oh-my-opencode 4.8.1 → 4.9.1

package/packages/omo-codex/plugin/components/rules/dist/post-compact-state.d.ts

@@ -0,0 +1,13 @@
+export type PostCompactPendingKind = "static" | "dynamic";
+export interface PostCompactPendingState {
+    static?: boolean;
+    dynamic?: boolean;
+}
+export interface PostCompactStateFields {
+    readonly postCompactPending?: PostCompactPendingState;
+    readonly postCompactRecovering?: PostCompactPendingState;
+    readonly compacted?: boolean;
+}
+export declare function postCompactKindState(kinds: ReadonlySet<PostCompactPendingKind>): PostCompactPendingState | undefined;
+export declare function postCompactPendingKinds(state: PostCompactStateFields): Set<PostCompactPendingKind>;
+export declare function postCompactRecoveringKinds(state: PostCompactStateFields): Set<PostCompactPendingKind>;

package/packages/omo-codex/plugin/components/rules/dist/post-compact-state.js

@@ -0,0 +1,29 @@
+export function postCompactKindState(kinds) {
+    if (kinds.size === 0) {
+        return undefined;
+    }
+    return {
+        ...(kinds.has("static") ? { static: true } : {}),
+        ...(kinds.has("dynamic") ? { dynamic: true } : {}),
+    };
+}
+export function postCompactPendingKinds(state) {
+    const pendingKinds = new Set();
+    if (state.compacted === true || state.postCompactPending?.static === true) {
+        pendingKinds.add("static");
+    }
+    if (state.compacted === true || state.postCompactPending?.dynamic === true) {
+        pendingKinds.add("dynamic");
+    }
+    return pendingKinds;
+}
+export function postCompactRecoveringKinds(state) {
+    const recoveringKinds = new Set();
+    if (state.postCompactRecovering?.static === true) {
+        recoveringKinds.add("static");
+    }
+    if (state.postCompactRecovering?.dynamic === true) {
+        recoveringKinds.add("dynamic");
+    }
+    return recoveringKinds;
+}

package/packages/omo-codex/plugin/components/rules/dist/rules/cache.d.ts

@@ -0,0 +1,9 @@
+import type { LoadedRule, SessionState } from "./types.js";
+export declare function createSessionState(cwd?: string): SessionState;
+export declare function staticDedupKey(cwd: string, rulePath: string, contentHash: string): string;
+export declare function dynamicDedupKey(rulePath: string, contentHash: string): string;
+export declare function markStaticInjected(state: SessionState, rule: LoadedRule): boolean;
+export declare function markDynamicInjected(state: SessionState, rule: LoadedRule): boolean;
+export declare function isStaticInjected(state: SessionState, rule: LoadedRule): boolean;
+export declare function isDynamicInjected(state: SessionState, rule: LoadedRule): boolean;
+export declare function clearSession(state: SessionState): void;

package/packages/omo-codex/plugin/components/rules/dist/rules/cache.js

@@ -0,0 +1,51 @@
+const DYNAMIC_SESSION_KEY = "__pi-rules-session__";
+export function createSessionState(cwd) {
+    return {
+        cwd,
+        staticDedup: new Set(),
+        dynamicDedup: new Map(),
+        dynamicTargetFingerprints: new Map(),
+        loadedRules: [],
+        diagnostics: [],
+    };
+}
+export function staticDedupKey(cwd, rulePath, contentHash) {
+    return `${cwd}::${rulePath}::${contentHash}`;
+}
+export function dynamicDedupKey(rulePath, contentHash) {
+    return `${rulePath}::${contentHash}`;
+}
+export function markStaticInjected(state, rule) {
+    const key = staticDedupKey(state.cwd ?? "", rule.realPath, rule.contentHash);
+    if (state.staticDedup.has(key)) {
+        return false;
+    }
+    state.staticDedup.add(key);
+    return true;
+}
+export function markDynamicInjected(state, rule) {
+    let keys = state.dynamicDedup.get(DYNAMIC_SESSION_KEY);
+    if (keys === undefined) {
+        keys = new Set();
+        state.dynamicDedup.set(DYNAMIC_SESSION_KEY, keys);
+    }
+    const key = dynamicDedupKey(rule.realPath, rule.contentHash);
+    if (keys.has(key)) {
+        return false;
+    }
+    keys.add(key);
+    return true;
+}
+export function isStaticInjected(state, rule) {
+    return state.staticDedup.has(staticDedupKey(state.cwd ?? "", rule.realPath, rule.contentHash));
+}
+export function isDynamicInjected(state, rule) {
+    return state.dynamicDedup.get(DYNAMIC_SESSION_KEY)?.has(dynamicDedupKey(rule.realPath, rule.contentHash)) === true;
+}
+export function clearSession(state) {
+    state.staticDedup.clear();
+    state.dynamicDedup.clear();
+    state.dynamicTargetFingerprints.clear();
+    state.loadedRules.length = 0;
+    state.diagnostics.length = 0;
+}

