lazycodex-ai 4.16.0 → 4.16.2

package/packages/omo-codex/plugin/components/ulw-loop/test/plan-io.test.ts

@@ -1,16 +1,18 @@
-import { copyFile, mkdir, mkdtemp, readdir, readFile, writeFile } from "node:fs/promises";
+import { appendFile, copyFile, mkdir, mkdtemp, readdir, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { setImmediate as tick } from "node:timers/promises";
 import { beforeEach, describe, expect, it } from "vitest";
 import { ulwLoopDir, ulwLoopGoalsPath, ulwLoopLedgerPath } from "../src/paths.js";
 import {
 	appendLedger,
+	findAcceptedSteeringLedgerEntry,
 	readSteeringLedgerEntries,
 	readUlwLoopPlan,
 	withUlwLoopMutationLock,
 	writePlan,
 } from "../src/plan-io.js";
-import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan } from "../src/types.js";
+import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan, UlwLoopSteeringAudit } from "../src/types.js";
 import { UlwLoopError } from "../src/types.js";
 
 const NOW = "2026-05-23T00:00:00.000Z";
@@ -51,6 +53,45 @@ function entry(kind: UlwLoopLedgerEntry["kind"], goalId = "G001"): UlwLoopLedger
 	return { at: NOW, kind, goalId };
 }
 
+function steeringAudit(overrides: Partial<UlwLoopSteeringAudit> = {}): UlwLoopSteeringAudit {
+	return {
+		kind: "revise_pending_wording",
+		source: "cli",
+		targetGoalIds: ["G001"],
+		evidence: "observed evidence",
+		rationale: "needed change",
+		invariant: {
+			accepted: true,
+			structuralInvariantAccepted: true,
+			evidenceBackedNecessity: true,
+			noEasierCompletion: true,
+			rejectedReasons: [],
+		},
+		...overrides,
+	};
+}
+
+function rejectedSteeringAudit(overrides: Partial<UlwLoopSteeringAudit> = {}): UlwLoopSteeringAudit {
+	return steeringAudit({
+		invariant: {
+			accepted: false,
+			structuralInvariantAccepted: false,
+			evidenceBackedNecessity: false,
+			noEasierCompletion: true,
+			rejectedReasons: ["missing evidence"],
+		},
+		...overrides,
+	});
+}
+
+function steeringEntry(
+	kind: UlwLoopLedgerEntry["kind"],
+	audit: UlwLoopSteeringAudit,
+	overrides: Partial<UlwLoopLedgerEntry> = {},
+): UlwLoopLedgerEntry {
+	return { at: NOW, kind, goalId: "G001", steering: audit, ...overrides };
+}
+
 async function makeRepo(): Promise<string> {
 	return mkdtemp(join(tmpdir(), "ug-io-"));
 }
@@ -209,6 +250,112 @@ describe("readSteeringLedgerEntries", () => {
 	});
 });
 
