oh-my-opencode 4.8.0 → 4.9.0

package/packages/omo-codex/plugin/components/rules/dist/transcript-rule-filter.js

@@ -0,0 +1,49 @@
+import { readTranscriptSearchText } from "./transcript-search.js";
+export function filterRulesAlreadyInTranscript(rules, transcriptPath, markInjected, options = {}) {
+    if (rules.length === 0 || transcriptPath === null) {
+        return [...rules];
+    }
+    const transcriptText = readTranscriptSearchText(transcriptPath, options);
+    return filterRulesNotInTranscriptText(rules, transcriptText, markInjected);
+}
+export function filterRulesNotInTranscriptText(rules, transcriptText, markInjected) {
+    if (rules.length === 0 || transcriptText === null) {
+        return [...rules];
+    }
+    const pendingRules = [];
+    for (const rule of rules) {
+        if (isRuleAlreadyInTranscript(rule, transcriptText)) {
+            markInjected(rule);
+            continue;
+        }
+        pendingRules.push(rule);
+    }
+    return pendingRules;
+}
+function isRuleAlreadyInTranscript(rule, transcriptText) {
+    const staticReferenceNeedles = [
+        `- [${displayFilename(rule)}]{${rule.path}}`,
+        `- [${displayFilename(rule)}]{${rule.realPath}}`,
+    ];
+    if (staticReferenceNeedles.some((needle) => transcriptText.includes(needle))) {
+        return true;
+    }
+    const bodyNeedle = rule.body.trim().slice(0, 2_000);
+    if (bodyNeedle.length === 0 || !transcriptText.includes(bodyNeedle)) {
+        return false;
+    }
+    const markers = [
+        `Instructions from: ${rule.path}`,
+        `Instructions from: ${rule.realPath}`,
+        rule.relativePath.length === 0 ? null : rule.relativePath,
+    ].filter((marker) => marker !== null);
+    return markers.some((marker) => transcriptText.includes(marker));
+}
+function displayFilename(rule) {
+    const normalizedPath = rule.relativePath.length > 0 ? rule.relativePath : rule.path;
+    const segments = normalizedPath
+        .replace(/\\/g, "/")
+        .split("/")
+        .filter((segment) => segment.length > 0);
+    return segments.at(-1) ?? normalizedPath;
+}

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

@@ -0,0 +1,4 @@
+export interface TranscriptSearchOptions {
+    readonly latestCompactedReplacementOnly?: boolean;
+}
+export declare function readTranscriptSearchText(transcriptPath: string, options?: TranscriptSearchOptions): string | null;

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

@@ -0,0 +1,91 @@
+import { readFileSync } from "node:fs";
+export function readTranscriptSearchText(transcriptPath, options = {}) {
+    try {
+        const rawTranscript = readFileSync(transcriptPath, "utf8");
+        if (options.latestCompactedReplacementOnly === true) {
+            return latestCompactedReplacementSearchText(rawTranscript);
+        }
+        return [rawTranscript, ...collectJsonLineStrings(rawTranscript)].join("\n");
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        return null;
+    }
+}
+function latestCompactedReplacementSearchText(rawTranscript) {
+    const lines = rawTranscript.split(/\r?\n/);
+    let latestCompactedLineIndex = -1;
+    let replacementHistory = null;
+    for (const [index, line] of lines.entries()) {
+        const parsed = parseJsonLine(line);
+        if (!isRecord(parsed) || parsed["type"] !== "compacted") {
+            continue;
+        }
+        const payload = parsed["payload"];
+        if (!isRecord(payload)) {
+            continue;
+        }
+        const candidateReplacementHistory = payload["replacement_history"];
+        if (!Array.isArray(candidateReplacementHistory)) {
+            continue;
+        }
+        latestCompactedLineIndex = index;
+        replacementHistory = candidateReplacementHistory;
+    }
+    if (replacementHistory === null) {
+        return null;
+    }
+    const values = [];
+    collectStrings(replacementHistory, values);
+    const laterTranscript = lines.slice(latestCompactedLineIndex + 1).join("\n");
+    values.push(laterTranscript, ...collectJsonLineStrings(laterTranscript));
+    return values.join("\n");
+}
+function collectJsonLineStrings(rawTranscript) {
+    const values = [];
+    for (const line of rawTranscript.split(/\r?\n/)) {
+        const parsed = parseJsonLine(line);
+        if (parsed !== null) {
+            collectStrings(parsed, values);
+        }
+    }
+    return values;
+}
+function parseJsonLine(line) {
+    if (line.trim().length === 0) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(line);
+        return parsed;
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw error;
+        }
+        return null;
+    }
+}
+function collectStrings(value, output) {
+    if (typeof value === "string") {
+        output.push(value);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectStrings(item, output);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    for (const item of Object.values(value)) {
+        collectStrings(item, output);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/rules/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Loading Project Rules"
+						"statusMessage": "LazyCodex(4.9.0): Loading Project Rules"
 					}
 				]
 			}
