oh-my-openagent 4.7.1 → 4.7.3

package/dist/cli/index.js

@@ -61669,7 +61669,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-openagent",
-  version: "4.7.1",
+  version: "4.7.3",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -61804,17 +61804,17 @@ var package_default = {
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "oh-my-openagent-darwin-arm64": "4.7.1",
-    "oh-my-openagent-darwin-x64": "4.7.1",
-    "oh-my-openagent-darwin-x64-baseline": "4.7.1",
-    "oh-my-openagent-linux-arm64": "4.7.1",
-    "oh-my-openagent-linux-arm64-musl": "4.7.1",
-    "oh-my-openagent-linux-x64": "4.7.1",
-    "oh-my-openagent-linux-x64-baseline": "4.7.1",
-    "oh-my-openagent-linux-x64-musl": "4.7.1",
-    "oh-my-openagent-linux-x64-musl-baseline": "4.7.1",
-    "oh-my-openagent-windows-x64": "4.7.1",
-    "oh-my-openagent-windows-x64-baseline": "4.7.1"
+    "oh-my-openagent-darwin-arm64": "4.7.3",
+    "oh-my-openagent-darwin-x64": "4.7.3",
+    "oh-my-openagent-darwin-x64-baseline": "4.7.3",
+    "oh-my-openagent-linux-arm64": "4.7.3",
+    "oh-my-openagent-linux-arm64-musl": "4.7.3",
+    "oh-my-openagent-linux-x64": "4.7.3",
+    "oh-my-openagent-linux-x64-baseline": "4.7.3",
+    "oh-my-openagent-linux-x64-musl": "4.7.3",
+    "oh-my-openagent-linux-x64-musl-baseline": "4.7.3",
+    "oh-my-openagent-windows-x64": "4.7.3",
+    "oh-my-openagent-windows-x64-baseline": "4.7.3"
   },
   overrides: {
     hono: "^4.12.18",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-openagent",
-  "version": "4.7.1",
+  "version": "4.7.3",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -135,17 +135,17 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "oh-my-openagent-darwin-arm64": "4.7.1",
-    "oh-my-openagent-darwin-x64": "4.7.1",
-    "oh-my-openagent-darwin-x64-baseline": "4.7.1",
-    "oh-my-openagent-linux-arm64": "4.7.1",
-    "oh-my-openagent-linux-arm64-musl": "4.7.1",
-    "oh-my-openagent-linux-x64": "4.7.1",
-    "oh-my-openagent-linux-x64-baseline": "4.7.1",
-    "oh-my-openagent-linux-x64-musl": "4.7.1",
-    "oh-my-openagent-linux-x64-musl-baseline": "4.7.1",
-    "oh-my-openagent-windows-x64": "4.7.1",
-    "oh-my-openagent-windows-x64-baseline": "4.7.1"
+    "oh-my-openagent-darwin-arm64": "4.7.3",
+    "oh-my-openagent-darwin-x64": "4.7.3",
+    "oh-my-openagent-darwin-x64-baseline": "4.7.3",
+    "oh-my-openagent-linux-arm64": "4.7.3",
+    "oh-my-openagent-linux-arm64-musl": "4.7.3",
+    "oh-my-openagent-linux-x64": "4.7.3",
+    "oh-my-openagent-linux-x64-baseline": "4.7.3",
+    "oh-my-openagent-linux-x64-musl": "4.7.3",
+    "oh-my-openagent-linux-x64-musl-baseline": "4.7.3",
+    "oh-my-openagent-windows-x64": "4.7.3",
+    "oh-my-openagent-windows-x64-baseline": "4.7.3"
   },
   "overrides": {
     "hono": "^4.12.18",

package/packages/omo-codex/plugin/components/rules/README.md

@@ -26,7 +26,7 @@ Project-level sources:
 - `.github/instructions/**/*.md`
 - `.github/copilot-instructions.md`
 
-User-home sources are also supported by the ported engine when available.
+User-home sources are also supported by the ported engine when available. `AGENTS.md` is not part of `auto` source selection because Codex already loads it as native project instructions, so re-injecting it through hooks duplicates context; opt into it explicitly with `CODEX_RULES_ENABLED_SOURCES` if you need hook-level migration behavior. Claude user-home sources (`~/.claude/rules`, `~/.claude/CLAUDE.md`) are also excluded from `auto` because they usually contain Claude Code runtime instructions rather than Codex rules; opt into them explicitly when you want that migration behavior.
 
 Markdown rule files may use frontmatter such as:
 
@@ -73,7 +73,7 @@ Use `CODEX_RULES_*` environment variables:
 | `CODEX_RULES_MODE` | `both`, `static`, `dynamic`, `off` | `both` |
 | `CODEX_RULES_MAX_RULE_CHARS` | positive integer | `12000` |
 | `CODEX_RULES_MAX_RESULT_CHARS` | positive integer | `40000` |
-| `CODEX_RULES_ENABLED_SOURCES` | comma-separated source names | `auto` |
+| `CODEX_RULES_ENABLED_SOURCES` | comma-separated source names or `auto` | `auto` (excludes `AGENTS.md`, `~/.claude/rules`, `~/.claude/CLAUDE.md`) |
 
 For migration from `pi-rules`, equivalent `PI_RULES_*` variables are accepted as fallbacks.
 

package/packages/omo-codex/plugin/components/rules/src/dynamic-target-fingerprints.ts

@@ -1,11 +1,11 @@
 import { statSync } from "node:fs";
 import { resolve } from "node:path";
 import { isSameOrChildPath, toPosixPath, uniqueStrings } from "./path-utils.js";
-import { SOURCE_PRIORITY } from "./rules/constants.js";
 import { createRuleDiscoveryCache, findRuleCandidates } from "./rules/finder.js";
 import { hashContent } from "./rules/matcher.js";
 import { sortCandidates } from "./rules/ordering.js";
 import { findProjectRoot } from "./rules/project-root.js";
+import { disabledSourcesFromConfig } from "./rules/sources.js";
 import type { PiRulesConfig, RuleCandidate } from "./rules/types.js";
 
 export interface DynamicTargetFingerprint {
@@ -19,7 +19,7 @@ export function fingerprintDynamicTargets(
 	targetPaths: ReadonlyArray<string>,
 	config: PiRulesConfig,
 ): DynamicTargetFingerprint[] {
-	const disabledSources = disabledSourcesFor(config);
+	const disabledSources = disabledSourcesFromConfig(config);
 	const discoveryCache = createRuleDiscoveryCache();
 	const cwdProjectRoot = findProjectRoot(cwd);
 	const fingerprints: DynamicTargetFingerprint[] = [];
@@ -84,15 +84,6 @@ function fileFingerprint(filePath: string): string {
 	}
 }
 
-function disabledSourcesFor(config: PiRulesConfig): ReadonlySet<string> | undefined {
-	if (config.enabledSources === "auto") {
-		return undefined;
-	}
-
-	const enabledSources = new Set(config.enabledSources);
-	return new Set([...SOURCE_PRIORITY.keys()].filter((source) => !enabledSources.has(source)));
-}
-
 function dynamicTargetCacheKey(targetPath: string): string {
 	return toPosixPath(resolve(targetPath));
 }

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

@@ -15,13 +15,13 @@ import {
 	DEFAULT_POST_COMPACT_MAX_RESULT_CHARS,
 	DEFAULT_POST_COMPACT_MAX_RULE_CHARS,
 	PROJECT_SINGLE_FILES,
-	SOURCE_PRIORITY,
 } from "./constants.js";
 import { createRuleDiscoveryCache, type RuleDiscoveryCache } from "./finder.js";
 import { formatDynamicBlock, formatStaticBlock } from "./formatter.js";
 import { hashContent, matchRule } from "./matcher.js";
 import { sortCandidates } from "./ordering.js";
 import { parseRule } from "./parser.js";
+import { disabledSourcesFromConfig } from "./sources.js";
 import type { LoadedRule, MatchReason, PiRulesConfig, RuleCandidate, RuleDiagnostic, SessionState } from "./types.js";
 
 interface LoadedRuleContent {
@@ -97,7 +97,7 @@ export function createEngine(config: PiRulesConfig, deps: EngineDeps): Engine {
 			projectRoot,
 			targetFile: null,
 		};
-		const disabledSources = disabledSourcesFor(config);
+		const disabledSources = disabledSourcesFromConfig(config);
 		if (disabledSources !== undefined) {
 			findOptions.disabledSources = disabledSources;
 		}
@@ -121,7 +121,7 @@ export function createEngine(config: PiRulesConfig, deps: EngineDeps): Engine {
 		const seenRules = new Set<string>();
 		const loadedRuleContent = new Map<string, LoadedRuleContent | null>();
 		const projectMembership = new Map<string, boolean>();
-		const disabledSources = disabledSourcesFor(config);
+		const disabledSources = disabledSourcesFromConfig(config);
 		const discoveryCache = createRuleDiscoveryCache();
 		const candidateDiscoveryCache: CandidateDiscoveryCache = new Map();
 		const cwdProjectRoot = deps.findProjectRoot(cwd);
@@ -442,15 +442,6 @@ function staticMatchReason(rule: LoadedRule): MatchReason | null {
 	return null;
 }
 
-function disabledSourcesFor(config: PiRulesConfig): ReadonlySet<string> | undefined {
-	if (config.enabledSources === "auto") {
-		return undefined;
-	}
-
-	const enabledSources = new Set(config.enabledSources);
-	return new Set([...SOURCE_PRIORITY.keys()].filter((source) => !enabledSources.has(source)));
-}
-
 function isDedupedRootSingleFile(candidate: RuleCandidate, rootSingleFileSelected: boolean): boolean {
 	return rootSingleFileSelected && isRootSingleFile(candidate);
 }

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

@@ -0,0 +1,17 @@
+import { SOURCE_PRIORITY } from "./constants.js";
+import type { PiRulesConfig, RuleSource } from "./types.js";
+
+export const DEFAULT_AUTO_DISABLED_SOURCES: readonly RuleSource[] = [
+	"AGENTS.md",
+	"~/.claude/rules",
+	"~/.claude/CLAUDE.md",
+];
+
+export function disabledSourcesFromConfig(config: PiRulesConfig): ReadonlySet<string> | undefined {
+	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/test/codex-hook.test.ts

@@ -211,6 +211,21 @@ describe("codex rules hooks", () => {
 		expect(parsed.hookSpecificOutput?.additionalContext).toContain("Always wear safety goggles");
 	});
 
+	it("#given default auto sources #when SessionStart runs #then native Codex AGENTS.md is not duplicated", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+
+		// when
+		const output = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+		});
+
+		// then
+		const parsed = parseHookOutput(output);
+		expect(parsed.hookSpecificOutput?.additionalContext).toContain("## Project Instructions");
+		expect(parsed.hookSpecificOutput?.additionalContext).not.toContain("Always wear safety goggles");
+	});
+
 	it("#given static context already injected #when UserPromptSubmit runs #then it emits no duplicate context", async () => {
 		// given
 		const { root, pluginData } = makeTempProject();
@@ -351,6 +366,23 @@ describe("codex rules hooks", () => {
 		expect(readSessionCache(pluginData).dynamicTargetFingerprints).toEqual(cachedState.dynamicTargetFingerprints);
 	});
 
+	it("#given default auto sources #when excluded AGENTS.md changes #then PostToolUse fingerprint stays stable", async () => {
+		// given
+		const { root, pluginData } = makeTempProject();
+		const filePath = path.join(root, "src", "app.ts");
+		const input = postToolUseInput(root, filePath);
+		await runPostToolUseHook(input, { pluginDataRoot: pluginData });
+		const cachedState = readSessionCache(pluginData);
+		writeFileSync(path.join(root, "AGENTS.md"), "Native Codex instructions changed outside codex-rules auto.");
+
+		// when
+		const output = await runPostToolUseHook(input, { pluginDataRoot: pluginData });
+
+		// then
+		expect(output).toBe("");
+		expect(readSessionCache(pluginData).dynamicTargetFingerprints).toEqual(cachedState.dynamicTargetFingerprints);
+	});
+
 	it("#given dynamic context remains in transcript but cache is missing #when PostToolUse repeats #then it emits no duplicate context", async () => {
 		// given
 		const { root, pluginData } = makeTempProject();

package/packages/omo-codex/plugin/components/rules/test/dynamic-target-fingerprints.test.ts

@@ -0,0 +1,71 @@
+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 { fingerprintDynamicTargets } from "../src/dynamic-target-fingerprints.js";
+import { defaultConfig } from "../src/rules/engine.js";
+
+const tempDirectories: string[] = [];
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("codex rules dynamic target fingerprints", () => {
+	it("#given auto source mode #when an excluded source file changes #then cache key stays stable", () => {
+		// given
+		const { cwd, targetPath } = makeProjectWithDefaultSources();
+		const config = defaultConfig();
+
+		// when
+		const initial = fingerprintDynamicTargets(cwd, [targetPath], config);
+		writeFileSync(
+			path.join(cwd, "AGENTS.md"),
+			[
+				"Always use the exact code style.",
+				"Updated guidance.",
+				"",
+				"This file should be excluded from auto mode.",
+			].join("\n"),
+		);
+		const afterChange = fingerprintDynamicTargets(cwd, [targetPath], config);
+		writeFileSync(
+			path.join(cwd, ".github", "instructions", "workflow.md"),
+			["---", "description: Workflow rules", 'globs: ["**/*.ts"]', "---", "Prefer explicit return types."].join(
+				"\n",
+			),
+		);
+		const afterEnabledChange = fingerprintDynamicTargets(cwd, [targetPath], config);
+		const initialFingerprint = initial[0]?.fingerprint;
+
+		// then
+		expect(afterChange).toHaveLength(1);
+		expect(afterEnabledChange).toHaveLength(1);
+		expect(initialFingerprint).toBeDefined();
+		expect(afterChange[0]?.fingerprint).toBe(initialFingerprint);
+		expect(afterEnabledChange[0]?.fingerprint).not.toBe(initialFingerprint);
+	});
+});
+
+function makeProjectWithDefaultSources(): { cwd: string; targetPath: string } {
+	const root = mkdtempSync(path.join(tmpdir(), "codex-rules-fingerprint-"));
+	const projectRoot = path.join(root, "repo");
+	const instructionPath = path.join(projectRoot, ".github", "instructions");
+	const targetPath = path.join(projectRoot, "src", "app.ts");
+	tempDirectories.push(root);
+
+	mkdirSync(instructionPath, { recursive: true });
+	mkdirSync(path.dirname(targetPath), { recursive: true });
+	writeFileSync(path.join(projectRoot, "package.json"), "{}");
+	writeFileSync(path.join(projectRoot, "AGENTS.md"), "Default project AGENTS file.");
+	writeFileSync(path.join(projectRoot, ".github", "copilot-instructions.md"), "Legacy copilot instruction");
+	writeFileSync(
+		path.join(instructionPath, "workflow.md"),
+		["---", "description: Workflow rules", 'globs: ["**/*.ts"]', "---", "Keep async/await explicit."].join("\n"),
+	);
+	writeFileSync(targetPath, "export const answer = 42;\n");
+	return { cwd: projectRoot, targetPath };
+}

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

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 
+import { configFromEnvironment } from "../src/config.js";
 import { createEngine, defaultConfig, type EngineDeps } from "../src/rules/engine.js";
 import { matchRule as defaultMatchRule } from "../src/rules/matcher.js";
 import type { RuleCandidate } from "../src/rules/types.js";
@@ -190,3 +191,54 @@ describe("rule engine dynamic matching", () => {
 		expect(matchCalls).toBe(2);
 	});
 });
+
+describe("rule engine default source selection", () => {
+	it("#given auto source selection #when loading static rules #then Codex-native and Claude-home sources are disabled by default", () => {
+		// given
+		let capturedDisabledSources: ReadonlySet<string> | undefined;
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: (options) => {
+				capturedDisabledSources = options.disabledSources;
+				return [];
+			},
+			readFile: () => null,
+		} satisfies EngineDeps;
+		const engine = createEngine(defaultConfig(), deps);
+
+		// when
+		engine.loadStaticRules(projectRoot);
+
+		// then
+		expect(capturedDisabledSources?.has("AGENTS.md")).toBe(true);
+		expect(capturedDisabledSources?.has("~/.claude/rules")).toBe(true);
+		expect(capturedDisabledSources?.has("~/.claude/CLAUDE.md")).toBe(true);
+		expect(capturedDisabledSources?.has("CLAUDE.md")).toBe(false);
+	});
+
+	it("#given Codex-native and Claude-home sources are explicitly enabled #when loading static rules #then they are not disabled", () => {
+		// given
+		let capturedDisabledSources: ReadonlySet<string> | undefined;
+		const deps = {
+			findProjectRoot: () => projectRoot,
+			findCandidates: (options) => {
+				capturedDisabledSources = options.disabledSources;
+				return [];
+			},
+			readFile: () => null,
+		} satisfies EngineDeps;
+		const engine = createEngine(
+			configFromEnvironment({ CODEX_RULES_ENABLED_SOURCES: "AGENTS.md,~/.claude/CLAUDE.md,plugin-bundled" }),
+			deps,
+		);
+
+		// when
+		engine.loadStaticRules(projectRoot);
+
+		// then
+		expect(capturedDisabledSources?.has("AGENTS.md")).toBe(false);
+		expect(capturedDisabledSources?.has("~/.claude/CLAUDE.md")).toBe(false);
+		expect(capturedDisabledSources?.has("plugin-bundled")).toBe(false);
+		expect(capturedDisabledSources?.has(".omo/rules")).toBe(true);
+	});
+});

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

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+
+import { SOURCE_PRIORITY } from "../src/rules/constants.js";
+import { defaultConfig } from "../src/rules/engine.js";
+import { disabledSourcesFromConfig } from "../src/rules/sources.js";
+import type { PiRulesConfig } from "../src/rules/types.js";
+
+describe("rules source selection", () => {
+	it("#given default config #when disabled sources are derived #then opt-out sources stay disabled", () => {
+		// given
+		const config = defaultConfig();
+		const expected = new Set(["AGENTS.md", "~/.claude/rules", "~/.claude/CLAUDE.md"]);
+
+		// when
+		const disabledSources = disabledSourcesFromConfig(config);
+		expect(disabledSources).toBeDefined();
+		if (disabledSources === undefined) return;
+
+		// then
+		expect(disabledSources).toEqual(expected);
+	});
+
+	it("#given explicit enabled sources #when disabled source set is derived #then all other known sources are omitted", () => {
+		// given
+		const config: PiRulesConfig = {
+			...defaultConfig(),
+			enabledSources: [".omo/rules", "AGENTS.md"],
+		};
+
+		// when
+		const disabledSources = disabledSourcesFromConfig(config);
+		expect(disabledSources).toBeDefined();
+		if (disabledSources === undefined) return;
+
+		// then
+		for (const source of [".omo/rules", "AGENTS.md"]) {
+			expect(disabledSources.has(source)).toBe(false);
+		}
+		expect(disabledSources.has("plugin-bundled")).toBe(true);
+		expect(disabledSources.has("~/.claude/rules")).toBe(true);
+		expect(disabledSources).toEqual(
+			new Set([...SOURCE_PRIORITY.keys()].filter((source) => source !== ".omo/rules" && source !== "AGENTS.md")),
+		);
+	});
+});

package/packages/omo-codex/plugin/components/ultrawork/README.md

@@ -35,6 +35,8 @@ node ${PLUGIN_ROOT}/dist/cli.js hook user-prompt-submit
 
 Codex passes the prompt payload on stdin. When the pattern `\b(?:ultrawork|ulw)\b` (case-insensitive) matches, the hook writes the directive to stdout — Codex injects non-JSON stdout as `additional_context` for the next turn. Otherwise the hook writes nothing and exits 0. Malformed input also exits 0 to never block the turn.
 
+If a prior `UserPromptSubmit` hook output in transcript JSONL already contains `<ultrawork-mode>`, the hook suppresses itself so the same directive is not injected repeatedly. Plain transcript text containing `<ultrawork-mode>` is ignored unless it comes from hook output.
+
 Bundled agent role TOMLs in `agents/` ship to `CODEX_HOME/agents/` at install time, not via a runtime hook. The installer creates a symlink on Linux / macOS and a file copy on Windows (because symlinks require admin privileges or Developer Mode). For the public marketplace, the source is the stable installed-marketplace snapshot, not the versioned plugin cache, so agent role configs remain valid when Codex replaces `~/.codex/plugins/cache/sisyphuslabs/omo/<version>/` during auto-update. Both code paths overwrite stale files and write a `.installed-agents.json` manifest next to the source root for clean uninstall tracking.
 
 ## Smoke test

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

@@ -3,6 +3,8 @@ import { readFileSync } from "node:fs";
 import { ULTRAWORK_DIRECTIVE } from "./directive.js";
 
 const ULTRAWORK_PATTERN = /\b(?:ultrawork|ulw)\b/i;
+const ULTRAWORK_DIRECTIVE_MARKER = "<ultrawork-mode>";
+const TRANSCRIPT_SEARCH_BYTES = 512_000;
 const CONTEXT_PRESSURE_MARKERS = [
 	"context compacted",
 	"context_length_exceeded",
@@ -29,10 +31,54 @@ interface UserPromptSubmitHookOutput {
 export function runUserPromptSubmitHook(input: unknown): string {
 	if (!isCodexUserPromptSubmitInput(input)) return "";
 	if (isContextPressureRecoveryPrompt(input.prompt)) return "";
+	if (hasUltraworkDirectiveAlreadyInTranscript(input.transcript_path)) return "";
 	if (isContextPressureTranscript(input.transcript_path)) return "";
 	return isUltraworkPrompt(input.prompt) ? formatAdditionalContextOutput(ULTRAWORK_DIRECTIVE) : "";
 }
 
+function hasUltraworkDirectiveAlreadyInTranscript(transcriptPath: string | null | undefined): boolean {
+	if (transcriptPath === undefined || transcriptPath === null) return false;
+	try {
+		const rawTranscript = readTranscriptTail(transcriptPath);
+		for (const line of rawTranscript.split(/\r?\n/)) {
+			const parsed = parseJsonLine(line);
+			if (parsed === null) {
+				continue;
+			}
+
+			if (!isRecord(parsed)) {
+				continue;
+			}
+
+			const hookSpecificOutput = parsed["hookSpecificOutput"];
+			if (!isRecord(hookSpecificOutput)) {
+				continue;
+			}
+
+			if (hookSpecificOutput["hookEventName"] !== "UserPromptSubmit") {
+				continue;
+			}
+
+			if (
+				typeof hookSpecificOutput["additionalContext"] === "string" &&
+				hookSpecificOutput["additionalContext"].includes(ULTRAWORK_DIRECTIVE_MARKER)
+			) {
+				return true;
+			}
+		}
+	} catch (error) {
+		if (error instanceof Error) return false;
+		throw error;
+	}
+
+	return false;
+}
+
+function readTranscriptTail(transcriptPath: string): string {
+	const rawTranscript = readFileSync(transcriptPath);
+	return rawTranscript.subarray(Math.max(0, rawTranscript.byteLength - TRANSCRIPT_SEARCH_BYTES)).toString("utf8");
+}
+
 export function isUltraworkPrompt(prompt: string): boolean {
 	return ULTRAWORK_PATTERN.test(prompt);
 }
@@ -68,6 +114,22 @@ function normalizeAdditionalContext(additionalContext: string): string {
 	return additionalContext.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
 }
 
+function parseJsonLine(line: string): unknown | null {
+	if (line.trim().length === 0) {
+		return null;
+	}
+
+	try {
+		const parsed: unknown = JSON.parse(line);
+		return parsed;
+	} catch (error) {
+		if (error instanceof Error) {
+			return null;
+		}
+		throw error;
+	}
+}
+
 function isCodexUserPromptSubmitInput(value: unknown): value is CodexUserPromptSubmitInput {
 	return (
 		isRecord(value) &&

package/packages/omo-codex/plugin/components/ultrawork/test/codex-hook.test.ts

@@ -31,6 +31,49 @@ describe("codex ultrawork hook", () => {
 		expect(parsed.hookSpecificOutput.additionalContext).toMatch(/First user-visible line this turn MUST be exactly:/);
 	});
 
+	it("#given transcript already contains ultrawork directive #when hook sees ultrawork prompt #then it does not repeat directive", () => {
+		// given
+		const payload = {
+			hook_event_name: "UserPromptSubmit",
+			prompt: "please ulw this change",
+			transcript_path: writeTranscript(
+				JSON.stringify({
+					hookSpecificOutput: {
+						hookEventName: "UserPromptSubmit",
+						additionalContext: "<ultrawork-mode>\nexisting directive",
+					},
+				}),
+			),
+		};
+
+		// when
+		const output = runUserPromptSubmitHook(payload);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given transcript only mentions ultrawork marker in user content #when hook sees first ultrawork prompt #then it emits directive", () => {
+		// given
+		const payload = {
+			hook_event_name: "UserPromptSubmit",
+			prompt: "please ulw this change",
+			transcript_path: writeTranscript(
+				JSON.stringify({
+					role: "user",
+					content: "Please inspect text containing <ultrawork-mode> but do not activate yet.",
+				}),
+			),
+		};
+
+		// when
+		const output = runUserPromptSubmitHook(payload);
+		const parsed = parseHookOutput(output);
+
+		// then
+		expect(parsed.hookSpecificOutput.additionalContext).toMatch(/^<ultrawork-mode>/);
+	});
+
 	it("#given identifier-like ulw #when hook runs #then does not emit directive", () => {
 		// given
 		const payload = {
@@ -244,6 +287,14 @@ function writeContextPressureTranscript(): string {
 	return transcriptPath;
 }
 
+function writeTranscript(...lines: string[]): string {
+	const root = mkdtempSync(path.join(tmpdir(), "codex-ultrawork-transcript-"));
+	tempDirectories.push(root);
+	const transcriptPath = path.join(root, "transcript.jsonl");
+	writeFileSync(transcriptPath, `${lines.join("\n")}\n`);
+	return transcriptPath;
+}
+
 function writeCodexContextWindowTranscript(): string {
 	const root = mkdtempSync(path.join(tmpdir(), "codex-ultrawork-context-window-"));
 	tempDirectories.push(root);

package/packages/omo-codex/plugin/scripts/migrate-codex-config.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -169,7 +169,9 @@ async function configPaths({ env, cwd }) {
 	const codexHome = resolve(env.CODEX_HOME?.trim() || join(homedir(), ".codex"));
 	const paths = new Set([join(codexHome, "config.toml")]);
 	for (const projectConfig of projectConfigPaths({ cwd, stopAt: homedir() })) {
-		if (await pathExists(projectConfig)) paths.add(projectConfig);
+		if (!(await isRegularFile(projectConfig))) continue;
+		if (!(await isRegularDirectory(dirname(projectConfig)))) continue;
+		paths.add(projectConfig);
 	}
 	return [...paths];
 }
@@ -216,10 +218,18 @@ async function writeState(statePath, state) {
 	await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`);
 }
 
-async function pathExists(path) {
+async function isRegularFile(path) {
 	try {
-		await stat(path);
-		return true;
+		return (await lstat(path)).isFile();
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function isRegularDirectory(path) {
+	try {
+		return (await lstat(path)).isDirectory();
 	} catch (error) {
 		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
 		throw error;

package/packages/omo-codex/plugin/test/migrate-codex-config.test.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import test from "node:test";
@@ -32,6 +32,66 @@ test("#given stale root reasoning config #when ensuring config #then replaces st
 	assert.match(result, /\[features\]/);
 });
 
+test("#given project .codex is a symlink #when migrating #then project config is skipped", async (t) => {
+	if (!(await canCreateSymlink("dir"))) t.skip("symbolic links are unavailable in this environment");
+
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-symlink-dir-"));
+	const codexHome = join(root, "codex-home");
+	const project = join(root, "project");
+	const projectNested = join(project, "nested");
+	const projectCodexDirectory = join(root, "project-codex-real");
+	const projectConfigTarget = join(projectCodexDirectory, "config.toml");
+	const projectConfig = join(project, ".codex", "config.toml");
+
+	await mkdir(codexHome, { recursive: true });
+	await mkdir(projectCodexDirectory, { recursive: true });
+	await mkdir(dirname(projectConfigTarget), { recursive: true });
+	await mkdir(projectNested, { recursive: true });
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.2"\n');
+	await writeFile(projectConfigTarget, 'model = "gpt-5.2"\nmodel_context_window = 272000\n');
+	await rm(join(project, ".codex"), { recursive: true, force: true });
+	await symlink(projectCodexDirectory, join(project, ".codex"), "dir");
+
+	const result = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
+		},
+		cwd: projectNested,
+	});
+
+	assert.deepEqual(result.changed, [join(codexHome, "config.toml")]);
+	assert.match(await readFile(projectConfig, "utf8"), /model = "gpt-5\.2"/);
+});
+
+test("#given project config.toml is a symlink #when migrating #then project config is skipped", async (t) => {
+	if (!(await canCreateSymlink("file"))) t.skip("symbolic links are unavailable in this environment");
+
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-symlink-file-"));
+	const codexHome = join(root, "codex-home");
+	const project = join(root, "project");
+	const projectConfigDirectory = join(project, ".codex");
+	const projectConfig = join(projectConfigDirectory, "config.toml");
+	const realConfigSource = join(root, "shared-config.toml");
+
+	await mkdir(codexHome, { recursive: true });
+	await mkdir(projectConfigDirectory, { recursive: true });
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.2"\n');
+	await writeFile(realConfigSource, 'model = "gpt-5.2"\nmodel_context_window = 272000\n');
+	await symlink(realConfigSource, projectConfig, "file");
+
+	const result = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
+		},
+		cwd: project,
+	});
+
+	assert.deepEqual(result.changed, [join(codexHome, "config.toml")]);
+	assert.match(await readFile(realConfigSource, "utf8"), /model = "gpt-5\.2"/);
+});
+
 test("#given global and project-local stale Codex configs #when migrating #then both configs are forced to current defaults", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-migration-"));
 	const codexHome = join(root, "codex-home");
@@ -144,3 +204,29 @@ test("#given managed catalog state #when catalog version advances #then only pre
 	assert.match(content, /model = "gpt-5\.5"/);
 	assert.match(content, /model_context_window = 400000/);
 });
+
+async function canCreateSymlink(type) {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-symlink-capability-"));
+	const target = join(root, "target");
+	const link = join(root, "link");
+
+	try {
+		if (type === "dir") {
+			await mkdir(target, { recursive: true });
+			await symlink(target, link, "dir");
+		} else {
+			await writeFile(target, "");
+			await symlink(target, link, "file");
+		}
+
+		await rm(link);
+		await rm(target, { recursive: true, force: true });
+		await rm(root, { recursive: true, force: true });
+		return true;
+	} catch (error) {
+		await rm(root, { recursive: true, force: true });
+		if (!(error instanceof Error)) throw error;
+		if (error.code === "EPERM" || error.code === "EEXIST") return false;
+		return false;
+	}
+}