+describe("findAcceptedSteeringLedgerEntry", () => {
+	it.each([
+		[
+			"top-level idempotencyKey",
+			steeringEntry("steering_accepted", steeringAudit(), { idempotencyKey: "needle-key" }),
+		],
+		["steering.idempotencyKey", steeringEntry("steering_accepted", steeringAudit({ idempotencyKey: "needle-key" }))],
+		[
+			"steering.promptSignature",
+			steeringEntry("steering_accepted", steeringAudit({ promptSignature: "needle-key" })),
+		],
+	] as const)("finds an accepted entry by %s", async (_name, target) => {
+		// given
+		const repoRoot = await makeRepo();
+		await appendLedger(repoRoot, steeringEntry("steering_accepted", steeringAudit({ idempotencyKey: "other-key" })));
+		await appendLedger(repoRoot, target);
+
+		// when
+		const found = await findAcceptedSteeringLedgerEntry(repoRoot, "needle-key");
+
+		// then
+		expect(found).toEqual(target);
+	});
+
+	it("skips a rejected entry carrying the same key", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		await appendLedger(
+			repoRoot,
+			steeringEntry("steering_rejected", rejectedSteeringAudit({ idempotencyKey: "needle-key" })),
+		);
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toBeUndefined();
+	});
+
+	it("returns the accepted entry even when a rejected one with the same key precedes it", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		const accepted = steeringEntry("steering_accepted", steeringAudit({ idempotencyKey: "needle-key" }));
+		await appendLedger(
+			repoRoot,
+			steeringEntry("steering_rejected", rejectedSteeringAudit({ idempotencyKey: "needle-key" })),
+		);
+		await appendLedger(repoRoot, accepted);
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toEqual(accepted);
+	});
+
+	it("returns undefined when the ledger file is missing", async () => {
+		// given
+		const repoRoot = await makeRepo();
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toBeUndefined();
+	});
+
+	it("ignores the key when it only appears in non-steering entries", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		await appendLedger(repoRoot, { at: NOW, kind: "goal_completed", goalId: "G001", idempotencyKey: "needle-key" });
+		await appendLedger(repoRoot, { at: NOW, kind: "evidence_captured", goalId: "G001", evidence: "needle-key" });
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toBeUndefined();
+	});
+
+	it("ignores an accepted entry whose key only appears in evidence text", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		await appendLedger(repoRoot, steeringEntry("steering_accepted", steeringAudit({ evidence: "needle-key" })));
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toBeUndefined();
+	});
+
+	it("finds the key inside a legacy entry embedding full before/after plans", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		const bulkyGoals = Array.from({ length: 20 }, (_, index) =>
+			makeGoal({ id: `G${String(index + 1).padStart(3, "0")}`, objective: `evidence detail ${index} `.repeat(200) }),
+		);
+		const bulkyPlan = makePlan({ goals: bulkyGoals });
+		const legacyLine = JSON.stringify({
+			at: NOW,
+			kind: "steering_accepted",
+			goalId: "G001",
+			idempotencyKey: "needle-key",
+			before: bulkyPlan,
+			after: bulkyPlan,
+			steering: { ...steeringAudit({ idempotencyKey: "needle-key" }), before: bulkyPlan, after: bulkyPlan },
+		});
+		await mkdir(ulwLoopDir(repoRoot), { recursive: true });
+		await appendFile(ulwLoopLedgerPath(repoRoot), `${legacyLine}\n`, "utf8");
+
+		// when
+		const found = await findAcceptedSteeringLedgerEntry(repoRoot, "needle-key");
+
+		// then
+		expect(legacyLine.length).toBeGreaterThan(100_000);
+		expect(found?.kind).toBe("steering_accepted");
+		expect(found?.idempotencyKey).toBe("needle-key");
+	});
+});
+
 describe("withUlwLoopMutationLock", () => {
 	it("serializes concurrent invocations", async () => {
 		// given
@@ -236,4 +383,115 @@ describe("withUlwLoopMutationLock", () => {
 		expect(maxActive).toBe(1);
 		expect(await readFile(counterPath, "utf8")).toBe("3");
 	});
+
+	it("propagates the body rejection and keeps later calls working", async () => {
+		// given
+		const repoRoot = await makeRepo();
+
+		// when
+		const failure = withUlwLoopMutationLock(repoRoot, async () => {
+			throw new Error("body exploded");
+		});
+
+		// then
+		await expect(failure).rejects.toThrow("body exploded");
+		await expect(withUlwLoopMutationLock(repoRoot, async () => "recovered")).resolves.toBe("recovered");
+	});
+
+	it("still serializes a second batch after the first batch's gate settles", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		let active = 0;
+		let maxActive = 0;
+		const body = async (): Promise<void> => {
+			active += 1;
+			maxActive = Math.max(maxActive, active);
+			await tick();
+			active -= 1;
+		};
+
+		// when
+		await Promise.all([1, 2, 3].map(() => withUlwLoopMutationLock(repoRoot, body)));
+		await tick();
+		await Promise.all([1, 2].map(() => withUlwLoopMutationLock(repoRoot, body)));
+
+		// then
+		expect(maxActive).toBe(1);
+	});
+
+	it("keeps an in-flight successor locked when an earlier gate settles", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		const events: string[] = [];
+		let releaseSecond = false;
+
+		// when
+		const first = withUlwLoopMutationLock(repoRoot, async () => {
+			events.push("first");
+		});
+		const second = withUlwLoopMutationLock(repoRoot, async () => {
+			events.push("second:start");
+			while (!releaseSecond) await tick();
+			events.push("second:end");
+		});
+		await first;
+		await tick();
+		const third = withUlwLoopMutationLock(repoRoot, async () => {
+			events.push("third");
+		});
+		releaseSecond = true;
+		await Promise.all([second, third]);
+
+		// then
+		expect(events).toEqual(["first", "second:start", "second:end", "third"]);
+	});
+
+	it("does not serialize distinct repo roots against each other", async () => {
+		// given
+		const rootA = await makeRepo();
+		const rootB = await makeRepo();
+		const events: string[] = [];
+		let releaseA = false;
+
+		// when
+		const held = withUlwLoopMutationLock(rootA, async () => {
+			events.push("a:start");
+			while (!releaseA) await tick();
+			events.push("a:end");
+		});
+		await withUlwLoopMutationLock(rootB, async () => {
+			events.push("b");
+		});
+		releaseA = true;
+		await held;
+
+		// then
+		expect(events).toEqual(["a:start", "b", "a:end"]);
+	});
+
+	it("serializes per scope while distinct scopes stay independent", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		const scoped = { sessionId: "session-a" };
+		const events: string[] = [];
+		let releaseScoped = false;
+
+		// when
+		const heldScoped = withUlwLoopMutationLock(repoRoot, scoped, async () => {
+			events.push("scoped-1:start");
+			while (!releaseScoped) await tick();
+			events.push("scoped-1:end");
+		});
+		const queuedScoped = withUlwLoopMutationLock(repoRoot, scoped, async () => {
+			events.push("scoped-2");
+		});
+		await withUlwLoopMutationLock(repoRoot, async () => {
+			events.push("root-scope");
+		});
+		releaseScoped = true;
+		await Promise.all([heldScoped, queuedScoped]);
+
+		// then
+		expect(events).toEqual(["scoped-1:start", "root-scope", "scoped-1:end", "scoped-2"]);
+	});
 });