package/packages/omo-codex/plugin/components/rules/dist/rules/constants.d.ts

@@ -0,0 +1,70 @@
+import type { RuleSource } from "./types.js";
+/**
+ * Project root marker files / directories used by `findProjectRoot`.
+ * Walks UP from cwd until any of these is found in the directory.
+ */
+export declare const PROJECT_MARKERS: readonly string[];
+/**
+ * Project rule subdirectories. First tuple element is the parent dir under
+ * the project root, second is the subdir scanned recursively.
+ */
+export declare const PROJECT_RULE_SUBDIRS: ReadonlyArray<readonly [string, string]>;
+/**
+ * Single-file project rules (always apply, frontmatter optional).
+ */
+export declare const PROJECT_SINGLE_FILES: readonly string[];
+/**
+ * User-home rule directories.
+ */
+export declare const USER_HOME_RULE_SUBDIRS: readonly string[];
+/**
+ * User-home single-file rules. The first one to exist wins per "first-match" semantics.
+ */
+export declare const USER_HOME_SINGLE_FILES: readonly string[];
+/**
+ * Bundled plugin rule directory relative to the rules component root.
+ */
+export declare const BUNDLED_RULE_SUBDIR = "bundled-rules";
+/**
+ * File extensions accepted as rule files in scanned directories.
+ */
+export declare const RULE_FILE_EXTENSIONS: readonly string[];
+/**
+ * Per-rule source priority for deterministic ordering. Lower = earlier.
+ */
+export declare const SOURCE_PRIORITY: ReadonlyMap<RuleSource, number>;
+/**
+ * Distance value assigned to global / user-home rules.
+ */
+export declare const GLOBAL_DISTANCE = 9999;
+/**
+ * Per-rule body character cap (default).
+ */
+export declare const DEFAULT_MAX_RULE_CHARS = 12000;
+export declare const DEFAULT_MAX_SCAN_FILES = 1000;
+/**
+ * Total injected chars per tool result (default).
+ */
+export declare const DEFAULT_MAX_RESULT_CHARS = 40000;
+export declare const DEFAULT_POST_COMPACT_MAX_RULE_CHARS = 3500;
+export declare const DEFAULT_POST_COMPACT_MAX_RESULT_CHARS = 4000;
+/**
+ * Per-rule / total caps for dynamic (PostToolUse) injection. Kept far below the
+ * static defaults so mid-session rule matches stay lightweight.
+ */
+export declare const DEFAULT_DYNAMIC_MAX_RULE_CHARS = 4000;
+export declare const DEFAULT_DYNAMIC_MAX_RESULT_CHARS = 10000;
+/**
+ * Per-rule / total caps for UserPromptSubmit static injection. SessionStart
+ * keeps the full budget; prompt-time stragglers inject at a reduced size.
+ */
+export declare const DEFAULT_PROMPT_MAX_RULE_CHARS = 6000;
+export declare const DEFAULT_PROMPT_MAX_RESULT_CHARS = 16000;
+/**
+ * Truncation marker template. `{path}` is replaced with the relative path.
+ */
+export declare const TRUNCATION_NOTICE = "\n\n[Truncated. Full: {path}]";
+/**
+ * Directories excluded by the recursive scanner regardless of glob settings.
+ */
+export declare const SCANNER_EXCLUDED_DIRS: readonly string[];

package/packages/omo-codex/plugin/components/rules/dist/rules/constants.js

