oh-my-opencode 4.9.2 → 4.11.0

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

@@ -1,111 +0,0 @@
-import { existsSync, lstatSync, readdirSync, realpathSync, statSync } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
-import { DEFAULT_MAX_SCAN_FILES, RULE_FILE_EXTENSIONS, SCANNER_EXCLUDED_DIRS } from "./constants.js";
-export function scanRuleFiles(options) {
-    const rootPath = toAbsolutePath(options.rootDir);
-    if (!existsSync(rootPath)) {
-        return [];
-    }
-    let rootStats;
-    try {
-        rootStats = statSync(rootPath);
-    }
-    catch {
-        return [];
-    }
-    if (!rootStats.isDirectory()) {
-        return [];
-    }
-    const results = [];
-    const visitedDirectories = new Set();
-    const excludedDirs = new Set(options.excludedDirs ?? SCANNER_EXCLUDED_DIRS);
-    const maxDepth = options.maxDepth ?? 10;
-    const maxFiles = normalizeMaxFiles(options.maxFiles);
-    scanDirectory(rootPath, 0, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
-    return results;
-}
-function normalizeMaxFiles(maxFiles) {
-    const value = maxFiles ?? DEFAULT_MAX_SCAN_FILES;
-    if (!Number.isFinite(value) || value < 0)
-        return DEFAULT_MAX_SCAN_FILES;
-    return Math.floor(value);
-}
-function toAbsolutePath(filePath) {
-    return isAbsolute(filePath) ? filePath : resolve(filePath);
-}
-function scanDirectory(directoryPath, depth, maxDepth, maxFiles, excludedDirs, visitedDirectories, results) {
-    if (results.length >= maxFiles) {
-        return;
-    }
-    let realDirectoryPath;
-    try {
-        realDirectoryPath = realpathSync.native(directoryPath);
-    }
-    catch {
-        return;
-    }
-    if (visitedDirectories.has(realDirectoryPath)) {
-        return;
-    }
-    visitedDirectories.add(realDirectoryPath);
-    let entries;
-    try {
-        entries = readdirSync(directoryPath, { withFileTypes: true }).sort((leftEntry, rightEntry) => leftEntry.name.localeCompare(rightEntry.name));
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        if (results.length >= maxFiles) {
-            return;
-        }
-        const entryPath = join(directoryPath, entry.name);
-        if (entry.isDirectory()) {
-            if (!excludedDirs.has(entry.name) && depth < maxDepth) {
-                scanDirectory(entryPath, depth + 1, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
-            }
-            continue;
-        }
-        if (entry.isSymbolicLink()) {
-            scanSymbolicLink(entryPath, entry.name, depth, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
-            continue;
-        }
-        if (entry.isFile() && isRuleFile(entry.name)) {
-            results.push({ path: entryPath, realPath: resolveRealPath(entryPath) });
-        }
-    }
-}
-function scanSymbolicLink(linkPath, linkName, depth, maxDepth, maxFiles, excludedDirs, visitedDirectories, results) {
-    if (results.length >= maxFiles) {
-        return;
-    }
-    let targetStats;
-    try {
-        targetStats = statSync(linkPath);
-    }
-    catch {
-        return;
-    }
-    if (targetStats.isDirectory()) {
-        if (!excludedDirs.has(linkName) && depth < maxDepth) {
-            scanDirectory(linkPath, depth + 1, maxDepth, maxFiles, excludedDirs, visitedDirectories, results);
-        }
-        return;
-    }
-    if (targetStats.isFile() && isRuleFile(linkName)) {
-        results.push({ path: linkPath, realPath: resolveRealPath(linkPath) });
-    }
-}
-function isRuleFile(fileName) {
-    return RULE_FILE_EXTENSIONS.some((extension) => fileName.endsWith(extension));
-}
-function resolveRealPath(filePath) {
-    try {
-        const realPath = realpathSync.native(filePath);
-        const fileStats = lstatSync(filePath);
-        return fileStats.isSymbolicLink() ? realPath : filePath;
-    }
-    catch {
-        return filePath;
-    }
-}

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

@@ -1,3 +0,0 @@
-import type { PiRulesConfig } from "./types.js";
-export declare const DEFAULT_AUTO_DISABLED_SOURCES: readonly string[];
-export declare function disabledSourcesFromConfig(config: PiRulesConfig): ReadonlySet<string> | undefined;

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

@@ -1,9 +0,0 @@
-import { SOURCE_PRIORITY } from "./constants.js";
-export const DEFAULT_AUTO_DISABLED_SOURCES = ["AGENTS.md", "~/.claude/rules", "~/.claude/CLAUDE.md"];
-export function disabledSourcesFromConfig(config) {
-    if (config.enabledSources === "auto") {
-        return new Set(DEFAULT_AUTO_DISABLED_SOURCES);
-    }
-    const enabledSources = new Set(config.enabledSources);
-    return new Set([...SOURCE_PRIORITY.keys()].filter((source) => !enabledSources.has(source)));
-}

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

@@ -1,18 +0,0 @@
-import type { TruncationResult } from "./types.js";
-type BudgetRule = {
-    body: string;
-    relativePath: string;
-};
-type BudgetResult = BudgetRule & {
-    truncated: boolean;
-};
-export declare function isNeverTruncatedRule(relativePath: string): boolean;
-export declare function truncateRule(body: string, options: {
-    maxChars: number;
-    relativePath: string;
-}): TruncationResult;
-export declare function truncateBudget(input: {
-    rules: ReadonlyArray<BudgetRule>;
-    maxResultChars: number;
-}): BudgetResult[];
-export {};

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

@@ -1,59 +0,0 @@
-import { TRUNCATION_NOTICE } from "./constants.js";
-function truncationNotice(relativePath) {
-    return TRUNCATION_NOTICE.replace("{path}", relativePath);
-}
-export function isNeverTruncatedRule(relativePath) {
-    const normalized = relativePath.replace(/\\/g, "/");
-    const segments = normalized.split("/").filter((segment) => segment.length > 0);
-    const filename = segments.at(-1) ?? normalized;
-    return filename.toLowerCase() === "hephaestus.md";
-}
-function safeSliceEnd(body, end) {
-    if (end <= 0) {
-        return 0;
-    }
-    const lastCodeUnit = body.charCodeAt(end - 1);
-    if (lastCodeUnit >= 0xd800 && lastCodeUnit <= 0xdbff) {
-        return end - 1;
-    }
-    return end;
-}
-export function truncateRule(body, options) {
-    if (isNeverTruncatedRule(options.relativePath)) {
-        return { body, truncated: false, originalLength: body.length };
-    }
-    if (body.length <= options.maxChars) {
-        return { body, truncated: false, originalLength: body.length };
-    }
-    const notice = truncationNotice(options.relativePath);
-    if (options.maxChars < notice.length) {
-        return { body: notice, truncated: true, originalLength: body.length };
-    }
-    const sliceEnd = safeSliceEnd(body, options.maxChars - notice.length);
-    return { body: `${body.slice(0, sliceEnd)}${notice}`, truncated: true, originalLength: body.length };
-}
-export function truncateBudget(input) {
-    const results = [];
-    let remainingBudget = input.maxResultChars;
-    for (const rule of input.rules) {
-        if (isNeverTruncatedRule(rule.relativePath)) {
-            results.push({ body: rule.body, truncated: false, relativePath: rule.relativePath });
-            remainingBudget -= rule.body.length;
-            continue;
-        }
-        if (remainingBudget >= rule.body.length) {
-            results.push({ body: rule.body, truncated: false, relativePath: rule.relativePath });
-            remainingBudget -= rule.body.length;
-            continue;
-        }
-        const notice = truncationNotice(rule.relativePath);
-        if (remainingBudget <= notice.length) {
-            break;
-        }
-        const sliceEnd = safeSliceEnd(rule.body, remainingBudget - notice.length);
-        const body = `${rule.body.slice(0, sliceEnd)}${notice}`;
-        results.push({ body, truncated: true, relativePath: rule.relativePath });
-        remainingBudget -= body.length;
-    }
-    return results;
-}

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

@@ -1,126 +0,0 @@
-/**
- * Public types for pi-rules.
- *
- * These types are stable contracts between modules. The frontmatter type
- * mirrors omo's `RuleMetadata` plus Claude (`paths`) and Copilot (`applyTo`)
- * aliases that are normalized into `globs` internally.
- */
-/**
- * YAML frontmatter parsed from a rule markdown file.
- * `paths` (Claude alias) and `applyTo` (Copilot alias) are normalized into
- * `globs` by the parser before any matcher sees this struct.
- */
-export interface RuleFrontmatter {
-    description?: string;
-    globs?: string | string[];
-    paths?: string | string[];
-    applyTo?: string | string[];
-    alwaysApply?: boolean;
-}
-/**
- * Result of parsing a rule markdown file.
- * `body` excludes the frontmatter delimiters and the YAML payload.
- */
-export interface ParsedRule {
-    frontmatter: RuleFrontmatter;
-    body: string;
-    /**
-     * Diagnostic message if frontmatter parsing failed but the body was salvaged.
-     * Empty when parsing succeeded.
-     */
-    diagnostic?: string;
-}
-/**
- * A discovered rule file candidate before parsing/matching.
- *
- * `path` is the absolute path as discovered (possibly via symlink).
- * `realPath` is the canonical resolved path used for dedup.
- * `source` identifies which discovery source produced this candidate.
- */
-export interface RuleCandidate {
-    path: string;
-    realPath: string;
-    source: RuleSource;
-    /**
-     * Distance from the target file directory to the directory containing this rule.
-     * 0 = same directory, 9999 = global/user-home rule.
-     */
-    distance: number;
-    isGlobal: boolean;
-    /**
-     * True when this candidate is a SINGLE-FILE rule like
-     * `.github/copilot-instructions.md` (frontmatter optional, applies always).
-     */
-    isSingleFile: boolean;
-    /**
-     * Path relative to project root, POSIX-normalized. Used for matcher and display.
-     * Empty string for user-home global rules.
-     */
-    relativePath: string;
-}
-/**
- * A fully-loaded rule ready for injection.
- */
-export interface LoadedRule extends RuleCandidate {
-    frontmatter: RuleFrontmatter;
-    body: string;
-    contentHash: string;
-    matchReason: MatchReason;
-}
-/**
- * Source identifier for rule files. Used for deterministic ordering and display.
- */
-export type RuleSource = ".omo/rules" | ".claude/rules" | ".cursor/rules" | ".github/instructions" | ".github/copilot-instructions.md" | "CONTEXT.md" | "plugin-bundled" | "~/.omo/rules" | "~/.opencode/rules" | "~/.claude/rules";
-/**
- * Why a candidate matched the target file. Surfaced in the injection block so
- * the model can attribute its behavior to a specific rule.
- */
-export type MatchReason = "alwaysApply" | "single-file" | {
-    kind: "glob";
-    pattern: string;
-} | {
-    kind: "no-match";
-};
-/**
- * Truncation result.
- */
-export interface TruncationResult {
-    body: string;
-    truncated: boolean;
-    originalLength: number;
-}
-/**
- * Configuration knobs resolved from env vars and package.json.
- */
-export interface PiRulesConfig {
-    disabled: boolean;
-    mode: "static" | "dynamic" | "both" | "off";
-    maxRuleChars: number;
-    maxResultChars: number;
-    postCompactMaxRuleChars: number;
-    postCompactMaxResultChars: number;
-    dynamicMaxRuleChars: number;
-    dynamicMaxResultChars: number;
-    promptMaxRuleChars: number;
-    promptMaxResultChars: number;
-    enabledSources: RuleSource[] | "auto";
-}
-/**
- * Per-session in-memory dedup state.
- *
- * `staticDedup` keys are `{cwd}::{rulePath}::{contentHash}` strings.
- * `dynamicDedup` stores session-scoped `{rulePath}::{contentHash}` strings.
- */
-export interface SessionState {
-    cwd: string | undefined;
-    staticDedup: Set<string>;
-    dynamicDedup: Map<string, Set<string>>;
-    dynamicTargetFingerprints: Map<string, string>;
-    loadedRules: LoadedRule[];
-    diagnostics: RuleDiagnostic[];
-}
-export interface RuleDiagnostic {
-    severity: "warning" | "error";
-    source: string;
-    message: string;
-}

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

@@ -1,8 +0,0 @@
-/**
- * Public types for pi-rules.
- *
- * These types are stable contracts between modules. The frontmatter type
- * mirrors omo's `RuleMetadata` plus Claude (`paths`) and Copilot (`applyTo`)
- * aliases that are normalized into `globs` internally.
- */
-export {};

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

@@ -1,6 +0,0 @@
-interface RulesEngineFactoryOptions {
-    env?: NodeJS.ProcessEnv;
-    platform?: NodeJS.Platform;
-}
-export declare function createRulesEngine(options: RulesEngineFactoryOptions, config?: import("./rules/types.js").PiRulesConfig): import("./rules/engine-types.js").Engine;
-export {};

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

@@ -1,20 +0,0 @@
-import { readFileSync } from "node:fs";
-import { configFromEnvironment } from "./config.js";
-import { createEngine } from "./rules/engine.js";
-import { findRuleCandidates } from "./rules/finder.js";
-import { findProjectRoot } from "./rules/project-root.js";
-export function createRulesEngine(options, config = configFromEnvironment(options.env)) {
-    const platform = options.platform ?? process.platform;
-    return createEngine(config, {
-        findCandidates: (finderOptions) => findRuleCandidates({ ...finderOptions, platform }),
-        findProjectRoot,
-        readFile: (path) => {
-            try {
-                return readFileSync(path, "utf8");
-            }
-            catch {
-                return null;
-            }
-        },
-    });
-}

package/packages/omo-codex/plugin/components/rules/dist/session-state-lock.d.ts

@@ -1,3 +0,0 @@
-export declare const SESSION_STATE_LOCK_CONTENDED: unique symbol;
-export type SessionStateLockResult<T> = T | typeof SESSION_STATE_LOCK_CONTENDED;
-export declare function withSessionStateLock<T>(cachePath: string, callback: () => T): SessionStateLockResult<T>;

package/packages/omo-codex/plugin/components/rules/dist/session-state-lock.js

@@ -1,41 +0,0 @@
-import { mkdirSync, rmSync } from "node:fs";
-import { dirname } from "node:path";
-export const SESSION_STATE_LOCK_CONTENDED = Symbol("session-state-lock-contended");
-const LOCK_RETRY_COUNT = 20;
-const LOCK_RETRY_DELAY_MS = 5;
-const LOCK_SLEEP_VIEW = new Int32Array(new SharedArrayBuffer(4));
-export function withSessionStateLock(cachePath, callback) {
-    const lockPath = `${cachePath}.lock`;
-    mkdirSync(dirname(cachePath), { recursive: true });
-    for (let attempt = 0; attempt < LOCK_RETRY_COUNT; attempt += 1) {
-        try {
-            mkdirSync(lockPath);
-            try {
-                return callback();
-            }
-            finally {
-                rmSync(lockPath, { recursive: true, force: true });
-            }
-        }
-        catch (error) {
-            if (errorCode(error) === "EEXIST") {
-                sleepSync(LOCK_RETRY_DELAY_MS);
-                continue;
-            }
-            throw error;
-        }
-    }
-    return SESSION_STATE_LOCK_CONTENDED;
-}
-function errorCode(error) {
-    if (!isRecord(error)) {
-        return undefined;
-    }
-    return Reflect.get(error, "code");
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function sleepSync(milliseconds) {
-    Atomics.wait(LOCK_SLEEP_VIEW, 0, 0, milliseconds);
-}

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

@@ -1,10 +0,0 @@
-type RuntimeEnv = Readonly<Record<string, string | undefined>>;
-interface OmoResolutionDeps {
-    readonly fileExists?: (path: string) => boolean;
-    readonly platform?: NodeJS.Platform;
-}
-export declare const SPARKSHELL_AWARENESS_DEDUP_KEY = "__omo_sparkshell_awareness__";
-export declare function isCodexAppServerActive(env?: RuntimeEnv): boolean;
-export declare function resolveOmoInvocation(env?: RuntimeEnv, deps?: OmoResolutionDeps): string | null;
-export declare function getSparkShellRuntimeAwareness(env?: RuntimeEnv, deps?: OmoResolutionDeps): string;
-export {};

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

@@ -1,90 +0,0 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-const SPARKSHELL_AWARENESS_MARKER = "## Sparkshell Runtime";
-export const SPARKSHELL_AWARENESS_DEDUP_KEY = "__omo_sparkshell_awareness__";
-export function isCodexAppServerActive(env = process.env) {
-    const originator = env["CODEX_INTERNAL_ORIGINATOR_OVERRIDE"]?.toLowerCase() ?? "";
-    const bundleIdentifier = env["__CFBundleIdentifier"]?.toLowerCase() ?? "";
-    const shellActive = isTruthy(env["CODEX_SHELL"]);
-    return (shellActive &&
-        (originator.includes("codex desktop") ||
-            originator.includes("codex app") ||
-            bundleIdentifier === "com.openai.codex"));
-}
-function isSparkShellAppServerConfigured(env = process.env) {
-    const codexSocketPath = env["CODEX_APP_SERVER_SOCKET"]?.trim() ?? "";
-    const omoSocketPath = env["OMO_SPARKSHELL_APP_SERVER_SOCKET"]?.trim() ?? "";
-    return codexSocketPath.length > 0 || omoSocketPath.length > 0;
-}
-export function resolveOmoInvocation(env = process.env, deps = {}) {
-    const fileExists = deps.fileExists ?? existsSync;
-    const platform = deps.platform ?? process.platform;
-    const binNames = platform === "win32" ? ["omo.cmd", "omo.exe", "omo"] : ["omo"];
-    const pathDelimiter = platform === "win32" ? ";" : ":";
-    const pathEntries = (env["PATH"] ?? "").split(pathDelimiter).filter((entry) => entry.trim().length > 0);
-    for (const pathEntry of pathEntries) {
-        for (const binName of binNames) {
-            if (fileExists(join(pathEntry, binName)))
-                return "omo";
-        }
-    }
-    for (const candidateDir of omoCandidateBinDirs(env)) {
-        for (const binName of binNames) {
-            const candidate = join(candidateDir, binName);
-            if (fileExists(candidate))
-                return candidate;
-        }
-    }
-    return null;
-}
-function omoCandidateBinDirs(env) {
-    const dirs = [];
-    const localBinDir = env["CODEX_LOCAL_BIN_DIR"]?.trim() ?? "";
-    if (localBinDir.length > 0)
-        dirs.push(localBinDir);
-    const home = env["HOME"]?.trim() || env["USERPROFILE"]?.trim() || "";
-    const codexHome = env["CODEX_HOME"]?.trim() || (home.length > 0 ? join(home, ".codex") : "");
-    if (codexHome.length > 0)
-        dirs.push(join(codexHome, "bin"));
-    if (home.length > 0)
-        dirs.push(join(home, ".local", "bin"));
-    return dirs;
-}
-export function getSparkShellRuntimeAwareness(env = process.env, deps = {}) {
-    const override = env["OMO_SPARKSHELL_AWARENESS"] ?? env["LAZYCODEX_SPARKSHELL_AWARENESS"];
-    if (isFalsy(override)) {
-        return "";
-    }
-    if (!isTruthy(override) && !isCodexAppServerActive(env) && !isSparkShellAppServerConfigured(env)) {
-        return "";
-    }
-    const resolved = resolveOmoInvocation(env, deps);
-    const invocation = resolved ?? (isTruthy(override) ? "omo" : null);
-    if (invocation === null) {
-        return "";
-    }
-    const command = /\s/.test(invocation) ? `"${invocation}"` : invocation;
-    return [
-        SPARKSHELL_AWARENESS_MARKER,
-        "",
-        `- Prefer \`${command} sparkshell <command>\` for repo inspection, CLI smoke tests, git/history checks, and bounded verification before falling back to raw shell commands.`,
-        `- Use \`${command} sparkshell --shell '<command>'\` only when shell metacharacters are required.`,
-        `- Use \`${command} sparkshell --tmux-pane <pane-id> --tail-lines 400\` to inspect an existing tmux pane. Tail lines must stay between 100 and 1000.`,
-        "- When no native sidecar or appserver is available, Sparkshell silently falls back to raw command execution. `OMO_SPARKSHELL_BIN` selects a native sidecar path.",
-        "- When `CODEX_THREAD_ID` identifies a Codex session, Sparkshell appends recent session context (first/latest user request + last 5 conversation messages) after the shell result so output consumers stay aligned with the session goals. `OMO_SPARKSHELL_SESSION_CONTEXT=0` disables it.",
-        `- Route potentially huge output (full log files, big diffs, \`cat\`/\`grep\` over large artifacts) through \`${command} sparkshell\` instead of reading it raw: oversized output is condensed to a budget while preserving error signatures, repeated patterns, session-goal-relevant lines, and head/tail. Tune with \`--budget <chars>\`; disable with \`OMO_SPARKSHELL_CONDENSE=0\`.`,
-        "- Oversized output is first summarized by the spark model (`codex exec`, default `gpt-5.3-codex-spark`) fed with the session context: the summary reproduces the output as-is (no masking) and ends with a `[sparkshell caption]` line describing what ran and which lines were omitted. `OMO_SPARKSHELL_SPARK=0` skips the model and uses deterministic condensation directly.",
-    ].join("\n");
-}
-function isTruthy(value) {
-    if (value === undefined) {
-        return false;
-    }
-    return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
-}
-function isFalsy(value) {
-    if (value === undefined) {
-        return false;
-    }
-    return ["0", "false", "no", "off"].includes(value.trim().toLowerCase());
-}

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

@@ -1,3 +0,0 @@
-import type { CodexRulesHookOptions } from "./codex-hook-options.js";
-import type { TranscriptSearchOptions } from "./transcript-search.js";
-export declare function runStaticInjection(cwd: string, transcriptPath: string | null, eventName: "SessionStart" | "UserPromptSubmit", cachePath: string, options: CodexRulesHookOptions, completedPostCompactChannel?: "static", transcriptSearchOptions?: TranscriptSearchOptions, model?: string): string;

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

@@ -1,128 +0,0 @@
-import { existsSync } from "node:fs";
-import { configFromEnvironment } from "./config.js";
-import { withPromptBudget } from "./event-budget.js";
-import { formatAdditionalContextOutput } from "./hook-output.js";
-import { completePostCompactRecovery, hydrateEngineState, persistEngineState } from "./persistent-cache.js";
-import { withPostCompactBudget } from "./post-compact-budget.js";
-import { buildPostCompactReadDirective } from "./post-compact-directive.js";
-import { isNeverTruncatedRule } from "./rules/truncator.js";
-import { createRulesEngine } from "./rules-engine-factory.js";
-import { getSparkShellRuntimeAwareness, SPARKSHELL_AWARENESS_DEDUP_KEY } from "./sparkshell-awareness.js";
-import { filterRulesAlreadyInTranscript, filterRulesNotInTranscriptText } from "./transcript-rule-filter.js";
-import { readTranscriptSearchText } from "./transcript-search.js";
-export function runStaticInjection(cwd, transcriptPath, eventName, cachePath, options, completedPostCompactChannel, transcriptSearchOptions = {}, model) {
-    const config = configFromEnvironment(options.env);
-    if (config.disabled || config.mode === "off" || config.mode === "dynamic") {
-        if (completedPostCompactChannel !== undefined) {
-            completePostCompactRecovery(cachePath, completedPostCompactChannel);
-        }
-        return "";
-    }
-    if (completedPostCompactChannel !== undefined) {
-        return runPostCompactRecovery({
-            cwd,
-            transcriptPath,
-            eventName,
-            cachePath,
-            options,
-            channel: completedPostCompactChannel,
-            model: model ?? "",
-            config,
-        });
-    }
-    const effectiveConfig = eventName === "UserPromptSubmit" ? withPromptBudget(config) : config;
-    const engine = createRulesEngine(options, effectiveConfig);
-    hydrateEngineState(engine, cachePath);
-    engine.state.cwd = cwd;
-    const loaded = engine.loadStaticRules(cwd);
-    const rules = filterRulesAlreadyInTranscript(loaded.rules.filter((rule) => !engine.isStaticInjected(rule)), transcriptPath, (rule) => {
-        engine.markStaticInjected(rule);
-    }, transcriptSearchOptions);
-    const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY)
-        ? ""
-        : getSparkShellRuntimeAwareness(options.env);
-    if (rules.length === 0 && sparkshellAwareness.length === 0) {
-        persistEngineState(engine, cachePath);
-        return "";
-    }
-    const block = engine.formatStatic(rules);
-    for (const rule of rules) {
-        engine.markStaticInjected(rule);
-    }
-    if (sparkshellAwareness.length > 0) {
-        engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
-    }
-    persistEngineState(engine, cachePath);
-    return formatAdditionalContextOutput(eventName, combineStaticContext(block, sparkshellAwareness));
-}
-function runPostCompactRecovery(input) {
-    const effectiveConfig = withPostCompactBudget(input.config, {
-        model: input.model,
-        transcriptPath: input.transcriptPath,
-    });
-    const engine = createRulesEngine(input.options, effectiveConfig);
-    hydrateEngineState(engine, input.cachePath);
-    engine.state.cwd = input.cwd;
-    const loaded = engine.loadStaticRules(input.cwd);
-    const transcriptText = readRecoveryTranscriptText(input.transcriptPath);
-    const missingRules = filterRulesNotInTranscriptText(loaded.rules.filter((rule) => !engine.isStaticInjected(rule)), transcriptText, (rule) => {
-        engine.markStaticInjected(rule);
-    });
-    const dynamicRulePaths = recoverDynamicRulePaths(engine, transcriptText, loaded.rules);
-    const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY)
-        ? ""
-        : getSparkShellRuntimeAwareness(input.options.env);
-    if (missingRules.length === 0 && dynamicRulePaths.length === 0 && sparkshellAwareness.length === 0) {
-        persistEngineState(engine, input.cachePath, input.channel);
-        return "";
-    }
-    const fullBodyRules = missingRules.filter((rule) => isNeverTruncatedRule(ruleDisplayPath(rule)));
-    const listedRules = missingRules.filter((rule) => !isNeverTruncatedRule(ruleDisplayPath(rule)));
-    const bodyBlock = fullBodyRules.length === 0 ? "" : engine.formatStatic(fullBodyRules);
-    const directive = buildPostCompactReadDirective([...listedRules.map((rule) => rule.path), ...dynamicRulePaths], effectiveConfig.maxResultChars);
-    for (const rule of missingRules) {
-        engine.markStaticInjected(rule);
-    }
-    if (sparkshellAwareness.length > 0) {
-        engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
-    }
-    persistEngineState(engine, input.cachePath, input.channel);
-    return formatAdditionalContextOutput(input.eventName, combineStaticContext(bodyBlock, directive, sparkshellAwareness));
-}
-function readRecoveryTranscriptText(transcriptPath) {
-    if (transcriptPath === null) {
-        return null;
-    }
-    return (readTranscriptSearchText(transcriptPath, { latestCompactedReplacementOnly: true }) ??
-        readTranscriptSearchText(transcriptPath));
-}
-function recoverDynamicRulePaths(engine, transcriptText, staticRules) {
-    const staticRulePaths = new Set(staticRules.map((rule) => rule.realPath));
-    const recoveredPaths = new Set();
-    for (const dedupKeys of engine.state.dynamicDedup.values()) {
-        for (const dedupKey of dedupKeys) {
-            const separatorIndex = dedupKey.lastIndexOf("::");
-            if (separatorIndex <= 0) {
-                continue;
-            }
-            const rulePath = dedupKey.slice(0, separatorIndex);
-            if (staticRulePaths.has(rulePath)) {
-                continue;
-            }
-            if (transcriptText !== null && transcriptText.includes(rulePath)) {
-                continue;
-            }
-            if (!existsSync(rulePath)) {
-                continue;
-            }
-            recoveredPaths.add(rulePath);
-        }
-    }
-    return [...recoveredPaths].sort();
-}
-function ruleDisplayPath(rule) {
-    return rule.relativePath.length > 0 ? rule.relativePath : rule.path;
-}
-function combineStaticContext(...blocks) {
-    return blocks.filter((block) => block.trim().length > 0).join("\n\n");
-}

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

@@ -1,6 +0,0 @@
-export interface CodexPostToolUseLike {
-    tool_name: string;
-    tool_input: unknown;
-    tool_response: unknown;
-}
-export declare function extractCodexToolPaths(input: CodexPostToolUseLike, cwd: string): string[];