package/packages/omo-codex/plugin/components/ulw-loop/test/skill-contract.test.ts

@@ -65,6 +65,6 @@ describe("ulw-loop skill contract", () => {
 		// then
 		expect(workflow.match(/malformed input, prompt injection/g)?.length ?? 0).toBe(1);
 		expect(wordCount(workflow)).toBeLessThanOrEqual(3697);
-		expect(wordCount(skill)).toBeLessThanOrEqual(611);
+		expect(wordCount(skill)).toBeLessThanOrEqual(625);
 	});
 });

package/packages/omo-codex/plugin/components/ulw-loop/test/steering-snapshot.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { buildSteeringPlanSnapshot, changedGoalIdsBetween } from "../src/steering-snapshot.js";
+import type { UlwLoopItem, UlwLoopPlan } from "../src/types.js";
+
+const NOW = "2026-05-23T00:00:00.000Z";
+
+function goal(id: string, overrides: Partial<UlwLoopItem> = {}): UlwLoopItem {
+	return {
+		id,
+		title: `Goal ${id}`,
+		objective: `Objective for ${id}`,
+		status: "pending",
+		successCriteria: [],
+		attempt: 0,
+		createdAt: NOW,
+		updatedAt: NOW,
+		...overrides,
+	};
+}
+
+function plan(goals: UlwLoopItem[], overrides: Partial<UlwLoopPlan> = {}): UlwLoopPlan {
+	return {
+		version: 1,
+		createdAt: NOW,
+		updatedAt: NOW,
+		briefPath: ".omo/ulw-loop/brief.md",
+		goalsPath: ".omo/ulw-loop/goals.json",
+		ledgerPath: ".omo/ulw-loop/ledger.jsonl",
+		goals,
+		...overrides,
+	};
+}
+
+describe("changedGoalIdsBetween", () => {
+	it.each([
+		{
+			name: "added goal",
+			before: [goal("G001"), goal("G002")],
+			after: [goal("G001"), goal("G002"), goal("G003")],
+			expected: ["G003"],
+		},
+		{
+			name: "removed goal",
+			before: [goal("G001"), goal("G002")],
+			after: [goal("G001")],
+			expected: ["G002"],
+		},
+		{
+			name: "mutated goal",
+			before: [goal("G001"), goal("G002")],
+			after: [goal("G001"), goal("G002", { title: "Rewritten" })],
+			expected: ["G002"],
+		},
+		{
+			name: "reordered-only goals",
+			before: [goal("G001"), goal("G002"), goal("G003")],
+			after: [goal("G003"), goal("G001"), goal("G002")],
+			expected: [],
+		},
+		{
+			name: "identical plans",
+			before: [goal("G001"), goal("G002")],
+			after: [goal("G001"), goal("G002")],
+			expected: [],
+		},
+		{
+			name: "add + remove + mutate at once",
+			before: [goal("G001"), goal("G002"), goal("G003")],
+			after: [goal("G001", { status: "blocked" }), goal("G003"), goal("G004")],
+			expected: ["G001", "G002", "G004"],
+		},
+	])("detects $name", ({ before, after, expected }) => {
+		// when
+		const changed = changedGoalIdsBetween(plan(before), plan(after));
+
+		// then
+		expect([...changed].sort()).toEqual(expected);
+	});
+});
+
+describe("buildSteeringPlanSnapshot", () => {
+	it("includes only changed goals while keeping full goalIds order and goalCount", () => {
+		// given
+		const goals = [goal("G001"), goal("G002"), goal("G003"), goal("G004")];
+		const source = plan(goals);
+
+		// when
+		const snapshot = buildSteeringPlanSnapshot(source, new Set(["G003"]));
+
+		// then
+		expect(snapshot.goals.map((item) => item.id)).toEqual(["G003"]);
+		expect(snapshot.goals[0]).toEqual(goals[2]);
+		expect(snapshot.goalIds).toEqual(["G001", "G002", "G003", "G004"]);
+		expect(snapshot.goalCount).toBe(4);
+		expect(snapshot.updatedAt).toBe(NOW);
+	});
+
+	it("omits the activeGoalId key entirely when the plan has none", () => {
+		// when
+		const snapshot = buildSteeringPlanSnapshot(plan([goal("G001")]), new Set(["G001"]));
+
+		// then
+		expect("activeGoalId" in snapshot).toBe(false);
+	});
+
+	it("carries activeGoalId when the plan has one", () => {
+		// when
+		const snapshot = buildSteeringPlanSnapshot(plan([goal("G001")], { activeGoalId: "G001" }), new Set());
+
+		// then
+		expect(snapshot.activeGoalId).toBe("G001");
+	});
+
+	it("keeps plan order for changed goals regardless of set insertion order", () => {
+		// given
+		const source = plan([goal("G001"), goal("G002"), goal("G003")]);
+
+		// when
+		const snapshot = buildSteeringPlanSnapshot(source, new Set(["G003", "G001"]));
+
+		// then
+		expect(snapshot.goals.map((item) => item.id)).toEqual(["G001", "G003"]);
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/steering.test.ts

@@ -1,8 +1,8 @@
-import { mkdtemp, readFile } from "node:fs/promises";
+import { appendFile, mkdtemp, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
-import { ulwLoopGoalsPath } from "../src/paths.js";
+import { ulwLoopGoalsPath, ulwLoopLedgerPath } from "../src/paths.js";
 import { readSteeringLedgerEntries, readUlwLoopPlan, writePlan } from "../src/plan-io.js";
 import {
 	applySteeringMutation,
@@ -12,6 +12,7 @@ import {
 } from "../src/steering.js";
 import type {
 	UlwLoopItem,
+	UlwLoopLedgerEntry,
 	UlwLoopPlan,
 	UlwLoopSteeringProposal,
 	UlwLoopSuccessCriterion,
@@ -320,6 +321,104 @@ describe("steerUlwLoop", () => {
 		expect(second.deduped).toBe(true);
 		expect((await readUlwLoopPlan(repoRoot)).goals).toHaveLength(4);
 	});
+
+	describe("compact steering ledger entries", () => {
+		const DETAIL = "evidence detail ".repeat(200);
+
+		function fatGoal(id: string): UlwLoopItem {
+			return goal({
+				id,
+				title: `Fat goal ${id}`,
+				objective: `Objective ${id}: ${DETAIL}`,
+				evidence: DETAIL,
+				successCriteria: [
+					criterion({ id: "C001", scenario: DETAIL, expectedEvidence: DETAIL }),
+					criterion({ id: "C002", scenario: DETAIL, expectedEvidence: DETAIL }),
+				],
+			});
+		}
+
+		function fatPlan(): UlwLoopPlan {
+			return plan({
+				goals: Array.from({ length: 20 }, (_, index) => fatGoal(`G${String(index + 1).padStart(3, "0")}`)),
+			});
+		}
+
+		it("writes an O(changed goals) ledger entry instead of embedding the full plan", async () => {
+			// given
+			const seed = fatPlan();
+			const planBytes = JSON.stringify(seed).length;
+			const repoRoot = await repoWithPlan(seed);
+
+			// when
+			await steerUlwLoop(
+				repoRoot,
+				steering({ kind: "revise_pending_wording", targetGoalId: "G010", revisedTitle: "Sharper goal ten" }),
+			);
+
+			// then
+			const lines = (await readFile(ulwLoopLedgerPath(repoRoot), "utf8")).split("\n").filter(Boolean);
+			expect(lines).toHaveLength(1);
+			const line = lines[0] ?? "";
+			expect(line.length).toBeLessThan(planBytes / 4);
+			const entry: UlwLoopLedgerEntry = JSON.parse(line);
+			expect("before" in entry).toBe(false);
+			expect("after" in entry).toBe(false);
+			expect(entry.steering?.before?.goals.map((item) => item.id)).toEqual(["G010"]);
+			expect(entry.steering?.after?.goals.map((item) => item.id)).toEqual(["G010"]);
+			expect(entry.steering?.after?.goals[0]?.title).toBe("Sharper goal ten");
+			expect(entry.steering?.before?.goalCount).toBe(20);
+			expect(entry.steering?.before?.goalIds).toEqual(seed.goals.map((item) => item.id));
+		});
+	});
+
+	it("dedup against a legacy full-plan entry strips before/after from the returned audit", async () => {
+		// given
+		const seed = plan();
+		const repoRoot = await repoWithPlan(seed);
+		const legacyLine = JSON.stringify({
+			at: NOW,
+			kind: "steering_accepted",
+			goalId: "G001",
+			idempotencyKey: "legacy-key",
+			evidence: "observable blocker evidence",
+			message: "the plan must change to stay safe",
+			mutationKind: "revise_pending_wording",
+			steering: {
+				kind: "revise_pending_wording",
+				source: "cli",
+				targetGoalIds: ["G001"],
+				evidence: "observable blocker evidence",
+				rationale: "the plan must change to stay safe",
+				idempotencyKey: "legacy-key",
+				invariant: {
+					accepted: true,
+					structuralInvariantAccepted: true,
+					evidenceBackedNecessity: true,
+					noEasierCompletion: true,
+					rejectedReasons: [],
+				},
+				before: seed,
+				after: seed,
+			},
+		});
+		await appendFile(ulwLoopLedgerPath(repoRoot), `${legacyLine}\n`, "utf8");
+
+		// when
+		const result = await steerUlwLoop(repoRoot, steering({ idempotencyKey: "legacy-key" }));
+
+		// then
+		expect(result.deduped).toBe(true);
+		expect(result.accepted).toBe(true);
+		expect("before" in result.audit).toBe(false);
+		expect("after" in result.audit).toBe(false);
+		expect(result.audit).toMatchObject({
+			kind: "revise_pending_wording",
+			idempotencyKey: "legacy-key",
+			deduped: true,
+		});
+		expect((await readUlwLoopPlan(repoRoot)).goals).toEqual(seed.goals);
+	});
 });
 
 describe("parseUlwLoopSteeringDirective", () => {

package/packages/omo-codex/plugin/hooks/post-compact-resetting-git-bash-mcp-reminder.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/git-bash/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO) Resetting Git Bash MCP Reminder",
+						"statusMessage": "(OmO 4.16.2) Resetting Git Bash MCP Reminder",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\git-bash\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-compact-resetting-lsp-diagnostics-cache.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO) Resetting LSP Diagnostics Cache",
+						"statusMessage": "(OmO 4.16.2) Resetting LSP Diagnostics Cache",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\lsp\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-compact-resetting-project-rule-cache.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/rules/dist/cli.js\" hook post-compact",
 						"timeout": 10,
-						"statusMessage": "(OmO) Resetting Project Rule Cache",
+						"statusMessage": "(OmO 4.16.2) Resetting Project Rule Cache",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\rules\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-codegraph-init-guidance.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/codegraph/dist/cli.js\" hook post-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO) Checking CodeGraph Init Guidance",
+						"statusMessage": "(OmO 4.16.2) Checking CodeGraph Init Guidance",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\codegraph\\dist\\cli.js\" hook post-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-comments.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/comment-checker/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "(OmO) Checking Comments",
+						"statusMessage": "(OmO 4.16.2) Checking Comments",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\comment-checker\\dist\\cli.js\" hook post-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-lsp-diagnostics.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "(OmO) Checking LSP Diagnostics",
+						"statusMessage": "(OmO 4.16.2) Checking LSP Diagnostics",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\lsp\\dist\\cli.js\" hook post-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-thread-title-hygiene.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/teammode/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO) Checking Thread Title Hygiene",
+						"statusMessage": "(OmO 4.16.2) Checking Thread Title Hygiene",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\teammode\\dist\\cli.js\" hook post-tool-use"
 					}
 				]

package/packages/omo-codex/plugin/hooks/post-tool-use-matching-project-rules.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/rules/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO) Matching Project Rules",
+						"statusMessage": "(OmO 4.16.2) Matching Project Rules",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\rules\\dist\\cli.js\" hook post-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/pre-tool-use-enforcing-unlimited-goal-budget.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/ulw-loop/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO) Enforcing Unlimited Goal Budget",
+						"statusMessage": "(OmO 4.16.2) Enforcing Unlimited Goal Budget",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\ulw-loop\\dist\\cli.js\" hook pre-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/pre-tool-use-recommending-git-bash-mcp.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/git-bash/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO) Recommending Git Bash MCP",
+						"statusMessage": "(OmO 4.16.2) Recommending Git Bash MCP",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\git-bash\\dist\\cli.js\" hook pre-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/session-start-checking-auto-update.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/scripts/auto-update.mjs\" hook session-start",
 						"timeout": 5,
-						"statusMessage": "(OmO) Checking Auto Update",
+						"statusMessage": "(OmO 4.16.2) Checking Auto Update",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\scripts\\auto-update.mjs\" hook session-start"
 					}
 				],

package/packages/omo-codex/plugin/hooks/session-start-checking-bootstrap-provisioning.json

@@ -8,7 +8,7 @@
 						"command": "node \"${PLUGIN_ROOT}/components/bootstrap/dist/cli.js\" hook session-start",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\bootstrap.ps1\"",
 						"timeout": 30,
-						"statusMessage": "(OmO) Checking Bootstrap Provisioning"
+						"statusMessage": "(OmO 4.16.2) Checking Bootstrap Provisioning"
 					}
 				]
 			}