@@ -0,0 +1,101 @@
+/**
+ * Project root marker files / directories used by `findProjectRoot`.
+ * Walks UP from cwd until any of these is found in the directory.
+ */
+export const PROJECT_MARKERS = [
+    ".git",
+    "pnpm-workspace.yaml",
+    "package.json",
+    "pyproject.toml",
+    "Cargo.toml",
+    "go.mod",
+    ".venv",
+];
+/**
+ * Project rule subdirectories. First tuple element is the parent dir under
+ * the project root, second is the subdir scanned recursively.
+ */
+export const PROJECT_RULE_SUBDIRS = [
+    [".omo", "rules"],
+    [".claude", "rules"],
+    [".cursor", "rules"],
+    [".github", "instructions"],
+];
+/**
+ * Single-file project rules (always apply, frontmatter optional).
+ */
+export const PROJECT_SINGLE_FILES = [".github/copilot-instructions.md", "CONTEXT.md"];
+/**
+ * User-home rule directories.
+ */
+export const USER_HOME_RULE_SUBDIRS = [".omo/rules", ".opencode/rules", ".claude/rules"];
+/**
+ * User-home single-file rules. The first one to exist wins per "first-match" semantics.
+ */
+export const USER_HOME_SINGLE_FILES = [];
+/**
+ * Bundled plugin rule directory relative to the rules component root.
+ */
+export const BUNDLED_RULE_SUBDIR = "bundled-rules";
+/**
+ * File extensions accepted as rule files in scanned directories.
+ */
+export const RULE_FILE_EXTENSIONS = [".md", ".mdc"];
+/**
+ * Per-rule source priority for deterministic ordering. Lower = earlier.
+ */
+export const SOURCE_PRIORITY = new Map([
+    [".omo/rules", 0],
+    [".claude/rules", 1],
+    [".cursor/rules", 2],
+    [".github/instructions", 3],
+    [".github/copilot-instructions.md", 4],
+    ["CONTEXT.md", 7],
+    ["~/.omo/rules", 100],
+    ["~/.opencode/rules", 101],
+    ["~/.claude/rules", 102],
+    ["plugin-bundled", 200],
+]);
+/**
+ * Distance value assigned to global / user-home rules.
+ */
+export const GLOBAL_DISTANCE = 9999;
+/**
+ * Per-rule body character cap (default).
+ */
+export const DEFAULT_MAX_RULE_CHARS = 12000;
+export const DEFAULT_MAX_SCAN_FILES = 1000;
+/**
+ * Total injected chars per tool result (default).
+ */
+export const DEFAULT_MAX_RESULT_CHARS = 40000;
+export const DEFAULT_POST_COMPACT_MAX_RULE_CHARS = 3500;
+export const DEFAULT_POST_COMPACT_MAX_RESULT_CHARS = 4000;
+/**
+ * Per-rule / total caps for dynamic (PostToolUse) injection. Kept far below the
+ * static defaults so mid-session rule matches stay lightweight.
+ */
+export const DEFAULT_DYNAMIC_MAX_RULE_CHARS = 4000;
+export const DEFAULT_DYNAMIC_MAX_RESULT_CHARS = 10000;
+/**
+ * Per-rule / total caps for UserPromptSubmit static injection. SessionStart
+ * keeps the full budget; prompt-time stragglers inject at a reduced size.
+ */
+export const DEFAULT_PROMPT_MAX_RULE_CHARS = 6000;
+export const DEFAULT_PROMPT_MAX_RESULT_CHARS = 16000;
+/**
+ * Truncation marker template. `{path}` is replaced with the relative path.
+ */
+export const TRUNCATION_NOTICE = "\n\n[Truncated. Full: {path}]";
+/**
+ * Directories excluded by the recursive scanner regardless of glob settings.
+ */
+export const SCANNER_EXCLUDED_DIRS = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".turbo",
+    ".next",
+    "coverage",
+];

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-dynamic-cache.d.ts

@@ -0,0 +1,5 @@
+import type { CandidateDiscoveryCache, DynamicMatchCache, EngineDeps } from "./engine-types.js";
+import type { matchRule } from "./matcher.js";
+import type { LoadedRule, MatchReason, RuleCandidate } from "./types.js";
+export declare function matchDynamicRuleCached(cache: DynamicMatchCache, projectRoot: string | null, targetFile: string, candidate: RuleCandidate, loadedRule: LoadedRule, matchRuleImpl: typeof matchRule): MatchReason | null;
+export declare function findSortedCandidatesCached(cache: CandidateDiscoveryCache, findCandidates: EngineDeps["findCandidates"], options: Parameters<EngineDeps["findCandidates"]>[0]): RuleCandidate[];

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-dynamic-cache.js

