oh-my-opencode 4.8.0 → 4.9.0

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

@@ -1,12 +1,20 @@
+import { existsSync } from "node:fs";
+
 import type { CodexRulesHookOptions } from "./codex-hook-options.js";
 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 type { Engine } from "./rules/engine.js";
+import { isNeverTruncatedRule } from "./rules/truncator.js";
+import type { LoadedRule, PiRulesConfig } from "./rules/types.js";
 import { createRulesEngine } from "./rules-engine-factory.js";
 import { getSparkShellRuntimeAwareness, SPARKSHELL_AWARENESS_DEDUP_KEY } from "./sparkshell-awareness.js";
-import { filterRulesAlreadyInTranscript } from "./transcript-rule-filter.js";
+import { filterRulesAlreadyInTranscript, filterRulesNotInTranscriptText } from "./transcript-rule-filter.js";
 import type { TranscriptSearchOptions } from "./transcript-search.js";
+import { readTranscriptSearchText } from "./transcript-search.js";
 
 export function runStaticInjection(
 	cwd: string,
@@ -26,10 +34,20 @@ export function runStaticInjection(
 		return "";
 	}
 
-	const effectiveConfig =
-		completedPostCompactChannel === undefined
-			? config
-			: withPostCompactBudget(config, { model: model ?? "", transcriptPath });
+	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;
@@ -47,7 +65,7 @@ export function runStaticInjection(
 		? ""
 		: getSparkShellRuntimeAwareness(options.env);
 	if (rules.length === 0 && sparkshellAwareness.length === 0) {
-		persistEngineState(engine, cachePath, completedPostCompactChannel);
+		persistEngineState(engine, cachePath);
 		return "";
 	}
 
@@ -58,10 +76,112 @@ export function runStaticInjection(
 	if (sparkshellAwareness.length > 0) {
 		engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
 	}
-	persistEngineState(engine, cachePath, completedPostCompactChannel);
+	persistEngineState(engine, cachePath);
 	return formatAdditionalContextOutput(eventName, combineStaticContext(block, sparkshellAwareness));
 }
 
+interface PostCompactRecoveryInput {
+	cwd: string;
+	transcriptPath: string | null;
+	eventName: "SessionStart" | "UserPromptSubmit";
+	cachePath: string;
+	options: CodexRulesHookOptions;
+	channel: "static";
+	model: string;
+	config: PiRulesConfig;
+}
+
+function runPostCompactRecovery(input: PostCompactRecoveryInput): string {
+	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: string | null): string | null {
+	if (transcriptPath === null) {
+		return null;
+	}
+	return (
+		readTranscriptSearchText(transcriptPath, { latestCompactedReplacementOnly: true }) ??
+		readTranscriptSearchText(transcriptPath)
+	);
+}
+
+function recoverDynamicRulePaths(
+	engine: Engine,
+	transcriptText: string | null,
+	staticRules: ReadonlyArray<LoadedRule>,
+): string[] {
+	const staticRulePaths = new Set(staticRules.map((rule) => rule.realPath));
+	const recoveredPaths = new Set<string>();
+	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: LoadedRule): string {
+	return rule.relativePath.length > 0 ? rule.relativePath : rule.path;
+}
+
 function combineStaticContext(...blocks: readonly string[]): string {
 	return blocks.filter((block) => block.trim().length > 0).join("\n\n");
 }

package/packages/omo-codex/plugin/components/rules/src/transcript-rule-filter.ts

@@ -13,7 +13,15 @@ export function filterRulesAlreadyInTranscript(
 	}
 
 	const transcriptText = readTranscriptSearchText(transcriptPath, options);
-	if (transcriptText === null) {
+	return filterRulesNotInTranscriptText(rules, transcriptText, markInjected);
+}
+
+export function filterRulesNotInTranscriptText(
+	rules: ReadonlyArray<LoadedRule>,
+	transcriptText: string | null,
+	markInjected: (rule: LoadedRule) => void,
+): LoadedRule[] {
+	if (rules.length === 0 || transcriptText === null) {
 		return [...rules];
 	}
 

package/packages/omo-codex/plugin/components/rules/test/bundled-rules.test.ts

@@ -200,7 +200,7 @@ describe("plugin bundled rules", () => {
 		expect(output).toBe("");
 	});
 
-	it("#given bundled static context already injected #when UserPromptSubmit runs after PostCompact #then it emits no duplicate bundled context", async () => {
+	it("#given bundled static context dropped by compaction #when UserPromptSubmit runs after PostCompact #then it re-injects the bundled persona body in full", async () => {
 		// given
 		const { root, pluginData, bundledRulePath } = makeFixture();
 		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
@@ -219,7 +219,9 @@ describe("plugin bundled rules", () => {
 
 		// then
 		expect(compactOutput).toBe("");
-		expect(output).toBe("");
+		expect(output).toContain(`Instructions from: ${bundledRulePath}`);
+		expect(output).toContain(BUNDLED_BODY);
+		expect(output).not.toContain("[Truncated. Full:");
 	});
 
 	it("#given bundled Hephaestus rule body exceeds per-rule cap #when SessionStart runs #then static context expands the body within result budget", async () => {

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

@@ -25,7 +25,7 @@ afterEach(() => {
 });
 
 describe("codex rules post-compaction context budget", () => {
-	it("#given oversized project rules already injected #when static recovery runs after compaction #then it emits no duplicate static injection", async () => {
+	it("#given oversized project rules already injected #when static recovery runs after compaction #then it emits a mandatory read directive instead of rule bodies", async () => {
 		// given
 		const { root, pluginData } = makeOversizedProject();
 		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
@@ -50,7 +50,12 @@ describe("codex rules post-compaction context budget", () => {
 		expect(firstContext).toContain("Project rule");
 		expect(firstContext).toContain("[Truncated. Full:");
 		expect(firstContext.length).toBeLessThan(31_000);
-		expect(output).toBe("");
+		const recoveryContext = readAdditionalContext(output);
+		expect(recoveryContext).toContain("MUST READ");
+		expect(recoveryContext).toContain("NO EXCUSES");
+		expect(recoveryContext).toContain(path.join(root, "CONTEXT.md"));
+		expect(recoveryContext).not.toContain("Project rule");
+		expect(recoveryContext.length).toBeLessThan(2_000);
 	});
 });
 

package/packages/omo-codex/plugin/components/rules/test/codex-hook-post-compact-context.test.ts

@@ -20,7 +20,7 @@ afterEach(() => {
 });
 
 describe("codex rules compacted context recovery", () => {
-	it("#given compacted session source after PostCompact #when static rules re-inject #then output uses the compact recovery budget", async () => {
+	it("#given compacted session source after PostCompact #when static recovery runs #then output is a mandatory read directive", async () => {
 		// given
 		const { root, pluginData } = makeOversizedProject("compact-source");
 		const transcriptPath = writeCompactedTranscript(root, "summary dropped injected rules");
@@ -37,10 +37,10 @@ describe("codex rules compacted context recovery", () => {
 
 		// then
 		const postCompactContext = readAdditionalContext(output);
-		expect(postCompactContext.length).toBeLessThan(5_000);
-		expect(postCompactContext).toContain("Instructions from:");
+		expect(postCompactContext.length).toBeLessThan(2_000);
+		expect(postCompactContext).toContain("MUST READ");
 		expect(postCompactContext).toContain("CONTEXT.md");
-		expect(postCompactContext).toContain("Project rule");
+		expect(postCompactContext).not.toContain("Project rule");
 	});
 
 	it("#given compacted context warning and near-full transcript #when compact source starts twice #then handles compacted context warning once", async () => {
@@ -65,7 +65,7 @@ describe("codex rules compacted context recovery", () => {
 		// then
 		const firstContext = readOptionalAdditionalContext(firstOutput);
 		expect(firstContext.length).toBeLessThan(1_000);
-		expect(firstContext).toContain("Instructions from:");
+		expect(firstContext).toContain("MUST READ");
 		expect(firstContext).toContain("CONTEXT.md");
 		expect(secondOutput).toBe("");
 	});
@@ -88,7 +88,7 @@ describe("codex rules compacted context recovery", () => {
 		// then
 		const context = readOptionalAdditionalContext(output);
 		expect(context.length).toBeLessThan(1_000);
-		expect(context).toContain("Instructions from:");
+		expect(context).toContain("MUST READ");
 		expect(context).toContain("CONTEXT.md");
 	});
 
@@ -106,7 +106,7 @@ describe("codex rules compacted context recovery", () => {
 		// then
 		const context = readOptionalAdditionalContext(output);
 		expect(context.length).toBeLessThan(1_000);
-		expect(context).toContain("Instructions from:");
+		expect(context).toContain("MUST READ");
 		expect(context).toContain("CONTEXT.md");
 	});
 
@@ -128,7 +128,7 @@ describe("codex rules compacted context recovery", () => {
 		// then
 		const context = readOptionalAdditionalContext(output);
 		expect(context.length).toBeLessThan(1_000);
-		expect(context).toContain("Instructions from:");
+		expect(context).toContain("MUST READ");
 		expect(context).toContain("CONTEXT.md");
 	});
 
@@ -157,7 +157,7 @@ describe("codex rules compacted context recovery", () => {
 		const contexts = outputs.map(readOptionalAdditionalContext);
 		expect(contexts.filter((context) => context.length > 0)).toHaveLength(1);
 		expect(contexts.join("").length).toBeLessThan(1_000);
-		expect(contexts.join("")).toContain("Instructions from:");
+		expect(contexts.join("")).toContain("MUST READ");
 		expect(contexts.join("")).toContain("CONTEXT.md");
 	});
 });

package/packages/omo-codex/plugin/components/rules/test/codex-hook-post-compact-dedup.test.ts

@@ -93,7 +93,7 @@ describe("codex rules PostCompact deduplication", () => {
 		expect(output).toBe("");
 	});
 
-	it("#given startup already injected static context #when UserPromptSubmit runs after PostCompact #then it emits no duplicate static context", async () => {
+	it("#given startup static context dropped by compaction #when UserPromptSubmit runs after PostCompact #then it emits a mandatory read directive without rule bodies", async () => {
 		// given
 		const { root, pluginData } = makeTempProject();
 		await runSessionStartHook(sessionStartInput(root), {
@@ -113,10 +113,13 @@ describe("codex rules PostCompact deduplication", () => {
 		});
 
 		// then
-		expect(output).toBe("");
+		const context = readAdditionalContext(output);
+		expect(context).toContain("MUST READ");
+		expect(context).toContain("CONTEXT.md");
+		expect(context).not.toContain("Instructions from:");
 	});
 
-	it("#given startup already injected static context #when compact SessionStart runs after PostCompact #then it emits no duplicate static context", async () => {
+	it("#given startup static context dropped by compaction #when compact SessionStart runs after PostCompact #then it emits a mandatory read directive without rule bodies", async () => {
 		// given
 		const { root, pluginData } = makeTempProject();
 		await runSessionStartHook(sessionStartInput(root), {
@@ -136,7 +139,10 @@ describe("codex rules PostCompact deduplication", () => {
 		});
 
 		// then
-		expect(output).toBe("");
+		const context = readAdditionalContext(output);
+		expect(context).toContain("MUST READ");
+		expect(context).toContain("CONTEXT.md");
+		expect(context).not.toContain("Instructions from:");
 	});
 });
 

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

@@ -0,0 +1,241 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+	type CodexPostCompactInput,
+	type CodexPostToolUseInput,
+	type CodexSessionStartInput,
+	type CodexUserPromptSubmitInput,
+	runPostCompactHook,
+	runPostToolUseHook,
+	runSessionStartHook,
+	runUserPromptSubmitHook,
+} from "../src/codex-hook.js";
+
+const tempDirectories: string[] = [];
+const PROJECT_ONLY_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: "CONTEXT.md,.omo/rules",
+};
+const SESSION_ID = "session-post-compact-directive";
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("codex rules post-compaction read directive", () => {
+	it("#given injected rules dropped by compaction #when UserPromptSubmit recovers #then it lists rule paths in a mandatory read directive instead of bodies", async () => {
+		// given
+		const { root, pluginData } = makeProject();
+		await runSessionStartHook(sessionStartInput(root), { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+		const dynamicOutput = await runPostToolUseHook(postToolUseInput(root, path.join(root, "src", "app.ts")), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const transcriptPath = writeCompactedTranscript(root, "summary that dropped every injected rule");
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(dynamicOutput).toContain("TypeScript rule");
+		const context = readAdditionalContext(output);
+		expect(context).toContain("MUST READ");
+		expect(context).toContain("NO EXCUSES");
+		expect(context).toContain("CONTEXT.md");
+		expect(context).toContain(".omo/rules/typescript.md");
+		expect(context).not.toContain("A".repeat(50));
+		expect(context).not.toContain("B".repeat(50));
+		expect(context.length).toBeLessThan(2_000);
+	});
+
+	it("#given recovery directive already emitted #when UserPromptSubmit runs again #then it emits nothing", async () => {
+		// given
+		const { root, pluginData } = makeProject();
+		await runSessionStartHook(sessionStartInput(root), { pluginDataRoot: pluginData, env: PROJECT_ONLY_ENV });
+		const transcriptPath = writeCompactedTranscript(root, "summary that dropped every injected rule");
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+		await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// when
+		const secondOutput = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(secondOutput).toBe("");
+	});
+
+	it("#given rules retained in compacted replacement #when UserPromptSubmit recovers #then it emits nothing", async () => {
+		// given
+		const { root, pluginData } = makeProject();
+		const firstOutput = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+		const transcriptPath = writeCompactedTranscript(root, readAdditionalContext(firstOutput));
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runUserPromptSubmitHook(userPromptSubmitInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_ONLY_ENV,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given bundled hephaestus rule dropped by compaction #when compact SessionStart recovers #then hephaestus body is re-injected in full alongside the directive", async () => {
+		// given
+		const { root, pluginData } = makeProject();
+		const env = { CODEX_RULES_ENABLED_SOURCES: "CONTEXT.md,plugin-bundled" };
+		await runSessionStartHook(sessionStartInput(root), { pluginDataRoot: pluginData, env });
+		const transcriptPath = writeCompactedTranscript(root, "summary that dropped every injected rule");
+		await runPostCompactHook(
+			{ ...postCompactInput(root), transcript_path: transcriptPath },
+			{ pluginDataRoot: pluginData },
+		);
+
+		// when
+		const output = await runSessionStartHook(compactSessionStartInput(root, transcriptPath), {
+			pluginDataRoot: pluginData,
+			env,
+		});
+
+		// then
+		const context = readAdditionalContext(output);
+		expect(context).toContain("You are Hephaestus");
+		expect(context).not.toContain("[Truncated. Full:");
+		expect(context).toContain("MUST READ");
+		expect(context).toContain("CONTEXT.md");
+	});
+});
+
+function makeProject(): { root: string; pluginData: string } {
+	const root = mkdtempSync(path.join(tmpdir(), "codex-rules-directive-project-"));
+	const pluginData = mkdtempSync(path.join(tmpdir(), "codex-rules-directive-data-"));
+	tempDirectories.push(root, pluginData);
+	writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+	writeFileSync(path.join(root, "CONTEXT.md"), `Project rule\n${"A".repeat(8_000)}`);
+	mkdirSync(path.join(root, ".omo", "rules"), { recursive: true });
+	writeFileSync(
+		path.join(root, ".omo", "rules", "typescript.md"),
+		["---", 'globs: "**/*.ts"', "---", "", `TypeScript rule\n${"B".repeat(2_000)}`].join("\n"),
+	);
+	mkdirSync(path.join(root, "src"), { recursive: true });
+	writeFileSync(path.join(root, "src", "app.ts"), "export const app = 1;\n");
+	return { root, pluginData };
+}
+
+function sessionStartInput(root: string): CodexSessionStartInput {
+	return {
+		session_id: SESSION_ID,
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "startup",
+	};
+}
+
+function compactSessionStartInput(root: string, transcriptPath: string): CodexSessionStartInput {
+	return {
+		session_id: SESSION_ID,
+		transcript_path: transcriptPath,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "compact",
+	};
+}
+
+function postCompactInput(root: string): CodexPostCompactInput {
+	return {
+		session_id: SESSION_ID,
+		turn_id: "turn-compact",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "PostCompact",
+		model: "gpt-5.5",
+		trigger: "auto",
+	};
+}
+
+function userPromptSubmitInput(root: string, transcriptPath: string): CodexUserPromptSubmitInput {
+	return {
+		session_id: SESSION_ID,
+		turn_id: "turn-after-compact",
+		transcript_path: transcriptPath,
+		cwd: root,
+		hook_event_name: "UserPromptSubmit",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		prompt: "continue",
+	};
+}
+
+function postToolUseInput(root: string, filePath: string): CodexPostToolUseInput {
+	return {
+		session_id: SESSION_ID,
+		turn_id: "turn-tool",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "PostToolUse",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		tool_name: "apply_patch",
+		tool_input: { path: filePath },
+		tool_response: {},
+		tool_use_id: "tool-use-1",
+	};
+}
+
+function writeCompactedTranscript(root: string, retainedText: string): string {
+	const transcriptPath = path.join(root, "transcript-compacted.jsonl");
+	writeFileSync(
+		transcriptPath,
+		`${JSON.stringify({
+			type: "compacted",
+			payload: {
+				message: "summary",
+				replacement_history: [{ type: "message", role: "user", content: retainedText }],
+			},
+		})}\n`,
+	);
+	return transcriptPath;
+}
+
+function readAdditionalContext(output: string): string {
+	if (output.trim().length === 0) {
+		throw new Error("Expected hook output to include additional context.");
+	}
+	const parsed: unknown = JSON.parse(output);
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return "";
+	const hookSpecificOutput = (parsed as Record<string, unknown>)["hookSpecificOutput"];
+	if (typeof hookSpecificOutput !== "object" || hookSpecificOutput === null) return "";
+	const additionalContext = (hookSpecificOutput as Record<string, unknown>)["additionalContext"];
+	return typeof additionalContext === "string" ? additionalContext : "";
+}