@systemfsoftware/omp-agent-discipline 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,953 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+//#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;
+}
+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,
+		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 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) {
+			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$1(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 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);
+	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$1(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);
+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 ../../../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 ../omp-utils/dist/index.js
+/**
+* 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 {}
+	};
+}
+/**
+* `systemfsoftware.toml` loader — unified config for all systemfsoftware OMP extensions.
+*
+* Parsed with @std/toml. Cached per cwd. Missing file → `{}` (no config is fine).
+* Malformed TOML → fail open (`{}`) + one warn via the injected logger (never throws:
+* a config typo must not freeze extension behavior).
+*/
+const CONFIG_FILE = "systemfsoftware.toml";
+const cache = /* @__PURE__ */ new Map();
+const warnedFiles = /* @__PURE__ */ new Set();
+/**
+* Load `systemfsoftware.toml` from `cwd`. Cached per cwd.
+* `warn` receives at most one message per malformed file (defaults to a no-op).
+*/
+function loadToml(cwd, warn = () => {}) {
+	const cached = cache.get(cwd);
+	if (cached !== void 0) return cached;
+	const configPath = join(cwd, CONFIG_FILE);
+	let config = {};
+	if (existsSync(configPath)) try {
+		const parsed = parse(readFileSync(configPath, "utf-8"));
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) config = Object.fromEntries(Object.entries(parsed).map(([key, value]) => [key, Array.isArray(value) ? value.filter((v) => typeof v === "string") : []]));
+	} catch (error) {
+		if (!warnedFiles.has(configPath)) {
+			warnedFiles.add(configPath);
+			warn(`[toml-loader] malformed ${CONFIG_FILE} at ${configPath} — failing open (no config)`);
+			warn(error instanceof Error ? error.message : "unknown parse error");
+		}
+	}
+	cache.set(cwd, config);
+	return config;
+}
+//#endregion
+//#region src/no-skill-delegation.ts
+/** Module-scoped telemetry emitter, initialized in the default export. */
+let tel$1 = () => {};
+const compiledCache = /* @__PURE__ */ new Map();
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileGuard(names) {
+	if (names.length === 0) return null;
+	const nameGroup = "(?:" + names.map(escapeRegex).join("|") + ")";
+	return {
+		protectedSkills: new Set(names),
+		delegationVerbs: [
+			new RegExp("\\binvoke\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bdispatch\\s+(?:to\\s+)?(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bwrap\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\s+in\\s+(?:a\\s+)?(?:task|agent|subagent)\\b", "i"),
+			new RegExp("\\bdelegate\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\brun\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\s+(?:via|in)\\s+(?:a\\s+)?(?:subagent|task|agent)\\b", "i"),
+			new RegExp("\\b(?:run|execute|launch)\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bskill:\\s*[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bskill:\\/\\/" + nameGroup + "\\b", "i"),
+			new RegExp("(?:^|\\W)[`/]" + nameGroup + "(?=$|\\b|\\W)", "i"),
+			new RegExp("(?:^|\\W)/" + nameGroup + "(?=$|\\b|\\W)", "i"),
+			new RegExp("\\buse\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bload\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bspawn\\s+(?:a\\s+)?(?:task|agent|subagent|worker)\\s+(?:with|using)\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bcall\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bsend\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bcreate\\s+(?:a\\s+)?(?:task|agent|subagent)\\s+(?:with|using)\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bstart\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i")
+		],
+		referenceVerbs: [
+			new RegExp("\\bsee\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bper\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\bread\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i"),
+			new RegExp("\\baccording\\s+to\\s+(?:the\\s+)?[`/]?" + nameGroup + "\\b", "i")
+		],
+		mentionPatterns: new Map(names.map((name) => [name, new RegExp("(?:^|[\\s/.`\"])" + escapeRegex(name) + "(?=$|[\\s/.`\"]|\\b)", "i")]))
+	};
+}
+function getCompiledGuard(cwd) {
+	const cached = compiledCache.get(cwd);
+	if (cached !== void 0) return cached;
+	const compiled = compileGuard(loadToml(cwd)["no_delegate_skills"] ?? []);
+	if (compiled !== null) compiledCache.set(cwd, compiled);
+	return compiled;
+}
+function readString(input, ...keys) {
+	for (const key of keys) {
+		const value = input[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return "";
+}
+function denyMessage(skill, how, excerpt) {
+	return [
+		`⛔ BLOCKED: "${skill}" must not be delegated to a subagent.`,
+		`Detected in ${how}: ${excerpt}`,
+		"",
+		`REQUIRED: invoke ${skill} directly in THIS session via the host Skill / Tool call,`,
+		"then pass its return envelope to the next step. Do NOT wrap it in a task / Agent dispatch.",
+		"",
+		"WHY: a subagent reproduces the shape but loses the skill protocol — plan-path gate,",
+		"headless review contract, and pipeline-vs-chat mode. The contract does not survive the hop.",
+		"",
+		"RULE: root AGENTS.md §\"Skill invocations\" (SK1/SK2)."
+	].join("\n");
+}
+function noSkillDelegationExtension(pi) {
+	tel$1 = createTelemetry("agent_discipline", pi.logger);
+	pi.on("tool_call", (event, ctx) => {
+		const guard = getCompiledGuard(ctx.cwd);
+		if (guard === null) return void 0;
+		const toolName = event.toolName.toLowerCase();
+		if (toolName !== "task" && toolName !== "agent") return void 0;
+		const input = event.input;
+		const subagentType = readString(input, "subagent_type", "agent");
+		if (subagentType !== "" && guard.protectedSkills.has(subagentType)) {
+			tel$1("delegation.blocked", {
+				skill: subagentType,
+				how: "subagent_type"
+			});
+			return {
+				block: true,
+				reason: denyMessage(subagentType, "subagent_type", subagentType)
+			};
+		}
+		const prompt = readString(input, "prompt", "task", "description");
+		if (prompt !== "") {
+			const mentioned = [...guard.mentionPatterns.entries()].filter(([, pattern]) => pattern.test(prompt)).map(([name]) => name);
+			if (mentioned.length > 0 && guard.referenceVerbs.every((re) => !re.test(prompt)) && guard.delegationVerbs.some((re) => re.test(prompt))) {
+				const skill = mentioned[0];
+				const matched = guard.delegationVerbs.map((re) => re.exec(prompt)).find((m) => m !== null);
+				const excerpt = matched !== void 0 ? matched[0] : prompt.slice(0, 120);
+				tel$1("delegation.blocked", {
+					skill,
+					how: "prompt"
+				});
+				return {
+					block: true,
+					reason: denyMessage(skill, "prompt", excerpt)
+				};
+			}
+		}
+	});
+}
+//#endregion
+//#region src/xd-retry-guard.ts
+const NOT_FOUND_RE = /Tool ([A-Za-z0-9_:-]+) not found/i;
+const XD_PREFIX = "xd://";
+const ledger = /* @__PURE__ */ new Map();
+const LEDGER_MAX_SIZE = 50;
+/** Module-scoped telemetry emitter, initialized in the default export. */
+let tel = () => {};
+function isTextBlock(value) {
+	return typeof value === "object" && value !== null && "text" in value && typeof value.text === "string";
+}
+function resultText(result) {
+	if (typeof result !== "object" || result === null || !("content" in result)) return "";
+	const content = result.content;
+	if (!Array.isArray(content)) return "";
+	return content.filter(isTextBlock).map((block) => block.text).join("\n");
+}
+function buildReminder(entries) {
+	return `<system-reminder>
+A previous tool call failed with "Tool X not found". These tools are listed under "# xd:// Tool Devices" in the system prompt — they are NOT function-call tools. Invoking them by name fails; invoking them via the write tool to their xd:// URL executes them.
+
+Unresolved failures:
+${entries.map((entry) => `- "${entry.tool}": retry NOW by calling the write tool with path "xd://${entry.tool}" and content = the JSON args object (read "xd://${entry.tool}" first for its schema).`).join("\n")}
+
+Do NOT concede unavailability and do NOT continue other work leaving these unretried. This reminder re-injects on every model call until each retry executes (a write to the xd:// URL clears its entry).
+</system-reminder>`;
+}
+function xdRetryGuardExtension(pi) {
+	tel = createTelemetry("agent_discipline", pi.logger);
+	pi.on("tool_execution_end", (event, _ctx) => {
+		if (!event.isError) return;
+		const match = NOT_FOUND_RE.exec(resultText(event.result));
+		if (!match) return;
+		const tool = match[1];
+		if (tool === void 0) return;
+		const existing = ledger.get(tool);
+		if (existing) existing.failures += 1;
+		else {
+			if (ledger.size >= LEDGER_MAX_SIZE) {
+				const firstKey = ledger.keys().next().value;
+				if (firstKey !== void 0) ledger.delete(firstKey);
+			}
+			ledger.set(tool, {
+				tool,
+				failures: 1,
+				remindedAtFailure: 0
+			});
+			tel("guard.fired", {
+				tool,
+				count: ledger.size
+			});
+		}
+	});
+	pi.on("tool_execution_start", (event, _ctx) => {
+		if (event.toolName !== "write") return;
+		if (typeof event.args !== "object" || event.args === null || !("path" in event.args)) return;
+		const path = event.args.path;
+		if (typeof path !== "string" || !path.startsWith(XD_PREFIX)) return;
+		const device = path.slice(5).split(/[/?#]/)[0];
+		if (device === void 0 || device.length === 0) return;
+		if (ledger.delete(device)) tel("guard.cleared", {
+			tool: device,
+			count: ledger.size
+		});
+	});
+	pi.on("context", (event) => {
+		if (ledger.size === 0) return void 0;
+		const unresolved = [...ledger.values()].filter((e) => e.failures > e.remindedAtFailure);
+		if (unresolved.length === 0) return void 0;
+		tel("guard.reminded", { count: unresolved.length });
+		const reminder = buildReminder(unresolved);
+		for (const entry of unresolved) entry.remindedAtFailure = entry.failures;
+		return { messages: [...event.messages, {
+			role: "user",
+			content: [{
+				type: "text",
+				text: reminder
+			}],
+			timestamp: Date.now()
+		}] };
+	});
+}
+//#endregion
+//#region src/index.ts
+function agentDisciplineExtension(pi) {
+	xdRetryGuardExtension(pi);
+	noSkillDelegationExtension(pi);
+}
+//#endregion
+export { agentDisciplineExtension as default };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@systemfsoftware/omp-agent-discipline",
+  "license": "MIT",
+  "version": "0.0.0",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
+  "description": "OMP agent discipline: mechanical enforcement of rules prose can't hold (xd:// retry guard, ...)",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "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/omp-utils": "^0.0.0",
+    "@systemfsoftware/tsconfig": "^1.1.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:fs node:path",
+    "postbuild": "pnpm verify-dist",
+    "typecheck": "tsc --noEmit --incremental",
+    "test": "vitest run",
+    "lint": "oxlint . ${AGENT:+--format=unix --quiet}"
+  }
+}