@@ -0,0 +1,60 @@
+import { dirname, resolve } from "node:path";
+import { pathBasesForTarget, toPosixPath } from "./engine-paths.js";
+import { sortCandidates } from "./ordering.js";
+const MAX_DYNAMIC_MATCH_CACHE_ENTRIES = 4096;
+export function matchDynamicRuleCached(cache, projectRoot, targetFile, candidate, loadedRule, matchRuleImpl) {
+    const cacheKey = dynamicMatchCacheKey(projectRoot, targetFile, candidate, loadedRule.contentHash);
+    if (cache.has(cacheKey)) {
+        const cachedReason = cache.get(cacheKey) ?? null;
+        cache.delete(cacheKey);
+        cache.set(cacheKey, cachedReason);
+        return cachedReason;
+    }
+    const matchResult = matchRuleImpl({
+        frontmatter: loadedRule.frontmatter,
+        isSingleFile: candidate.isSingleFile,
+        pathBases: pathBasesForTarget(projectRoot, targetFile, candidate),
+    });
+    const reason = matchResult.matched ? matchResult.reason : null;
+    setDynamicMatchCacheEntry(cache, cacheKey, reason);
+    return reason;
+}
+export function findSortedCandidatesCached(cache, findCandidates, options) {
+    const cacheKey = candidateDiscoveryCacheKey(options);
+    const cached = cache.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const candidates = sortCandidates(findCandidates(options));
+    cache.set(cacheKey, candidates);
+    return candidates;
+}
+function setDynamicMatchCacheEntry(cache, cacheKey, reason) {
+    if (cache.size >= MAX_DYNAMIC_MATCH_CACHE_ENTRIES) {
+        const oldestCacheKey = cache.keys().next().value;
+        if (oldestCacheKey !== undefined) {
+            cache.delete(oldestCacheKey);
+        }
+    }
+    cache.set(cacheKey, reason);
+}
+function dynamicMatchCacheKey(projectRoot, targetFile, candidate, contentHash) {
+    return [
+        projectRoot ?? "",
+        toPosixPath(resolve(targetFile)),
+        candidate.realPath,
+        candidate.relativePath,
+        candidate.source,
+        candidate.isGlobal ? "global" : "project",
+        candidate.isSingleFile ? "single" : "multi",
+        String(candidate.distance),
+        contentHash,
+    ].join("\0");
+}
+function candidateDiscoveryCacheKey(options) {
+    return [
+        options.projectRoot ?? "",
+        options.targetFile === null ? "" : dirname(resolve(options.targetFile)),
+        ...[...(options.disabledSources ?? [])].sort(),
+    ].join("\0");
+}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-dynamic-loader.d.ts

@@ -0,0 +1,6 @@
+import type { DynamicMatchCache, EngineDeps } from "./engine-types.js";
+import type { LoadedRule, PiRulesConfig, RuleDiagnostic } from "./types.js";
+export declare function loadDynamicCandidates(config: PiRulesConfig, deps: EngineDeps, cwd: string, targetPaths: ReadonlyArray<string>, dynamicMatchCache: DynamicMatchCache): {
+    rules: LoadedRule[];
+    diagnostics: RuleDiagnostic[];
+};

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-dynamic-loader.js

