@systemfsoftware/omp-claude-compat 0.0.0 → 1.1.3

package/dist/index.js

@@ -1,6 +1,11 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, extname, isAbsolute, resolve, sep } from "node:path";
-import { execFile } from "node:child_process";
+import { Cause, Config, Context, Effect, Either, Exit, Layer, ManagedRuntime, Match, MutableHashMap, Option, ParseResult, Ref, Schema, Stream } from "effect";
+import { CommandExecutor } from "@effect/platform/CommandExecutor";
+import { FileSystem } from "@effect/platform/FileSystem";
+import * as PathModule from "@effect/platform/Path";
+import { Path } from "@effect/platform/Path";
+import { Command } from "@effect/platform";
+import { homedir } from "node:os";
+import { NodeCommandExecutor, NodeFileSystem } from "@effect/platform-node";
 //#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",
@@ -84,6 +89,70 @@ function getKeys(record) {
 */ function isLeap(yearNumber) {
 	return yearNumber % 4 === 0 && yearNumber % 100 !== 0 || yearNumber % 400 === 0;
 }
+var Scanner = class {
+	#whitespace = /[ \t]/;
+	#position = 0;
+	#source;
+	constructor(source) {
+		this.#source = source;
+	}
+	get position() {
+		return this.#position;
+	}
+	get source() {
+		return this.#source;
+	}
+	/**
+	* Get current character
+	* @param index - relative index from current position
+	*/ char(index = 0) {
+		return this.#source[this.#position + index] ?? "";
+	}
+	/**
+	* Get sliced string
+	* @param start - start position relative from current position
+	* @param end - end position relative from current position
+	*/ slice(start, end) {
+		return this.#source.slice(this.#position + start, this.#position + end);
+	}
+	/**
+	* Move position to next
+	*/ next(count = 1) {
+		this.#position += count;
+	}
+	skipWhitespaces() {
+		while (this.#whitespace.test(this.char()) && !this.eof()) this.next();
+		if (!this.isCurrentCharEOL() && /\s/.test(this.char())) {
+			const escaped = "\\u" + this.char().charCodeAt(0).toString(16);
+			const position = this.#position;
+			throw new SyntaxError(`Cannot parse the TOML: It contains invalid whitespace at position '${position}': \`${escaped}\``);
+		}
+	}
+	nextUntilChar(options = { skipComments: true }) {
+		while (!this.eof()) {
+			const char = this.char();
+			if (this.#whitespace.test(char) || this.isCurrentCharEOL()) this.next();
+			else if (options.skipComments && this.char() === "#") while (!this.isCurrentCharEOL() && !this.eof()) this.next();
+			else break;
+		}
+	}
+	/**
+	* Position reached EOF or not
+	*/ eof() {
+		return this.#position >= this.#source.length;
+	}
+	isCurrentCharEOL() {
+		return this.char() === "\n" || this.startsWith("\r\n");
+	}
+	startsWith(searchString) {
+		return this.#source.startsWith(searchString, this.#position);
+	}
+	match(regExp) {
+		if (!regExp.sticky) throw new Error(`RegExp ${regExp} does not have a sticky 'y' flag`);
+		regExp.lastIndex = this.#position;
+		return this.#source.match(regExp);
+	}
+};
 function success(body) {
 	return {
 		ok: true,
@@ -100,6 +169,66 @@ function failure() {
 */ function unflat(keys, values = { __proto__: null }) {
 	return keys.reduceRight((acc, key) => ({ [key]: acc }), values);
 }
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function getTargetValue(target, keys) {
+	const key = keys[0];
+	if (!key) throw new Error("Cannot parse the TOML: key length is not a positive number");
+	return target[key];
+}
+function deepAssignTable(target, table) {
+	const { keys, type, value } = table;
+	const currentValue = getTargetValue(target, keys);
+	if (currentValue === void 0) return Object.assign(target, unflat(keys, value));
+	if (Array.isArray(currentValue)) {
+		deepAssign(currentValue.at(-1), {
+			type,
+			keys: keys.slice(1),
+			value
+		});
+		return target;
+	}
+	if (isObject(currentValue)) {
+		deepAssign(currentValue, {
+			type,
+			keys: keys.slice(1),
+			value
+		});
+		return target;
+	}
+	throw new Error("Unexpected assign");
+}
+function deepAssignTableArray(target, table) {
+	const { type, keys, value } = table;
+	const currentValue = getTargetValue(target, keys);
+	if (currentValue === void 0) return Object.assign(target, unflat(keys, [value]));
+	if (Array.isArray(currentValue)) {
+		if (table.keys.length === 1) currentValue.push(value);
+		else deepAssign(currentValue.at(-1), {
+			type: table.type,
+			keys: table.keys.slice(1),
+			value: table.value
+		});
+		return target;
+	}
+	if (isObject(currentValue)) {
+		deepAssign(currentValue, {
+			type,
+			keys: keys.slice(1),
+			value
+		});
+		return target;
+	}
+	throw new Error("Unexpected assign");
+}
+function deepAssign(target, body) {
+	switch (body.type) {
+		case "Block": return deepMerge(target, body.value);
+		case "Table": return deepAssignTable(target, body);
+		case "TableArray": return deepAssignTableArray(target, body);
+	}
+}
 function or(parsers) {
 	return (scanner) => {
 		for (const parse of parsers) {
@@ -163,6 +292,28 @@ function kv(keyParser, separator, valueParser) {
 		return success(unflat(key.body, value.body));
 	};
 }
+function merge(parser) {
+	return (scanner) => {
+		const result = parser(scanner);
+		if (!result.ok) return failure();
+		let body = { __proto__: null };
+		for (const record of result.body) if (typeof record === "object" && record !== null) body = deepMerge(body, record);
+		return success(body);
+	};
+}
+function repeat(parser) {
+	return (scanner) => {
+		const body = [];
+		while (!scanner.eof()) {
+			const result = parser(scanner);
+			if (!result.ok) break;
+			body.push(result.body);
+			scanner.nextUntilChar();
+		}
+		if (body.length === 0) return failure();
+		return success(body);
+	};
+}
 function surround(left, parser, right) {
 	const Left = character(left);
 	const Right = character(right);
@@ -473,10 +624,93 @@ const value = or([
 	inlineTable
 ]);
 const pair = kv(dottedKey, "=", value);
-surround("[", dottedKey, "]");
-surround("[[", dottedKey, "]]");
+function block(scanner) {
+	scanner.nextUntilChar();
+	const result = merge(repeat(pair))(scanner);
+	if (result.ok) return success({
+		type: "Block",
+		value: result.body
+	});
+	return failure();
+}
+const tableHeader = surround("[", dottedKey, "]");
+function table(scanner) {
+	scanner.nextUntilChar();
+	const header = tableHeader(scanner);
+	if (!header.ok) return failure();
+	scanner.nextUntilChar();
+	const b = block(scanner);
+	return success({
+		type: "Table",
+		keys: header.body,
+		value: b.ok ? b.body.value : { __proto__: null }
+	});
+}
+const tableArrayHeader = surround("[[", dottedKey, "]]");
+function tableArray(scanner) {
+	scanner.nextUntilChar();
+	const header = tableArrayHeader(scanner);
+	if (!header.ok) return failure();
+	scanner.nextUntilChar();
+	const b = block(scanner);
+	return success({
+		type: "TableArray",
+		keys: header.body,
+		value: b.ok ? b.body.value : { __proto__: null }
+	});
+}
+function toml(scanner) {
+	const blocks = repeat(or([
+		block,
+		tableArray,
+		table
+	]))(scanner);
+	if (!blocks.ok) return success({ __proto__: null });
+	return success(blocks.body.reduce(deepAssign, { __proto__: null }));
+}
+function createParseErrorMessage(scanner, message) {
+	const lines = scanner.source.slice(0, scanner.position).split("\n");
+	return `Parse error on line ${lines.length}, column ${lines.at(-1)?.length ?? 0}: ${message}`;
+}
+function parserFactory(parser) {
+	return (tomlString) => {
+		const scanner = new Scanner(tomlString);
+		try {
+			const result = parser(scanner);
+			if (result.ok && scanner.eof()) return result.body;
+			const message = `Unexpected character: "${scanner.char()}"`;
+			throw new SyntaxError(createParseErrorMessage(scanner, message));
+		} catch (error) {
+			if (error instanceof Error) throw new SyntaxError(createParseErrorMessage(scanner, error.message));
+			throw new SyntaxError(createParseErrorMessage(scanner, "Invalid error type caught"));
+		}
+	};
+}
 //#endregion
-//#region ../omp-utils/dist/index.js
+//#region ../../../node_modules/.pnpm/@jsr+std__toml@1.0.11/node_modules/@jsr/std__toml/parse.js
+/**
+* Parses a {@link https://toml.io | TOML} string into an object.
+*
+* @example Usage
+* ```ts
+* import { parse } from "@std/toml/parse";
+* import { assertEquals } from "@std/assert";
+*
+* const tomlString = `title = "TOML Example"
+* [owner]
+* name = "Alice"
+* bio = "Alice is a programmer."`;
+*
+* const obj = parse(tomlString);
+* assertEquals(obj, { title: "TOML Example", owner: { name: "Alice", bio: "Alice is a programmer." } });
+* ```
+* @param tomlString TOML string to be parsed.
+* @returns The parsed JS object.
+*/ function parse(tomlString) {
+	return parserFactory(toml)(tomlString);
+}
+//#endregion
+//#region ../../packages/omp-utils/dist/index.js
 /**
 * ACL: detect and extract shell commands from context-mode tool invocations.
 *
@@ -538,6 +772,63 @@ function createTelemetry(plugin, logger) {
 	};
 }
 /**
+* Schema: TOML config — the inner vocabulary of `systemfsoftware.toml`.
+*
+* Shape: a record of string key to string array. The only consumer of the inner
+* keys is the agent-discipline plugin (it reads `no_delegate_skills`); other
+* plugins may add their own keys without this schema changing. Branding makes
+* a parsed config distinguishable from a raw record and surfaces shape errors
+* through the loader's parse path.
+*
+* Pure declaration. No behavior, no `@std/toml`, no I/O. The ACL owns the
+* boundary crossing; the executor owns the I/O.
+*/
+const TomlConfig = Schema.Record({
+	key: Schema.String,
+	value: Schema.Array(Schema.String)
+}).pipe(Schema.brand("TomlConfig"));
+/**
+* ACL: TOML text → `TomlConfig`.
+*
+* The only file in this package that imports `@std/toml`. Anything that
+* decodes from outside the domain types routes through here so the foreign
+* parser is contained at one boundary.
+*
+* `Schema.transformOrFail` with `strict: true` makes the decode go through
+* Schema's identity contract — branding is earned by `ParseResult.decode`,
+* never by a cast. Encode is `Forbidden` because the TOML format is the
+* source, not the destination. Constitutes ACL1 (see `omp/AGENTS.md`).
+*/
+const TomlConfigFromText = Schema.transformOrFail(Schema.String, Schema.typeSchema(TomlConfig), {
+	strict: true,
+	decode: (raw) => ParseResult.try({
+		try: () => parse(raw),
+		catch: (e) => new ParseResult.Unexpected(e, "TOML parse error")
+	}).pipe(ParseResult.flatMap((parsed) => ParseResult.decodeUnknown(TomlConfig)(parsed))),
+	encode: (_, _d, ast) => ParseResult.fail(new ParseResult.Forbidden(ast, _, "TomlConfigFromText is decode-only"))
+});
+const CONFIG_FILE = "systemfsoftware.toml";
+const EMPTY_CONFIG = Schema.decodeSync(TomlConfig)({});
+var TomlLoader = class extends Context.Tag("TomlLoader")() {};
+Layer.effect(TomlLoader, Effect.gen(function* () {
+	const cache = yield* Ref.make(MutableHashMap.empty());
+	const fs = yield* FileSystem;
+	const path = yield* Path;
+	return TomlLoader.of({ load: Effect.fn("TomlLoader.load")(function* (cwd) {
+		const cached = yield* Ref.get(cache);
+		const existing = MutableHashMap.get(cached, cwd);
+		if (Option.isSome(existing)) return existing.value;
+		const configPath = path.join(cwd, CONFIG_FILE);
+		if (!(yield* fs.exists(configPath))) {
+			yield* Ref.update(cache, (m) => (MutableHashMap.set(m, cwd, EMPTY_CONFIG), m));
+			return EMPTY_CONFIG;
+		}
+		const result = yield* fs.readFileString(configPath).pipe(Effect.flatMap(Schema.decodeUnknown(TomlConfigFromText)), Effect.tapError((error) => Effect.logWarning(`[toml-loader] malformed ${CONFIG_FILE} at ${configPath} — failing open (no config)`, error)), Effect.catchAll(() => Effect.succeed(EMPTY_CONFIG)));
+		yield* Ref.update(cache, (m) => (MutableHashMap.set(m, cwd, result), m));
+		return result;
+	}) });
+}));
+/**
 * ACL: translate OMP tool input shapes to Claude Code hook input shapes.
 *
 * OMP sends `edits: [{ old_text, new_text }]` and `path`;
@@ -592,223 +883,288 @@ function normalizeToolName(name) {
 	if (name.length === 0) return name;
 	return name.charAt(0).toUpperCase() + name.slice(1);
 }
+Schema.Struct({
+	code: Schema.Number,
+	stdout: Schema.String,
+	stderr: Schema.String
+});
+var Block = class extends Schema.TaggedClass()("Block", { reason: Schema.String }) {};
+var Allow = class extends Schema.TaggedClass()("Allow", {}) {};
+var Warning = class extends Schema.TaggedClass()("Warning", { message: Schema.String }) {};
+Schema.Union(Block, Allow, Warning);
+var Blocked = class extends Schema.TaggedClass()("Blocked", { reason: Schema.String }) {};
+var Continue = class extends Schema.TaggedClass()("Continue", {
+	warning: Schema.optional(Schema.String),
+	updatedInput: Schema.optional(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	}))
+}) {};
+Schema.Union(Blocked, Continue);
 //#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
+//#region src/hook-output.acl.ts
+const ParsedHookOutputSchema = Schema.Struct({
+	decision: Schema.optional(Schema.String),
+	reason: Schema.optional(Schema.String),
+	hookSpecificOutput: Schema.optional(Schema.Struct({
+		permissionDecision: Schema.optional(Schema.String),
+		permissionDecisionReason: Schema.optional(Schema.String),
+		updatedInput: Schema.optional(Schema.Record({
+			key: Schema.String,
+			value: Schema.Unknown
+		}))
+	}))
+});
+const parseHookOutput = Schema.decodeUnknownEither(Schema.parseJson(ParsedHookOutputSchema));
+//#endregion
+//#region src/hook-settings.acl.ts
+const HookCommand = Schema.Struct({
+	type: Schema.Literal("command"),
+	command: Schema.String,
+	async: Schema.optional(Schema.Boolean),
+	timeout: Schema.optional(Schema.Number)
+});
+const HookEntry = Schema.Struct({
+	matcher: Schema.optional(Schema.String),
+	hooks: Schema.Array(HookCommand)
+});
+const HookGroups = Schema.Struct({
+	PreToolUse: Schema.optionalWith(Schema.Array(HookEntry), {
+		exact: true,
+		default: () => []
+	}),
+	PostToolUse: Schema.optionalWith(Schema.Array(HookEntry), {
+		exact: true,
+		default: () => []
+	}),
+	UserPromptSubmit: Schema.optionalWith(Schema.Array(HookEntry), {
+		exact: true,
+		default: () => []
+	}),
+	Stop: Schema.optionalWith(Schema.Array(HookEntry), {
+		exact: true,
+		default: () => []
+	}),
+	SessionStart: Schema.optionalWith(Schema.Array(HookEntry), {
+		exact: true,
+		default: () => []
+	}),
+	SessionEnd: Schema.optionalWith(Schema.Array(HookEntry), {
+		exact: true,
+		default: () => []
+	})
+});
+const SettingsWrapped = Schema.Struct({
+	hooks: HookGroups,
+	disableAllHooks: Schema.optional(Schema.Boolean)
+});
+const SettingsFlat = Schema.Struct({
+	...HookGroups.fields,
+	disableAllHooks: Schema.optional(Schema.Boolean)
+});
+const SettingsJSON = Schema.Union(SettingsWrapped, SettingsFlat);
+const decodeSettings = Schema.decodeUnknownEither(SettingsJSON);
+function parseSettings(json) {
+	return Either.map(decodeSettings(json), (s) => {
+		if ("hooks" in s) return s;
+		const { disableAllHooks: d, ...hookGroups } = s;
+		return {
+			hooks: hookGroups,
+			disableAllHooks: d
 		};
 	});
-	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;
+const ALL_HOOK_EVENTS = [
+	"PreToolUse",
+	"PostToolUse",
+	"UserPromptSubmit",
+	"SessionStart",
+	"SessionEnd",
+	"Stop"
+];
+function mergeSettings(settings) {
+	const merged = { hooks: {
+		PreToolUse: [],
+		PostToolUse: [],
+		UserPromptSubmit: [],
+		SessionStart: [],
+		SessionEnd: [],
+		Stop: []
+	} };
+	for (const s of settings) {
+		for (const event of ALL_HOOK_EVENTS) merged.hooks[event] = (merged.hooks[event] ?? []).concat(Array.from(s.hooks[event]));
+		if (s.disableAllHooks !== void 0) merged.disableAllHooks = s.disableAllHooks;
 	}
+	return merged;
+}
+function isHooksDisabled(settings) {
+	return settings.disableAllHooks === true;
 }
-function resolveCommand(command, cwd) {
+//#endregion
+//#region src/hook-verdict.workflow.ts
+var HookVerdictError = class extends Schema.TaggedError()("HookVerdictError", { raw: Schema.String }) {};
+var ExitBlock = class extends Schema.TaggedClass()("ExitBlock", {}) {};
+var ExitParse = class extends Schema.TaggedClass()("ExitParse", {}) {};
+var ExitOther = class extends Schema.TaggedClass()("ExitOther", {}) {};
+Schema.Union(ExitBlock, ExitParse, ExitOther);
+const classifyExit = (code) => Match.value(code).pipe(Match.when(2, () => new ExitBlock({})), Match.when(0, () => new ExitParse({})), Match.orElse(() => new ExitOther({})));
+const blockReason = (stderr, event) => Match.value(stderr.trim()).pipe(Match.when("", () => `Blocked by ${event} hook`), Match.orElse((trimmed) => trimmed));
+const decideFromParsed = (parsed, event) => Match.value(parsed.hookSpecificOutput?.permissionDecision ?? parsed.decision).pipe(Match.when("deny", () => new Block({ reason: parsed.hookSpecificOutput?.permissionDecisionReason ?? `Blocked by ${event} hook` })), Match.when("block", () => new Block({ reason: parsed.reason ?? `Blocked by ${event} hook` })), Match.orElse(() => new Allow({})));
+const decideFromNonStandardExit = (stderr) => Match.value(stderr.trim()).pipe(Match.when("", () => new Allow({})), Match.orElse((message) => new Warning({ message })));
+const interpretHookResult = (result, event) => Match.value(classifyExit(result.code)).pipe(Match.tag("ExitBlock", () => Either.right(new Block({ reason: blockReason(result.stderr, event) }))), Match.tag("ExitParse", () => Either.match(parseHookOutput(result.stdout), {
+	onLeft: () => Either.left(new HookVerdictError({ raw: result.stdout })),
+	onRight: (parsed) => Either.right(decideFromParsed(parsed, event))
+})), Match.tag("ExitOther", () => Either.right(decideFromNonStandardExit(result.stderr))), Match.exhaustive);
+//#endregion
+//#region src/hook-dispatcher.executor.ts
+var HookDispatcherExecutorDeps = class extends Context.Tag("HookDispatcherExecutorDeps")() {};
+function resolveCommandPath(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]
+		args: ["-c", trimmed.startsWith("\"") && trimmed.endsWith("\"") ? trimmed.slice(1, -1) : trimmed]
 	};
 }
-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,
+function hookNameFromCommand(command) {
+	return command.split(/[\\/]/).pop() ?? command;
+}
+const loadSettingsFile = Effect.fn("loadSettingsFile")(function* (path) {
+	const content = yield* (yield* FileSystem).readFileString(path).pipe(Effect.catchAll(() => Effect.succeed("")));
+	if (content === "") return null;
+	const jsonOrError = Schema.decodeUnknownEither(Schema.parseJson(Schema.Record({
+		key: Schema.String,
+		value: Schema.Unknown
+	})))(content);
+	if (Either.isLeft(jsonOrError)) return null;
+	const json = jsonOrError.right;
+	const either = parseSettings(json);
+	return Either.isLeft(either) ? null : either.right;
+});
+const loadSettings = Effect.fn("loadSettings")(function* (cwd) {
+	const paths = [
+		`${homedir()}/.claude/settings.json`,
+		`${cwd}/.claude/settings.json`,
+		`${cwd}/.claude/settings.local.json`,
+		"/etc/claude-code/managed-settings.json"
+	];
+	return yield* loadSettingsWithPaths(paths);
+});
+const loadSettingsWithPaths = Effect.fn("loadSettingsWithPaths")(function* (paths) {
+	const results = [];
+	for (const p of paths) {
+		const s = yield* loadSettingsFile(p);
+		if (s !== null) results.push(s);
+	}
+	if (results.length === 0) return null;
+	return mergeSettings(results);
+});
+const runHookScript = Effect.fn("runHookScript")(function* (command, input, cwd, timeoutMs) {
+	const executor = yield* CommandExecutor;
+	const { cmd, args } = resolveCommandPath(command, cwd);
+	const stdinText = JSON.stringify(input);
+	const hookCommand = Command.make(cmd, ...args).pipe(Command.workingDirectory(cwd), Command.env({
+		OMP_PROJECT_DIR: cwd,
+		CLAUDE_PROJECT_DIR: cwd
+	}), Command.feed(stdinText), Command.stdout("pipe"), Command.stderr("pipe"));
+	return yield* Effect.scoped(Effect.gen(function* () {
+		const process = yield* executor.start(hookCommand);
+		const stdout = yield* process.stdout.pipe(Stream.decodeText(), Stream.mkString);
+		const stderr = yield* process.stderr.pipe(Stream.decodeText(), Stream.mkString);
+		const exitCode = yield* process.exitCode;
+		return {
+			code: typeof exitCode === "number" ? exitCode : Number(exitCode),
 			stdout,
 			stderr
-		});
-	});
-	child.stdin?.on("error", () => {}).write(stdin);
-	child.stdin?.end();
-	return promise;
-}
-async function runHooksForEvent(entries, matchValue, input, ctx, event) {
+		};
+	})).pipe(Effect.timeout(timeoutMs), Effect.catchTag("TimeoutException", () => Effect.succeed({
+		code: -1,
+		stdout: "",
+		stderr: `timeout after ${timeoutMs}ms`
+	})));
+});
+const runHooksForEvent = Effect.fn("runHooksForEvent")(function* (entries, matchValue, input, ctx, event) {
 	const cwd = ctx.cwd;
+	const { tel } = yield* HookDispatcherExecutorDeps;
 	let warning;
 	let inputModified = false;
+	let currentInput = input;
 	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 hookName = hookNameFromCommand(hook.command);
 			const hookStart = performance.now();
+			const timeoutMs = (hook.timeout ?? 10) * 1e3;
 			if (hook.async) {
-				runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+				yield* Effect.forkDaemon(runHookScript(hook.command, currentInput, cwd, timeoutMs).pipe(Effect.tap((result) => Effect.sync(() => {
 					const durationMs = Math.round(performance.now() - hookStart);
 					tel("hook.executed", {
 						hook: hookName,
 						duration_ms: durationMs,
 						exit_code: result.code
 					});
-				}, (err) => {
+				})), Effect.catchAll(() => Effect.sync(() => {
 					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"
+						exit_code: null
 					});
-				});
+				}))));
 				continue;
 			}
-			let result;
-			try {
-				result = await runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3);
-			} catch (err) {
+			const result = yield* runHookScript(hook.command, currentInput, cwd, timeoutMs).pipe(Effect.tap((r) => Effect.sync(() => {
 				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"
+					exit_code: r.code
 				});
-				throw err;
-			}
-			const durationMs = Math.round(performance.now() - hookStart);
-			tel("hook.executed", {
-				hook: hookName,
-				duration_ms: durationMs,
-				exit_code: result.code
+			})), Effect.tapError(() => Effect.sync(() => {
+				const durationMs = Math.round(performance.now() - hookStart);
+				tel("hook.executed", {
+					hook: hookName,
+					duration_ms: durationMs,
+					exit_code: null
+				});
+			})));
+			const verdict = interpretHookResult(result, event);
+			const decision = Either.match(verdict, {
+				onLeft: (err) => Match.value(err).pipe(Match.tag("HookVerdictError", (e) => new Warning({ message: `Hook exited 0 but produced invalid JSON: ${e.raw.slice(0, 200)}` })), Match.exhaustive),
+				onRight: (d) => d
 			});
-			if (result.code === 2) return {
+			const outcome = Match.value(decision).pipe(Match.tag("Block", (d) => new Blocked({ reason: d.reason })), Match.tag("Warning", (d) => new Continue({ warning: d.message })), Match.tag("Allow", () => {
+				const either = parseHookOutput(result.stdout);
+				return new Continue({ updatedInput: Either.isRight(either) ? either.right.hookSpecificOutput?.updatedInput : void 0 });
+			}), Match.exhaustive);
+			const hookExit = Match.value(outcome).pipe(Match.tag("Blocked", (b) => Option.some({
 				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
+				reason: b.reason
+			})), Match.tag("Continue", (c) => {
+				if (c.warning !== void 0 && warning === void 0) warning = c.warning;
+				if (c.updatedInput !== void 0) {
+					currentInput = {
+						...currentInput,
+						...c.updatedInput
 					};
 					inputModified = true;
 				}
-			} catch {}
+				return Option.none();
+			}), Match.exhaustive);
+			if (Option.isSome(hookExit)) return hookExit.value;
 		}
 	}
 	return {
-		...inputModified ? { updatedInput: input } : {},
+		...inputModified ? { updatedInput: currentInput } : {},
 		...warning !== void 0 ? { warning } : {}
 	};
-}
-async function runPreToolUseHooks(settings, event, ctx) {
+});
+const runPreToolUseHooks = Effect.fn("runPreToolUseHooks")(function* (settings, event, ctx) {
+	const { tel } = yield* HookDispatcherExecutorDeps;
+	if (isHooksDisabled(settings)) return void 0;
 	const claudeToolName = normalizeToolName(event.toolName);
+	const sessionData = sessionIds(() => ctx.sessionManager.getSessionId());
 	const input = {
-		...getSessionIds(ctx),
+		...sessionData,
 		tool_name: claudeToolName,
 		tool_input: normalizeToolInput(claudeToolName, event.input),
 		tool_call_id: event.toolCallId
@@ -816,12 +1172,12 @@ async function runPreToolUseHooks(settings, event, ctx) {
 	const shellCommand = extractShellCommand(event.toolName, event.input);
 	if (shellCommand !== void 0 && shellCommand.length > 0) {
 		const bashInput = {
-			...getSessionIds(ctx),
+			...sessionData,
 			tool_name: "Bash",
 			tool_input: { command: shellCommand },
 			tool_call_id: event.toolCallId
 		};
-		const bashResult = await runHooksForEvent(settings.hooks.PreToolUse, "Bash", bashInput, ctx, "PreToolUse");
+		const bashResult = yield* runHooksForEvent(settings.hooks.PreToolUse, "Bash", bashInput, ctx, "PreToolUse");
 		if (bashResult.block) {
 			tel("tool_call.decision", {
 				tool_name: claudeToolName,
@@ -834,7 +1190,7 @@ async function runPreToolUseHooks(settings, event, ctx) {
 			};
 		}
 	}
-	const result = await runHooksForEvent(settings.hooks.PreToolUse, claudeToolName, input, ctx, "PreToolUse");
+	const result = yield* runHooksForEvent(settings.hooks.PreToolUse, claudeToolName, input, ctx, "PreToolUse");
 	if (result.block) {
 		tel("tool_call.decision", {
 			tool_name: claudeToolName,
@@ -854,31 +1210,33 @@ async function runPreToolUseHooks(settings, event, ctx) {
 		tool_name: claudeToolName,
 		decision: "allow"
 	});
-}
-async function runPostToolUseHooks(settings, event, ctx) {
+});
+const runPostToolUseHooks = Effect.fn("runPostToolUseHooks")(function* (settings, event, ctx) {
 	const claudeToolName = normalizeToolName(event.toolName);
+	if (isHooksDisabled(settings)) return void 0;
 	const input = {
-		...getSessionIds(ctx),
+		...sessionIds(() => ctx.sessionManager.getSessionId()),
 		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) {
+	return yield* runHooksForEvent(settings.hooks.PostToolUse, claudeToolName, input, ctx, "PostToolUse");
+});
+const runUserPromptSubmitHooks = Effect.fn("runUserPromptSubmitHooks")(function* (settings, event, ctx) {
 	const entries = settings.hooks.UserPromptSubmit;
+	if (isHooksDisabled(settings)) return void 0;
 	if (entries.length === 0) return void 0;
 	const cwd = ctx.cwd;
 	let injected = "";
 	const input = {
-		...getSessionIds(ctx),
+		...sessionIds(() => ctx.sessionManager.getSessionId()),
 		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);
+		const result = yield* 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;
@@ -887,173 +1245,249 @@ async function runUserPromptSubmitHooks(settings, event, ctx) {
 	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 runSessionStartHooks = Effect.fn("runSessionStartHooks")(function* (settings, reason, ctx) {
+	const { tel } = yield* HookDispatcherExecutorDeps;
+	if (isHooksDisabled(settings)) return;
 	const entries = settings.hooks.SessionStart;
 	if (entries.length === 0) return;
 	const cwd = ctx.cwd;
 	const input = {
-		...getSessionIds(ctx),
+		...sessionIds(() => ctx.sessionManager.getSessionId()),
 		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;
+			const hookName = hookNameFromCommand(hook.command);
+			const timeoutMs = (hook.timeout ?? 10) * 1e3;
 			if (hook.async) {
-				runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+				yield* Effect.forkDaemon(runHookScript(hook.command, input, cwd, timeoutMs).pipe(Effect.tap((result) => Effect.sync(() => {
 					tel("hook.executed", {
 						hook: hookName,
 						exit_code: result.code
 					});
-				}, (err) => {
+				})), Effect.catchAll(() => Effect.sync(() => {
 					tel("hook.executed", {
 						hook: hookName,
-						exit_code: null,
-						error: err instanceof Error ? err.message : "unknown error"
+						exit_code: null
 					});
-				});
+				}))));
 				continue;
 			}
-			await runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+			yield* runHookScript(hook.command, input, cwd, timeoutMs).pipe(Effect.tap((result) => Effect.sync(() => {
 				tel("hook.executed", {
 					hook: hookName,
 					exit_code: result.code
 				});
-			}, (err) => {
+			})), Effect.catchAll(() => Effect.sync(() => {
 				tel("hook.executed", {
 					hook: hookName,
-					exit_code: null,
-					error: err instanceof Error ? err.message : "unknown error"
+					exit_code: null
 				});
-			});
+			})));
 		}
 	}
-}
-async function runLifecycleHooks(entries, ctx) {
+});
+const runLifecycleHooks = Effect.fn("runLifecycleHooks")(function* (entries, ctx) {
 	if (entries.length === 0) return;
+	const { tel } = yield* HookDispatcherExecutorDeps;
 	const cwd = ctx.cwd;
-	const input = { ...getSessionIds(ctx) };
+	const input = { ...sessionIds(() => ctx.sessionManager.getSessionId()) };
 	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) => {
+		const hookName = hookNameFromCommand(hook.command);
+		const timeoutMs = (hook.timeout ?? 10) * 1e3;
+		if (hook.async) yield* Effect.forkDaemon(runHookScript(hook.command, input, cwd, timeoutMs).pipe(Effect.tap((result) => Effect.sync(() => {
 			tel("hook.executed", {
 				hook: hookName,
 				exit_code: result.code
 			});
-		}, (err) => {
+		})), Effect.catchAll(() => Effect.sync(() => {
 			tel("hook.executed", {
 				hook: hookName,
-				exit_code: null,
-				error: err instanceof Error ? err.message : "unknown error"
+				exit_code: null
 			});
-		});
-		else await runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+		}))));
+		else yield* runHookScript(hook.command, input, cwd, timeoutMs).pipe(Effect.tap((result) => Effect.sync(() => {
 			tel("hook.executed", {
 				hook: hookName,
 				exit_code: result.code
 			});
-		}, (err) => {
+		})), Effect.catchAll(() => Effect.sync(() => {
 			tel("hook.executed", {
 				hook: hookName,
-				exit_code: null,
-				error: err instanceof Error ? err.message : "unknown error"
+				exit_code: null
 			});
-		});
+		})));
 	}
-}
+});
 //#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);
+//#region src/runtime.ts
+const nodeLayer = NodeCommandExecutor.layer.pipe(Layer.provideMerge(NodeFileSystem.layer), Layer.provideMerge(PathModule.layer));
+const runtime = ManagedRuntime.make(nodeLayer);
+//#endregion
+//#region src/hook-dispatcher.handler.ts
+const HookDispatcherTask = (pi) => Layer.effectDiscard(Effect.sync(() => {
+	const tel = createTelemetry("claude_compat", pi.logger);
+	const telLayer = Layer.succeed(HookDispatcherExecutorDeps, { tel });
+	const runSafe = async (effect) => {
+		const exit = await runtime.runPromise(effect.pipe(Effect.provide(telLayer), Effect.exit));
+		if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+		return exit.value;
+	};
+	pi.on("tool_call", (event, ctx) => runSafe(Effect.gen(function* () {
+		const settings = yield* loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		return yield* runPreToolUseHooks(settings, event, ctx);
+	})));
+	pi.on("tool_result", (event, ctx) => runSafe(Effect.gen(function* () {
+		const settings = yield* loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		const result = yield* 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", (event, ctx) => runSafe(Effect.gen(function* () {
+		const settings = yield* loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		return yield* runUserPromptSubmitHooks(settings, event, ctx);
+	})));
+	pi.on("session_start", (_event, ctx) => runSafe(Effect.gen(function* () {
+		const settings = yield* loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		yield* runSessionStartHooks(settings, "start", ctx);
+	})));
+	pi.on("session_compact", (_event, ctx) => runSafe(Effect.gen(function* () {
+		const settings = yield* loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		yield* runSessionStartHooks(settings, "compact", ctx);
+	})));
+	pi.on("agent_start", (_event, ctx) => runSafe(Effect.gen(function* () {
+		const settings = yield* loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		yield* runSessionStartHooks(settings, "resume", ctx);
+	})));
+	pi.on("session_shutdown", (_event, ctx) => runSafe(Effect.gen(function* () {
+		const settings = yield* loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		if (settings.disableAllHooks) return void 0;
+		yield* runLifecycleHooks(settings.hooks.SessionEnd, ctx);
+	})));
+	pi.on("session_stop", (_event, ctx) => runSafe(Effect.gen(function* () {
+		const settings = yield* loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		if (settings.disableAllHooks) return void 0;
+		yield* runLifecycleHooks(settings.hooks.Stop, ctx);
+	})));
+}));
+//#endregion
+//#region src/inject-instructions.executor.ts
+const extractRefs = Effect.fn("extractRefs")(function* (content, baseDir, projectDir) {
+	const fs = yield* FileSystem;
+	const path = yield* PathModule.Path;
 	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;
+		if (path.isAbsolute(ref)) continue;
+		const baseResolved = path.resolve(baseDir, ref);
+		if (baseResolved.startsWith(projectDir + "/") || baseResolved === projectDir) {
+			const baseExists = yield* Effect.either(fs.exists(baseResolved));
+			if (Either.isRight(baseExists) && baseExists.right) {
+				refs.push({
+					sourcePath: baseDir,
+					resolvedPath: baseResolved
+				});
+				continue;
+			}
 		}
-		const rootResolved = resolve(projectDir, ref);
-		if ((rootResolved.startsWith(projectDir + sep) || rootResolved === projectDir) && existsSync(rootResolved)) refs.push({
-			sourcePath: filePath,
+		const rootResolved = path.resolve(projectDir, ref);
+		if ((rootResolved.startsWith(projectDir + "/") || rootResolved === projectDir) && rootResolved !== baseResolved) refs.push({
+			sourcePath: projectDir,
 			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 loadReferencedContent = Effect.fn("loadReferencedContent")(function* (projectDir) {
+	const fs = yield* FileSystem;
+	const path = yield* PathModule.Path;
+	const claudeMdPaths = [path.resolve(projectDir, "CLAUDE.md"), path.resolve(projectDir, ".claude", "CLAUDE.md")];
 	const allRefs = [];
-	for (const filePath of claudeMdPaths) if (existsSync(filePath)) allRefs.push(...extractRefs(filePath, projectDir));
+	for (const filePath of claudeMdPaths) {
+		const content = yield* Effect.either(fs.readFileString(filePath, "utf-8"));
+		if (Either.isRight(content)) {
+			const refs = yield* extractRefs(content.right, path.dirname(filePath), projectDir);
+			allRefs.push(...refs);
+		}
+	}
 	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 validRefs = [];
+	for (const ref of uniqueRefs) {
+		const exists = yield* Effect.either(fs.exists(ref.resolvedPath));
+		if (Either.isRight(exists) && exists.right) validRefs.push(ref);
+	}
+	if (validRefs.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) {
+	for (const ref of validRefs) {
 		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}]`);
-		}
+		const refContent = yield* Effect.either(fs.readFileString(ref.resolvedPath, "utf-8"));
+		if (Either.isRight(refContent)) parts.push(refContent.right);
+		else 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;
+});
+//#endregion
+//#region src/inject-instructions.handler.ts
+const InjectInstructionsTask = (pi) => Layer.effectDiscard(Effect.sync(() => {
+	pi.on("before_agent_start", async (event, _ctx) => {
+		const exit = await runtime.runPromise(Effect.gen(function* () {
+			return yield* loadReferencedContent(yield* Config.string("CLAUDE_PROJECT_DIR").pipe(Config.withDefault(process.cwd())));
+		}).pipe(Effect.exit));
+		if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+		const injected = exit.value;
+		if (injected === "") return void 0;
 		return { systemPrompt: [
 			...event.systemPrompt,
 			"",
-			cached
+			injected
 		] };
 	});
-}
+}));
 //#endregion
 //#region src/index.ts
 function claudeCompatExtension(pi) {
-	hookDispatcherExtension(pi);
-	injectInstructionsExtension(pi);
+	Effect.runSync(Effect.scoped(Layer.build(Layer.mergeAll(InjectInstructionsTask(pi), HookDispatcherTask(pi)))));
+	ManagedRuntime.make(Layer.mergeAll(InjectInstructionsTask(pi), HookDispatcherTask(pi)));
+	process.on("SIGINT", () => {
+		runtime.dispose();
+	});
+	process.on("SIGTERM", () => {
+		runtime.dispose();
+	});
 }
 //#endregion
 export { claudeCompatExtension as default };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/omp-claude-compat",
   "license": "MIT",
-  "version": "0.0.0",
+  "version": "1.1.3",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "description": "OMP Claude Code compatibility: dispatch .claude/settings.json hooks + inject CLAUDE.md @-references",
   "type": "module",
@@ -12,35 +12,50 @@
   "files": [
     "dist"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "@effect/platform": "^0.97.0",
+    "@effect/platform-node": "^0.97.0",
+    "effect": "^3.22.0"
+  },
   "peerDependencies": {
     "@oh-my-pi/pi-coding-agent": "^17.0.5"
   },
   "devDependencies": {
+    "@effect/vitest": "0.30.0",
     "@oh-my-pi/pi-coding-agent": "^17.0.5",
     "@types/node": "^24",
+    "fast-check": "^3",
     "rimraf": "^6.1.3",
     "tsdown": "^0.22.9",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/tsconfig": "^1.1.0",
+    "@systemfsoftware/effect-memfs": "^1.0.5",
+    "@systemfsoftware/effect-gherkin-spec": "^0.3.5",
     "@systemfsoftware/omp-utils": "^0.0.0",
-    "@systemfsoftware/oxlint-config": "^0.1.0"
+    "@systemfsoftware/oxlint-config": "^0.1.0",
+    "@systemfsoftware/tsconfig": "^1.2.4"
   },
   "omp": {
     "extensions": [
       "./dist/index.js"
     ]
   },
+  "publishConfig": {
+    "provenance": true
+  },
   "inlinedDependencies": {
     "@jsr/std__collections": "1.3.0",
     "@jsr/std__toml": "1.0.11"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
+    "directory": "omp/plugins/omp-claude-compat"
+  },
   "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",
+    "verify-dist": "node ../../scripts/check-dist-builtins.mjs --dist dist/index.js --expect os",
     "typecheck": "tsc --noEmit --incremental",
     "test": "vitest run",
     "lint": "oxlint . ${AGENT:+--format=unix --quiet}"