oh-my-opencode 4.5.1 → 4.6.0

package/packages/omo-codex/plugin/components/rules/src/hook-output.ts

@@ -0,0 +1,19 @@
+export type ContextInjectionHookEventName = "SessionStart" | "UserPromptSubmit" | "PostToolUse";
+
+export function formatAdditionalContextOutput(
+	eventName: ContextInjectionHookEventName,
+	additionalContext: string,
+): string {
+	const normalizedContext = normalizeAdditionalContext(additionalContext);
+	if (normalizedContext.length === 0) return "";
+	return `${JSON.stringify({
+		hookSpecificOutput: {
+			hookEventName: eventName,
+			additionalContext: normalizedContext,
+		},
+	})}\n`;
+}
+
+function normalizeAdditionalContext(additionalContext: string): string {
+	return additionalContext.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}

package/packages/omo-codex/plugin/components/rules/src/path-utils.ts

@@ -0,0 +1,29 @@
+import { isAbsolute, relative, resolve } from "node:path";
+
+export function displayPath(cwd: string, filePath: string): string {
+	const rel = isAbsolute(filePath) ? relative(cwd, filePath) : filePath;
+	return toPosixPath(rel);
+}
+
+export function isSameOrChildPath(childPath: string, parentPath: string): boolean {
+	const childRelativePath = relative(parentPath, resolve(childPath));
+	return childRelativePath === "" || (!childRelativePath.startsWith("..") && !isAbsolute(childRelativePath));
+}
+
+export function toPosixPath(path: string): string {
+	return path.replaceAll("\\", "/");
+}
+
+export function uniqueStrings(values: ReadonlyArray<string>): string[] {
+	const uniqueValues: string[] = [];
+	const seenValues = new Set<string>();
+	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/src/persistent-cache.ts

@@ -0,0 +1,234 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+import {
+	type PostCompactPendingKind,
+	type PostCompactPendingState,
+	postCompactKindState,
+	postCompactPendingKinds,
+	postCompactRecoveringKinds,
+} from "./post-compact-state.js";
+import type { Engine } from "./rules/engine.js";
+import { SESSION_STATE_LOCK_CONTENDED, withSessionStateLock } from "./session-state-lock.js";
+
+export type PostCompactClaimResult = "claimed" | "not-pending" | "contended";
+
+interface SerializedSessionState {
+	staticDedup: string[];
+	dynamicDedup: Record<string, string[]>;
+	dynamicTargetFingerprints?: Record<string, string>;
+	postCompactPending?: PostCompactPendingState;
+	postCompactRecovering?: PostCompactPendingState;
+	compacted?: boolean;
+}
+
+export function hydrateEngineState(engine: Engine, cachePath: string): void {
+	const state = readSessionState(cachePath);
+	engine.state.staticDedup.clear();
+	engine.state.dynamicDedup.clear();
+	engine.state.dynamicTargetFingerprints.clear();
+
+	for (const key of state.staticDedup) {
+		engine.state.staticDedup.add(key);
+	}
+	for (const [scope, keys] of Object.entries(state.dynamicDedup)) {
+		engine.state.dynamicDedup.set(scope, new Set(keys));
+	}
+	for (const [targetKey, fingerprint] of Object.entries(state.dynamicTargetFingerprints ?? {})) {
+		engine.state.dynamicTargetFingerprints.set(targetKey, fingerprint);
+	}
+}
+
+export function persistEngineState(
+	engine: Engine,
+	cachePath: string,
+	completedPostCompactKind?: PostCompactPendingKind,
+): void {
+	const currentState = readSessionState(cachePath);
+	const dynamicDedup: Record<string, string[]> = {};
+	for (const [scope, keys] of engine.state.dynamicDedup.entries()) {
+		dynamicDedup[scope] = [...keys];
+	}
+
+	const postCompactPending = nextPostCompactPending(currentState, completedPostCompactKind);
+	const postCompactRecovering = nextPostCompactRecovering(currentState, completedPostCompactKind);
+	writeSessionState(cachePath, {
+		staticDedup: [...engine.state.staticDedup],
+		dynamicDedup,
+		dynamicTargetFingerprints: Object.fromEntries(engine.state.dynamicTargetFingerprints.entries()),
+		...(postCompactPending === undefined ? {} : { postCompactPending }),
+		...(postCompactRecovering === undefined ? {} : { postCompactRecovering }),
+	});
+}
+
+export function clearSessionState(cachePath: string): void {
+	rmSync(cachePath, { force: true });
+}
+
+export function markSessionCompacted(cachePath: string): void {
+	const state = readSessionState(cachePath);
+	writeSessionState(cachePath, {
+		staticDedup: state.staticDedup,
+		dynamicDedup: state.dynamicDedup,
+		...(state.dynamicTargetFingerprints === undefined
+			? {}
+			: { dynamicTargetFingerprints: state.dynamicTargetFingerprints }),
+		postCompactPending: { static: true, dynamic: true },
+	});
+}
+
+export function hasPostCompactPending(cachePath: string): boolean {
+	const state = readSessionState(cachePath);
+	return postCompactPendingKinds(state).size > 0 || postCompactRecoveringKinds(state).size > 0;
+}
+
+export function isPostCompactPending(cachePath: string, kind: PostCompactPendingKind): boolean {
+	return postCompactPendingKinds(readSessionState(cachePath)).has(kind);
+}
+
+export function claimPostCompactPending(cachePath: string, kind: PostCompactPendingKind): PostCompactClaimResult {
+	const result = withSessionStateLock(cachePath, () => {
+		const state = readSessionState(cachePath);
+		const pendingKinds = postCompactPendingKinds(state);
+		if (!pendingKinds.has(kind)) {
+			return "not-pending";
+		}
+
+		pendingKinds.delete(kind);
+		const recoveringKinds = postCompactRecoveringKinds(state);
+		recoveringKinds.add(kind);
+		writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
+		return "claimed";
+	});
+	return result === SESSION_STATE_LOCK_CONTENDED ? "contended" : result;
+}
+
+export function isPostCompactRecoveryInProgress(cachePath: string, kind: PostCompactPendingKind): boolean {
+	return postCompactRecoveringKinds(readSessionState(cachePath)).has(kind);
+}
+
+export function completePostCompactRecovery(cachePath: string, kind: PostCompactPendingKind): void {
+	withSessionStateLock(cachePath, () => {
+		const state = readSessionState(cachePath);
+		const pendingKinds = postCompactPendingKinds(state);
+		const recoveringKinds = postCompactRecoveringKinds(state);
+		recoveringKinds.delete(kind);
+		writeSessionState(cachePath, stateWithPostCompactKinds(state, pendingKinds, recoveringKinds));
+	});
+}
+
+export function sessionCachePath(sessionId: string, pluginDataRoot: string | undefined): string {
+	const root = pluginDataRoot ?? process.env["PLUGIN_DATA"] ?? join(homedir(), ".codex", "codex-rules");
+	return join(root, "sessions", `${safePathSegment(sessionId)}.json`);
+}
+
+function readSessionState(cachePath: string): SerializedSessionState {
+	try {
+		const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+		if (!isSerializedSessionState(parsed)) return emptyState();
+		return parsed;
+	} catch {
+		return emptyState();
+	}
+}
+
+function writeSessionState(cachePath: string, state: SerializedSessionState): void {
+	mkdirSync(dirname(cachePath), { recursive: true });
+	writeFileSync(cachePath, `${JSON.stringify(state)}\n`);
+}
+
+function emptyState(): SerializedSessionState {
+	return { staticDedup: [], dynamicDedup: {}, dynamicTargetFingerprints: {} };
+}
+
+function nextPostCompactPending(
+	state: SerializedSessionState,
+	completedKind: PostCompactPendingKind | undefined,
+): PostCompactPendingState | undefined {
+	const pendingKinds = postCompactPendingKinds(state);
+	if (completedKind !== undefined) {
+		pendingKinds.delete(completedKind);
+	}
+
+	if (pendingKinds.size === 0) {
+		return undefined;
+	}
+
+	return {
+		...(pendingKinds.has("static") ? { static: true } : {}),
+		...(pendingKinds.has("dynamic") ? { dynamic: true } : {}),
+	};
+}
+
+function nextPostCompactRecovering(
+	state: SerializedSessionState,
+	completedKind: PostCompactPendingKind | undefined,
+): PostCompactPendingState | undefined {
+	const recoveringKinds = postCompactRecoveringKinds(state);
+	if (completedKind !== undefined) {
+		recoveringKinds.delete(completedKind);
+	}
+
+	return postCompactKindState(recoveringKinds);
+}
+
+function stateWithPostCompactKinds(
+	state: SerializedSessionState,
+	pendingKinds: ReadonlySet<PostCompactPendingKind>,
+	recoveringKinds: ReadonlySet<PostCompactPendingKind>,
+): SerializedSessionState {
+	const postCompactPending = postCompactKindState(pendingKinds);
+	const postCompactRecovering = postCompactKindState(recoveringKinds);
+	return {
+		staticDedup: state.staticDedup,
+		dynamicDedup: state.dynamicDedup,
+		...(state.dynamicTargetFingerprints === undefined
+			? {}
+			: { dynamicTargetFingerprints: state.dynamicTargetFingerprints }),
+		...(postCompactPending === undefined ? {} : { postCompactPending }),
+		...(postCompactRecovering === undefined ? {} : { postCompactRecovering }),
+	};
+}
+
+function safePathSegment(value: string): string {
+	return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
+}
+
+function isSerializedSessionState(value: unknown): value is SerializedSessionState {
+	if (!isRecord(value) || !Array.isArray(value["staticDedup"]) || !isRecord(value["dynamicDedup"])) {
+		return false;
+	}
+	const staticDedup = value["staticDedup"];
+	const dynamicDedup = value["dynamicDedup"];
+	const dynamicTargetFingerprints = value["dynamicTargetFingerprints"];
+	const postCompactPending = value["postCompactPending"];
+	const postCompactRecovering = value["postCompactRecovering"];
+	const compacted = value["compacted"];
+	return (
+		staticDedup.every((item) => typeof item === "string") &&
+		Object.values(dynamicDedup).every(
+			(item) => Array.isArray(item) && item.every((nestedItem) => typeof nestedItem === "string"),
+		) &&
+		(dynamicTargetFingerprints === undefined ||
+			(isRecord(dynamicTargetFingerprints) &&
+				Object.entries(dynamicTargetFingerprints).every(
+					([targetKey, fingerprint]) => typeof targetKey === "string" && typeof fingerprint === "string",
+				))) &&
+		(postCompactPending === undefined || isPostCompactPendingState(postCompactPending)) &&
+		(postCompactRecovering === undefined || isPostCompactPendingState(postCompactRecovering)) &&
+		(compacted === undefined || typeof compacted === "boolean")
+	);
+}
+
+function isPostCompactPendingState(value: unknown): value is PostCompactPendingState {
+	return (
+		isRecord(value) &&
+		(value["static"] === undefined || typeof value["static"] === "boolean") &&
+		(value["dynamic"] === undefined || typeof value["dynamic"] === "boolean")
+	);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/rules/src/post-compact-budget.ts

@@ -0,0 +1,104 @@
+import { hasContextPressureMarker } from "./context-pressure.js";
+import type { PiRulesConfig } from "./rules/types.js";
+import { readTranscriptSearchText } from "./transcript-search.js";
+
+export interface PostCompactBudgetContext {
+	readonly model: string;
+	readonly transcriptPath: string | null;
+}
+
+interface ModelContextBudget {
+	readonly slug: string;
+	readonly contextWindowTokens: number;
+	readonly effectivePercent: number;
+}
+
+const DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT = 95;
+const ESTIMATED_TRANSCRIPT_CHARS_PER_TOKEN = 3;
+const PROJECTED_INJECTION_CHARS_PER_TOKEN = 2;
+const POST_COMPACT_RESERVED_CONTEXT_PERCENT = 5;
+const POST_COMPACT_MIN_RESERVED_TOKENS = 8_000;
+const POST_COMPACT_MIN_GUIDE_CHARS = 500;
+const FALLBACK_CONTEXT_WINDOW_TOKENS = 200_000;
+const MODEL_CONTEXT_BUDGETS: readonly ModelContextBudget[] = [
+	{ slug: "gpt-5.5", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{ slug: "gpt-5.4", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{ slug: "gpt-5.4-mini", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{ slug: "gpt-5.3-codex", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{ slug: "gpt-5.2", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
+	{
+		slug: "codex-auto-review",
+		contextWindowTokens: 272_000,
+		effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+	},
+];
+
+export function withPostCompactBudget(config: PiRulesConfig, context?: PostCompactBudgetContext): PiRulesConfig {
+	const postCompactMaxResultChars = dynamicPostCompactMaxResultChars(context) ?? config.postCompactMaxResultChars;
+	const maxResultChars = Math.min(config.maxResultChars, config.postCompactMaxResultChars, postCompactMaxResultChars);
+	const maxRuleChars = Math.min(config.maxRuleChars, config.postCompactMaxRuleChars, maxResultChars);
+	return {
+		...config,
+		maxRuleChars,
+		maxResultChars,
+	};
+}
+
+function dynamicPostCompactMaxResultChars(context: PostCompactBudgetContext | undefined): number | undefined {
+	if (context === undefined || context.transcriptPath === null) {
+		return undefined;
+	}
+
+	const transcript = estimateTranscript(context.transcriptPath);
+	if (transcript === undefined) {
+		return undefined;
+	}
+
+	if (hasContextPressureMarker(transcript.text)) {
+		return POST_COMPACT_MIN_GUIDE_CHARS;
+	}
+
+	const modelBudget = modelContextBudgetFor(context.model) ?? fallbackModelContextBudget();
+	const effectiveContextWindow = Math.floor((modelBudget.contextWindowTokens * modelBudget.effectivePercent) / 100);
+	const reservedTokens = Math.max(
+		POST_COMPACT_MIN_RESERVED_TOKENS,
+		Math.floor((effectiveContextWindow * POST_COMPACT_RESERVED_CONTEXT_PERCENT) / 100),
+	);
+	const injectableTokens = Math.max(0, effectiveContextWindow - reservedTokens - transcript.tokens);
+	return Math.max(POST_COMPACT_MIN_GUIDE_CHARS, Math.floor(injectableTokens * PROJECTED_INJECTION_CHARS_PER_TOKEN));
+}
+
+function modelContextBudgetFor(model: string): ModelContextBudget | undefined {
+	const normalizedModel = model.trim().toLowerCase();
+	for (const budget of MODEL_CONTEXT_BUDGETS) {
+		if (
+			normalizedModel === budget.slug ||
+			normalizedModel.endsWith(`.${budget.slug}`) ||
+			normalizedModel.endsWith(`/${budget.slug}`)
+		) {
+			return budget;
+		}
+	}
+	return undefined;
+}
+
+function fallbackModelContextBudget(): ModelContextBudget {
+	return {
+		slug: "unknown",
+		contextWindowTokens: FALLBACK_CONTEXT_WINDOW_TOKENS,
+		effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+	};
+}
+
+function estimateTranscript(transcriptPath: string): { readonly text: string; readonly tokens: number } | undefined {
+	const transcriptText =
+		readTranscriptSearchText(transcriptPath, { latestCompactedReplacementOnly: true }) ??
+		readTranscriptSearchText(transcriptPath);
+	if (transcriptText === null) {
+		return undefined;
+	}
+	return {
+		text: transcriptText,
+		tokens: Math.ceil(Buffer.byteLength(transcriptText, "utf8") / ESTIMATED_TRANSCRIPT_CHARS_PER_TOKEN),
+	};
+}

package/packages/omo-codex/plugin/components/rules/src/post-compact-claim.ts

@@ -0,0 +1,13 @@
+import type { PostCompactClaimResult } from "./persistent-cache.js";
+import type { PostCompactPendingKind } from "./post-compact-state.js";
+
+export function claimedPostCompactKind<T extends PostCompactPendingKind>(
+	result: PostCompactClaimResult,
+	kind: T,
+): T | undefined {
+	return result === "claimed" ? kind : undefined;
+}
+
+export function shouldSkipPostCompactClaim(result: PostCompactClaimResult, recoveryInProgress: boolean): boolean {
+	return result === "contended" || (result === "not-pending" && recoveryInProgress);
+}

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

@@ -0,0 +1,45 @@
+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 function postCompactKindState(kinds: ReadonlySet<PostCompactPendingKind>): PostCompactPendingState | undefined {
+	if (kinds.size === 0) {
+		return undefined;
+	}
+
+	return {
+		...(kinds.has("static") ? { static: true } : {}),
+		...(kinds.has("dynamic") ? { dynamic: true } : {}),
+	};
+}
+
+export function postCompactPendingKinds(state: PostCompactStateFields): Set<PostCompactPendingKind> {
+	const pendingKinds = new Set<PostCompactPendingKind>();
+	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: PostCompactStateFields): Set<PostCompactPendingKind> {
+	const recoveringKinds = new Set<PostCompactPendingKind>();
+	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/src/rules/cache.ts

@@ -0,0 +1,64 @@
+import type { LoadedRule, SessionState } from "./types.js";
+
+const DYNAMIC_SESSION_KEY = "__pi-rules-session__";
+
+export function createSessionState(cwd?: string): SessionState {
+	return {
+		cwd,
+		staticDedup: new Set(),
+		dynamicDedup: new Map(),
+		dynamicTargetFingerprints: new Map(),
+		loadedRules: [],
+		diagnostics: [],
+	};
+}
+
+export function staticDedupKey(cwd: string, rulePath: string, contentHash: string): string {
+	return `${cwd}::${rulePath}::${contentHash}`;
+}
+
+export function dynamicDedupKey(rulePath: string, contentHash: string): string {
+	return `${rulePath}::${contentHash}`;
+}
+
+export function markStaticInjected(state: SessionState, rule: LoadedRule): boolean {
+	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: SessionState, rule: LoadedRule): boolean {
+	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: SessionState, rule: LoadedRule): boolean {
+	return state.staticDedup.has(staticDedupKey(state.cwd ?? "", rule.realPath, rule.contentHash));
+}
+
+export function isDynamicInjected(state: SessionState, rule: LoadedRule): boolean {
+	return state.dynamicDedup.get(DYNAMIC_SESSION_KEY)?.has(dynamicDedupKey(rule.realPath, rule.contentHash)) === true;
+}
+
+export function clearSession(state: SessionState): void {
+	state.staticDedup.clear();
+	state.dynamicDedup.clear();
+	state.dynamicTargetFingerprints.clear();
+	state.loadedRules.length = 0;
+	state.diagnostics.length = 0;
+}

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

@@ -0,0 +1,115 @@
+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 const PROJECT_MARKERS: readonly string[] = [
+	".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: ReadonlyArray<readonly [string, string]> = [
+	[".omo", "rules"],
+	[".claude", "rules"],
+	[".cursor", "rules"],
+	[".github", "instructions"],
+];
+
+/**
+ * Single-file project rules (always apply, frontmatter optional).
+ */
+export const PROJECT_SINGLE_FILES: readonly string[] = [
+	".github/copilot-instructions.md",
+	"AGENTS.md",
+	"CLAUDE.md",
+	"CONTEXT.md",
+];
+
+/**
+ * User-home rule directories.
+ */
+export const USER_HOME_RULE_SUBDIRS: readonly string[] = [".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: readonly string[] = [".config/opencode/AGENTS.md", ".claude/CLAUDE.md"];
+
+/**
+ * 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: readonly string[] = [".md", ".mdc"];
+
+/**
+ * Per-rule source priority for deterministic ordering. Lower = earlier.
+ */
+export const SOURCE_PRIORITY: ReadonlyMap<RuleSource, number> = new Map([
+	[".omo/rules", 0],
+	[".claude/rules", 1],
+	[".cursor/rules", 2],
+	[".github/instructions", 3],
+	[".github/copilot-instructions.md", 4],
+	["AGENTS.md", 5],
+	["CLAUDE.md", 6],
+	["CONTEXT.md", 7],
+	["~/.omo/rules", 100],
+	["~/.opencode/rules", 101],
+	["~/.claude/rules", 102],
+	["~/.config/opencode/AGENTS.md", 103],
+	["~/.claude/CLAUDE.md", 104],
+	["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;
+
+/**
+ * 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: readonly string[] = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".turbo",
+	".next",
+	"coverage",
+];