@@ -0,0 +1,61 @@
+import { findSortedCandidatesCached, matchDynamicRuleCached } from "./engine-dynamic-cache.js";
+import { loadCandidate, ruleDedupKey } from "./engine-loader.js";
+import { isSameOrChildPath } from "./engine-paths.js";
+import { createRuleDiscoveryCache } from "./finder.js";
+import { matchRule } from "./matcher.js";
+import { sortCandidates } from "./ordering.js";
+import { disabledSourcesFromConfig } from "./sources.js";
+export function loadDynamicCandidates(config, deps, cwd, targetPaths, dynamicMatchCache) {
+    const rules = [];
+    const diagnostics = [];
+    const seenRules = new Set();
+    const loadedRuleContent = new Map();
+    const projectMembership = new Map();
+    const disabledSources = disabledSourcesFromConfig(config);
+    const discoveryCache = createRuleDiscoveryCache();
+    const candidateDiscoveryCache = new Map();
+    const cwdProjectRoot = deps.findProjectRoot(cwd);
+    for (const targetFile of uniqueStrings(targetPaths)) {
+        const projectRoot = cwdProjectRoot !== null && isSameOrChildPath(targetFile, cwdProjectRoot)
+            ? cwdProjectRoot
+            : deps.findProjectRoot(targetFile);
+        const findOptions = {
+            projectRoot,
+            targetFile,
+            cache: discoveryCache,
+        };
+        if (disabledSources !== undefined) {
+            findOptions.disabledSources = disabledSources;
+        }
+        const candidates = findSortedCandidatesCached(candidateDiscoveryCache, deps.findCandidates, findOptions);
+        for (const candidate of candidates) {
+            const loadedRule = loadCandidate(candidate, deps, diagnostics, projectRoot, loadedRuleContent, projectMembership);
+            if (loadedRule === null) {
+                continue;
+            }
+            const matchReason = matchDynamicRuleCached(dynamicMatchCache, projectRoot, targetFile, candidate, loadedRule, deps.matchRule ?? matchRule);
+            if (matchReason === null) {
+                continue;
+            }
+            const dedupKey = ruleDedupKey(loadedRule);
+            if (seenRules.has(dedupKey)) {
+                continue;
+            }
+            seenRules.add(dedupKey);
+            rules.push({ ...loadedRule, matchReason });
+        }
+    }
+    return { rules: sortCandidates(rules), diagnostics };
+}
+function uniqueStrings(values) {
+    const uniqueValues = [];
+    const seenValues = new Set();
+    for (const value of values) {
+        if (seenValues.has(value)) {
+            continue;
+        }
+        seenValues.add(value);
+        uniqueValues.push(value);
+    }
+    return uniqueValues;
+}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-loader.d.ts

@@ -0,0 +1,7 @@
+import type { CandidateProjectMembership, EngineDeps, LoadedRuleContent } from "./engine-types.js";
+import type { LoadedRule, MatchReason, RuleCandidate, RuleDiagnostic } from "./types.js";
+export declare function loadCandidate(candidate: RuleCandidate, deps: EngineDeps, diagnostics: RuleDiagnostic[], projectRoot: string | null, loadedRuleContent?: Map<string, LoadedRuleContent | null>, projectMembership?: CandidateProjectMembership): (LoadedRule & {
+    matchReason: MatchReason;
+}) | null;
+export declare function ruleDedupKey(rule: LoadedRule): string;
+export declare function staticMatchReason(rule: LoadedRule): MatchReason | null;

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-loader.js

@@ -0,0 +1,60 @@
+import { isCandidateWithinProjectCached } from "./engine-paths.js";
+import { hashContent } from "./matcher.js";
+import { parseRule } from "./parser.js";
+export function loadCandidate(candidate, deps, diagnostics, projectRoot, loadedRuleContent, projectMembership) {
+    if (!isCandidateWithinProjectCached(candidate, projectRoot, projectMembership)) {
+        diagnostics.push({
+            severity: "warning",
+            source: candidate.path,
+            message: "Rule file resolves outside project root",
+        });
+        return null;
+    }
+    const cachedContent = loadedRuleContent?.get(candidate.realPath);
+    if (cachedContent !== undefined) {
+        return loadedRuleFromContent(candidate, cachedContent, diagnostics);
+    }
+    const content = deps.readFile(candidate.path);
+    if (content === null) {
+        loadedRuleContent?.set(candidate.realPath, null);
+        diagnostics.push({ severity: "warning", source: candidate.path, message: "Unable to read rule file" });
+        return null;
+    }
+    const parsed = parseRule(content);
+    const loadedContent = {
+        frontmatter: parsed.frontmatter,
+        body: parsed.body,
+        contentHash: hashContent(content),
+        ...(parsed.diagnostic === undefined ? {} : { diagnostic: parsed.diagnostic }),
+    };
+    loadedRuleContent?.set(candidate.realPath, loadedContent);
+    return loadedRuleFromContent(candidate, loadedContent, diagnostics);
+}
+export function ruleDedupKey(rule) {
+    return `${rule.realPath}::${rule.contentHash}`;
+}
+export function staticMatchReason(rule) {
+    if (rule.frontmatter.alwaysApply === true) {
+        return "alwaysApply";
+    }
+    if (rule.isSingleFile) {
+        return "single-file";
+    }
+    return null;
+}
+function loadedRuleFromContent(candidate, content, diagnostics) {
+    if (content === null) {
+        diagnostics.push({ severity: "warning", source: candidate.path, message: "Unable to read rule file" });
+        return null;
+    }
+    if (content.diagnostic !== undefined) {
+        diagnostics.push({ severity: "warning", source: candidate.path, message: content.diagnostic });
+    }
+    return {
+        ...candidate,
+        frontmatter: content.frontmatter,
+        body: content.body,
+        contentHash: content.contentHash,
+        matchReason: { kind: "no-match" },
+    };
+}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-paths.d.ts