@@ -19,7 +19,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook user-prompt-submit",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Loading Project Rules"
+						"statusMessage": "LazyCodex(4.9.0): Loading Project Rules"
 					}
 				]
 			}
@@ -32,7 +32,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Matching Project Rules"
+						"statusMessage": "LazyCodex(4.9.0): Matching Project Rules"
 					}
 				]
 			}
@@ -45,7 +45,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(0.1.0): Resetting Project Rule Cache"
+						"statusMessage": "LazyCodex(4.9.0): Resetting Project Rule Cache"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/rules/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-rules",
-	"version": "0.1.0",
+	"version": "4.9.0",
 	"description": "Codex plugin that injects project rule files into model context through lifecycle hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

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

@@ -3,6 +3,7 @@ import { configFromEnvironment } from "./config.js";
 import { hasContextPressureMarker, transcriptHasContextPressureMarker } from "./context-pressure.js";
 import { createHookDebugTimer } from "./debug-log.js";
 import { fingerprintDynamicTargets } from "./dynamic-target-fingerprints.js";
+import { withDynamicBudget } from "./event-budget.js";
 import { formatAdditionalContextOutput } from "./hook-output.js";
 import { displayPath, uniqueStrings } from "./path-utils.js";
 import {
@@ -175,11 +176,12 @@ export async function runPostToolUseHook(
 		debugTimer.done({ outputBytes: 0, reason: "post-compact-recovery-in-progress" });
 		return "";
 	}
+	const dynamicConfig = withDynamicBudget(config);
 	const engine = createRulesEngine(
 		options,
 		completedPostCompactKind !== undefined
-			? withPostCompactBudget(config, { model: input.model, transcriptPath: input.transcript_path })
-			: config,
+			? withPostCompactBudget(dynamicConfig, { model: input.model, transcriptPath: input.transcript_path })
+			: dynamicConfig,
 	);
 	hydrateEngineState(engine, cachePath);
 	debugTimer.lap("hydrate", {

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

@@ -21,6 +21,19 @@ export function configFromEnvironment(env: NodeJS.ProcessEnv = process.env): PiR
 		parsePositiveInteger(
 			firstEnv(env, "CODEX_RULES_POST_COMPACT_MAX_RESULT_CHARS", "PI_RULES_POST_COMPACT_MAX_RESULT_CHARS"),
 		) ?? config.postCompactMaxResultChars;
+	config.dynamicMaxRuleChars =
+		parsePositiveInteger(firstEnv(env, "CODEX_RULES_DYNAMIC_MAX_RULE_CHARS", "PI_RULES_DYNAMIC_MAX_RULE_CHARS")) ??
+		config.dynamicMaxRuleChars;
+	config.dynamicMaxResultChars =
+		parsePositiveInteger(
+			firstEnv(env, "CODEX_RULES_DYNAMIC_MAX_RESULT_CHARS", "PI_RULES_DYNAMIC_MAX_RESULT_CHARS"),
+		) ?? config.dynamicMaxResultChars;
+	config.promptMaxRuleChars =
+		parsePositiveInteger(firstEnv(env, "CODEX_RULES_PROMPT_MAX_RULE_CHARS", "PI_RULES_PROMPT_MAX_RULE_CHARS")) ??
+		config.promptMaxRuleChars;
+	config.promptMaxResultChars =
+		parsePositiveInteger(firstEnv(env, "CODEX_RULES_PROMPT_MAX_RESULT_CHARS", "PI_RULES_PROMPT_MAX_RESULT_CHARS")) ??
+		config.promptMaxResultChars;
 	config.enabledSources = parseEnabledSources(
 		firstEnv(env, "CODEX_RULES_ENABLED_SOURCES", "PI_RULES_ENABLED_SOURCES"),
 		disableBundledRules,

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

@@ -0,0 +1,17 @@
+import type { PiRulesConfig } from "./rules/types.js";
+
+export function withDynamicBudget(config: PiRulesConfig): PiRulesConfig {
+	return {
+		...config,
+		maxRuleChars: Math.min(config.maxRuleChars, config.dynamicMaxRuleChars),
+		maxResultChars: Math.min(config.maxResultChars, config.dynamicMaxResultChars),
+	};
+}
+
+export function withPromptBudget(config: PiRulesConfig): PiRulesConfig {
+	return {
+		...config,
+		maxRuleChars: Math.min(config.maxRuleChars, config.promptMaxRuleChars),
+		maxResultChars: Math.min(config.maxResultChars, config.promptMaxResultChars),
+	};
+}

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

@@ -68,8 +68,11 @@ export function clearSessionState(cachePath: string): void {
 
 export function markSessionCompacted(cachePath: string): void {
 	const state = readSessionState(cachePath);
+	// Compaction drops injected static rule bodies, so pre-compaction static
+	// dedup marks must not suppress the post-compact recovery directive.
+	// Dynamic dedup survives: those rules are recovered as read-directive paths.
 	writeSessionState(cachePath, {
-		staticDedup: state.staticDedup,
+		staticDedup: [],
 		dynamicDedup: state.dynamicDedup,
 		...(state.dynamicTargetFingerprints === undefined
 			? {}

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

@@ -0,0 +1,39 @@
+import { uniqueStrings } from "./path-utils.js";
+
+const DIRECTIVE_HEADER = [
+	"## MANDATORY: POST-COMPACTION RULE RECOVERY",
+	"",
+	"Context compaction DROPPED the project rule files listed below from your context.",
+	"YOU MUST READ THE FOLLOWING RULES with your file-reading tool RIGHT NOW, BEFORE ANY OTHER ACTION. NO EXCUSES.",
+	"Do not plan, answer, edit, or run anything until EVERY file below has been read end to end:",
+	"",
+].join("\n");
+
+const DIRECTIVE_FOOTER =
+	"\nOperating without these rules is a protocol violation. Reconstructing them from memory is NOT reading. READ THEM ALL. NO EXCUSES.";
+
+export function buildPostCompactReadDirective(rulePaths: ReadonlyArray<string>, maxChars: number): string {
+	const paths = uniqueStrings([...rulePaths]);
+	if (paths.length === 0) {
+		return "";
+	}
+
+	const lines: string[] = [];
+	let usedChars = DIRECTIVE_HEADER.length + DIRECTIVE_FOOTER.length;
+	let omittedCount = 0;
+	for (const rulePath of paths) {
+		const line = `- ${rulePath}`;
+		if (lines.length > 0 && usedChars + line.length + 1 > maxChars) {
+			omittedCount += 1;
+			continue;
+		}
+		lines.push(line);
+		usedChars += line.length + 1;
+	}
+	if (omittedCount > 0) {
+		lines.push(
+			`- (+${omittedCount} more rule files omitted - rescan the project rule directories and read those too)`,
+		);
+	}
+	return `${DIRECTIVE_HEADER}${lines.join("\n")}${DIRECTIVE_FOOTER}`;
+}

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

@@ -87,6 +87,22 @@ 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.
  */

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

@@ -7,10 +7,14 @@ import {
 	markStaticInjected as markStaticInjectedInState,
 } from "./cache.js";
 import {
+	DEFAULT_DYNAMIC_MAX_RESULT_CHARS,
+	DEFAULT_DYNAMIC_MAX_RULE_CHARS,
 	DEFAULT_MAX_RESULT_CHARS,
 	DEFAULT_MAX_RULE_CHARS,
 	DEFAULT_POST_COMPACT_MAX_RESULT_CHARS,
 	DEFAULT_POST_COMPACT_MAX_RULE_CHARS,
+	DEFAULT_PROMPT_MAX_RESULT_CHARS,
+	DEFAULT_PROMPT_MAX_RULE_CHARS,
 } from "./constants.js";
 import { loadDynamicCandidates } from "./engine-dynamic-loader.js";
 import { loadStaticCandidates } from "./engine-static-loader.js";
@@ -29,6 +33,10 @@ export function defaultConfig(): PiRulesConfig {
 		maxResultChars: DEFAULT_MAX_RESULT_CHARS,
 		postCompactMaxRuleChars: DEFAULT_POST_COMPACT_MAX_RULE_CHARS,
 		postCompactMaxResultChars: DEFAULT_POST_COMPACT_MAX_RESULT_CHARS,
+		dynamicMaxRuleChars: DEFAULT_DYNAMIC_MAX_RULE_CHARS,
+		dynamicMaxResultChars: DEFAULT_DYNAMIC_MAX_RESULT_CHARS,
+		promptMaxRuleChars: DEFAULT_PROMPT_MAX_RULE_CHARS,
+		promptMaxResultChars: DEFAULT_PROMPT_MAX_RESULT_CHARS,
 		enabledSources: "auto",
 	};
 }

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

@@ -1,4 +1,4 @@
-import { truncateBudget, truncateRule } from "./truncator.js";
+import { isNeverTruncatedRule, truncateBudget, truncateRule } from "./truncator.js";
 import type { LoadedRule } from "./types.js";
 
 export interface FormatOptions {
@@ -35,13 +35,12 @@ function truncateRules(rules: ReadonlyArray<LoadedRule>, options: FormatOptions)
 	const perRuleBudgeted = perRuleNormalized.map((rule) => ({
 		path: rule.path,
 		relativePath: rule.relativePath,
-		body:
-			rule.source === "plugin-bundled"
-				? truncateRule(rule.body, { maxChars: perRuleResultChars, relativePath: rule.relativePath }).body
-				: truncateRule(rule.body, {
-						maxChars: Math.min(options.maxRuleChars, perRuleResultChars),
-						relativePath: rule.relativePath,
-					}).body,
+		body: isNeverTruncatedRule(rule.relativePath)
+			? rule.body
+			: truncateRule(rule.body, {
+					maxChars: Math.min(options.maxRuleChars, perRuleResultChars),
+					relativePath: rule.relativePath,
+				}).body,
 	}));
 	const budgetedRules = truncateBudget({
 		rules: perRuleBudgeted.map((rule) => ({ body: rule.body, relativePath: rule.relativePath })),

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

@@ -14,6 +14,13 @@ function truncationNotice(relativePath: string): string {
 	return TRUNCATION_NOTICE.replace("{path}", relativePath);
 }
 
+export function isNeverTruncatedRule(relativePath: string): boolean {
+	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: string, end: number): number {
 	if (end <= 0) {
 		return 0;
@@ -28,6 +35,10 @@ function safeSliceEnd(body: string, end: number): number {
 }
 
 export function truncateRule(body: string, options: { maxChars: number; relativePath: string }): TruncationResult {
+	if (isNeverTruncatedRule(options.relativePath)) {
+		return { body, truncated: false, originalLength: body.length };
+	}
+
 	if (body.length <= options.maxChars) {
 		return { body, truncated: false, originalLength: body.length };
 	}
@@ -46,6 +57,12 @@ export function truncateBudget(input: { rules: ReadonlyArray<BudgetRule>; maxRes
 	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;

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

@@ -112,6 +112,10 @@ export interface PiRulesConfig {
 	maxResultChars: number;
 	postCompactMaxRuleChars: number;
 	postCompactMaxResultChars: number;
+	dynamicMaxRuleChars: number;
+	dynamicMaxResultChars: number;
+	promptMaxRuleChars: number;
+	promptMaxResultChars: number;
 	enabledSources: RuleSource[] | "auto";
 }
 

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

@@ -1,5 +1,13 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
 type RuntimeEnv = Readonly<Record<string, string | undefined>>;
 
+interface OmoResolutionDeps {
+	readonly fileExists?: (path: string) => boolean;
+	readonly platform?: NodeJS.Platform;
+}
+
 const SPARKSHELL_AWARENESS_MARKER = "## Sparkshell Runtime";
 
 export const SPARKSHELL_AWARENESS_DEDUP_KEY = "__omo_sparkshell_awareness__";
@@ -23,7 +31,38 @@ function isSparkShellAppServerConfigured(env: RuntimeEnv = process.env): boolean
 	return codexSocketPath.length > 0 || omoSocketPath.length > 0;
 }
 
-export function getSparkShellRuntimeAwareness(env: RuntimeEnv = process.env): string {
+export function resolveOmoInvocation(env: RuntimeEnv = process.env, deps: OmoResolutionDeps = {}): string | null {
+	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: RuntimeEnv): readonly string[] {
+	const dirs: string[] = [];
+	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: RuntimeEnv = process.env, deps: OmoResolutionDeps = {}): string {
 	const override = env["OMO_SPARKSHELL_AWARENESS"] ?? env["LAZYCODEX_SPARKSHELL_AWARENESS"];
 	if (isFalsy(override)) {
 		return "";
@@ -32,13 +71,23 @@ export function getSparkShellRuntimeAwareness(env: RuntimeEnv = process.env): st
 		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 `omo sparkshell <command>` for repo inspection, CLI smoke tests, git/history checks, and bounded verification before falling back to raw shell commands.",
-		"- Use `omo sparkshell --shell '<command>'` only when shell metacharacters are required.",
-		"- Use `omo sparkshell --tmux-pane <pane-id> --tail-lines 400` to inspect an existing tmux pane. Tail lines must stay between 100 and 1000.",
+		`- 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");
 }