@@ -0,0 +1,11 @@
+import type { CandidateProjectMembership } from "./engine-types.js";
+import type { RuleCandidate } from "./types.js";
+export declare function isCandidateWithinProjectCached(candidate: RuleCandidate, projectRoot: string | null, projectMembership: CandidateProjectMembership | undefined): boolean;
+export declare function isSameOrChildPath(childPath: string, parentPath: string): boolean;
+export declare function isRootSingleFile(candidate: RuleCandidate): boolean;
+export declare function pathBasesForTarget(projectRoot: string | null, targetFile: string, candidate: RuleCandidate): {
+    projectRelative: string;
+    scopeRelative?: string;
+    basename: string;
+};
+export declare function toPosixPath(path: string): string;

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-paths.js

@@ -0,0 +1,75 @@
+import { realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { PROJECT_SINGLE_FILES } from "./constants.js";
+const ROOT_SINGLE_FILE_SOURCES = new Set(PROJECT_SINGLE_FILES.filter((source) => !source.includes("/")));
+export function isCandidateWithinProjectCached(candidate, projectRoot, projectMembership) {
+    if (projectMembership === undefined) {
+        return isCandidateWithinProject(candidate, projectRoot);
+    }
+    const cacheKey = `${projectRoot ?? ""}\0${candidate.realPath}`;
+    const cached = projectMembership.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const isWithinProject = isCandidateWithinProject(candidate, projectRoot);
+    projectMembership.set(cacheKey, isWithinProject);
+    return isWithinProject;
+}
+export function isSameOrChildPath(childPath, parentPath) {
+    const childRelativePath = relative(parentPath, resolve(childPath));
+    return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
+}
+export function isRootSingleFile(candidate) {
+    return candidate.distance === 0 && candidate.isSingleFile && ROOT_SINGLE_FILE_SOURCES.has(candidate.source);
+}
+export function pathBasesForTarget(projectRoot, targetFile, candidate) {
+    const targetBasename = basename(targetFile);
+    if (projectRoot === null) {
+        return { projectRelative: targetBasename, basename: targetBasename };
+    }
+    const projectRelative = toPosixPath(relative(projectRoot, targetFile));
+    const scopeDirectory = scopeDirectoryForCandidate(projectRoot, candidate);
+    if (scopeDirectory === null) {
+        return { projectRelative, basename: targetBasename };
+    }
+    return {
+        projectRelative,
+        scopeRelative: toPosixPath(relative(scopeDirectory, targetFile)),
+        basename: targetBasename,
+    };
+}
+export function toPosixPath(path) {
+    return path.replaceAll("\\", "/");
+}
+function isCandidateWithinProject(candidate, projectRoot) {
+    if (candidate.isGlobal) {
+        return true;
+    }
+    if (projectRoot === null) {
+        return false;
+    }
+    const relativeRealPath = relative(realPathOrResolved(projectRoot), realPathOrResolved(candidate.realPath));
+    return relativeRealPath === "" || (!relativeRealPath.startsWith("..") && !isAbsolute(relativeRealPath));
+}
+function realPathOrResolved(path) {
+    try {
+        return realpathSync.native(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+function scopeDirectoryForCandidate(projectRoot, candidate) {
+    if (candidate.isGlobal) {
+        return null;
+    }
+    if (candidate.isSingleFile) {
+        return dirname(candidate.path);
+    }
+    const sourceIndex = candidate.relativePath.indexOf(candidate.source);
+    if (sourceIndex === -1) {
+        return projectRoot;
+    }
+    const scopeRelativeDirectory = candidate.relativePath.slice(0, sourceIndex).replace(/\/$/, "");
+    return scopeRelativeDirectory.length === 0 ? projectRoot : join(projectRoot, scopeRelativeDirectory);
+}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-static-loader.d.ts

@@ -0,0 +1,6 @@
+import type { EngineDeps } from "./engine-types.js";
+import type { LoadedRule, RuleCandidate, RuleDiagnostic } from "./types.js";
+export declare function loadStaticCandidates(candidates: ReadonlyArray<RuleCandidate>, deps: EngineDeps, projectRoot: string | null): {
+    rules: LoadedRule[];
+    diagnostics: RuleDiagnostic[];
+};

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-static-loader.js

@@ -0,0 +1,29 @@
+import { loadCandidate, staticMatchReason } from "./engine-loader.js";
+import { isRootSingleFile } from "./engine-paths.js";
+import { sortCandidates } from "./ordering.js";
+export function loadStaticCandidates(candidates, deps, projectRoot) {
+    const rules = [];
+    const diagnostics = [];
+    let rootSingleFileSelected = false;
+    for (const candidate of sortCandidates(candidates)) {
+        if (isDedupedRootSingleFile(candidate, rootSingleFileSelected)) {
+            continue;
+        }
+        const loadedRule = loadCandidate(candidate, deps, diagnostics, projectRoot);
+        if (loadedRule === null) {
+            continue;
+        }
+        const matchReason = staticMatchReason(loadedRule);
+        if (matchReason === null) {
+            continue;
+        }
+        if (isRootSingleFile(candidate)) {
+            rootSingleFileSelected = true;
+        }
+        rules.push({ ...loadedRule, matchReason });
+    }
+    return { rules: sortCandidates(rules), diagnostics };
+}
+function isDedupedRootSingleFile(candidate, rootSingleFileSelected) {
+    return rootSingleFileSelected && isRootSingleFile(candidate);
+}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-types.d.ts

@@ -0,0 +1,44 @@
+import type { RuleDiscoveryCache } from "./finder.js";
+import type { matchRule } from "./matcher.js";
+import type { LoadedRule, MatchReason, PiRulesConfig, RuleCandidate, RuleDiagnostic, SessionState } from "./types.js";
+export interface LoadedRuleContent {
+    frontmatter: LoadedRule["frontmatter"];
+    body: string;
+    contentHash: string;
+    diagnostic?: string;
+}
+export type CandidateProjectMembership = Map<string, boolean>;
+export type CandidateDiscoveryCache = Map<string, RuleCandidate[]>;
+export type DynamicMatchCache = Map<string, MatchReason | null>;
+export interface EngineDeps {
+    findCandidates: (options: {
+        projectRoot: string | null;
+        targetFile: string | null;
+        homeDir?: string;
+        disabledSources?: ReadonlySet<string>;
+        skipUserHome?: boolean;
+        cache?: RuleDiscoveryCache;
+    }) => RuleCandidate[];
+    readFile: (path: string) => string | null;
+    findProjectRoot: (startPath: string) => string | null;
+    matchRule?: typeof matchRule;
+}
+export interface Engine {
+    state: SessionState;
+    config: PiRulesConfig;
+    loadStaticRules(cwd: string): {
+        rules: LoadedRule[];
+        diagnostics: RuleDiagnostic[];
+    };
+    loadDynamicRules(cwd: string, targetPaths: ReadonlyArray<string>): {
+        rules: LoadedRule[];
+        diagnostics: RuleDiagnostic[];
+    };
+    formatStatic(rules: ReadonlyArray<LoadedRule>): string;
+    formatDynamic(rules: ReadonlyArray<LoadedRule>, target: string): string;
+    resetSession(cwd?: string): void;
+    isStaticInjected(rule: LoadedRule): boolean;
+    isDynamicInjected(rule: LoadedRule): boolean;
+    markStaticInjected(rule: LoadedRule): boolean;
+    markDynamicInjected(rule: LoadedRule): boolean;
+}

package/packages/omo-codex/plugin/components/rules/dist/rules/engine-types.js

@@ -0,0 +1 @@
+export {};

package/packages/omo-codex/plugin/components/rules/dist/rules/engine.d.ts

@@ -0,0 +1,5 @@
+import type { Engine, EngineDeps } from "./engine-types.js";
+import type { PiRulesConfig } from "./types.js";
+export type { Engine, EngineDeps } from "./engine-types.js";
+export declare function defaultConfig(): PiRulesConfig;
+export declare function createEngine(config: PiRulesConfig, deps: EngineDeps): Engine;