oh-my-opencode 4.15.1 → 4.16.0

package/packages/omo-codex/plugin/components/codegraph/test/serve-mcp-bridge.test.ts

@@ -1,15 +1,28 @@
 import { describe, expect, it } from "bun:test";
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { PassThrough } from "node:stream";
+import { fileURLToPath } from "node:url";
 
 import { runCodegraphServe } from "../src/serve.ts";
+import {
+	arrayProperty,
+	findTool,
+	frameMcpRequest,
+	parseMcpBodies,
+	recordProperty,
+	recordValue,
+	stringProperty,
+	writeFakeContractCodegraph,
+	writeFakeNewlineCodegraph,
+} from "./mcp-bridge-fixtures.ts";
+
+const componentRoot = realpathSync(fileURLToPath(new URL("..", import.meta.url)));
 
 describe("runCodegraphServe MCP protocol bridge", () => {
 	it("#given Codex framed stdio and a newline-json CodeGraph child #when listing tools #then it bridges frames and serves from the project cwd", async () => {
 		// given
-		const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-bridge-"));
+		const tempRoot = mkdtempSync(join(componentRoot, ".tmp-codegraph-bridge-"));
 		const projectRoot = join(tempRoot, "project");
 		const pluginCacheRoot = join(tempRoot, "plugin-cache");
 		const fakeCodegraph = join(tempRoot, "codegraph-fake.cjs");
@@ -96,7 +109,7 @@ describe("runCodegraphServe MCP protocol bridge", () => {
 
 	it("#given old upstream codegraph_node metadata and container outline guidance #when bridging #then it exposes the corrected LazyCodex contract", async () => {
 		// given
-		const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-contract-"));
+		const tempRoot = mkdtempSync(join(componentRoot, ".tmp-codegraph-contract-"));
 		const projectRoot = join(tempRoot, "project");
 		const fakeCodegraph = join(tempRoot, "codegraph-contract-fake.cjs");
 		const childLog = join(tempRoot, "child.log");
@@ -178,110 +191,3 @@ describe("runCodegraphServe MCP protocol bridge", () => {
 		}
 	});
 });
-
-function writeFakeNewlineCodegraph(filePath: string): void {
-	writeFileSync(
-		filePath,
-		[
-			"#!/usr/bin/env node",
-			"const fs = require('node:fs');",
-			"const readline = require('node:readline');",
-			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, `cwd=${process.cwd()}\\n`);",
-			"const rl = readline.createInterface({ input: process.stdin });",
-			"rl.on('line', (line) => {",
-			"  const request = JSON.parse(line);",
-			"  if (request.method === 'initialize') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { capabilities: { tools: { listChanged: false } }, protocolVersion: request.params.protocolVersion, serverInfo: { name: 'codegraph', version: '1.0.1' } } }) + '\\n');",
-			"  }",
-			"  if (request.method === 'tools/list') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: [{ name: 'codegraph_search' }, { name: 'codegraph_node' }, { name: 'codegraph_explore' }, { name: 'codegraph_callers' }] } }) + '\\n');",
-			"  }",
-			"});",
-		].join("\n"),
-	);
-	chmodSync(filePath, 0o755);
-}
-
-function writeFakeContractCodegraph(filePath: string): void {
-	writeFileSync(
-		filePath,
-		[
-			"#!/usr/bin/env node",
-			"const fs = require('node:fs');",
-			"const readline = require('node:readline');",
-			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, `cwd=${process.cwd()}\\n`);",
-			"const rl = readline.createInterface({ input: process.stdin });",
-			"rl.on('line', (line) => {",
-			"  const request = JSON.parse(line);",
-			"  if (request.method === 'tools/list') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: [",
-			"      { name: 'codegraph_search', description: 'search stays unchanged' },",
-			"      { name: 'codegraph_node', description: 'ONE SYMBOL you can name - its location, signature, verbatim source (includeCode=true) and caller/callee trail in one call', inputSchema: { type: 'object', properties: { includeCode: { type: 'boolean', description: \"Symbol mode: include the symbol's full body (default: false).\" }, symbol: { type: 'string' } } } }",
-			"    ] } }) + '\\n');",
-			"  }",
-			"  if (request.method === 'tools/call') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { content: [{ type: 'text', text: 'JsonlMCP\\nMembers (7)\\nStructural outline only. For full source, use the Read tool on this file or request a member.' }] } }) + '\\n');",
-			"  }",
-			"});",
-		].join("\n"),
-	);
-	chmodSync(filePath, 0o755);
-}
-
-function frameMcpRequest(request: {
-	readonly id: number;
-	readonly method: string;
-	readonly params: Record<string, unknown>;
-}): string {
-	const body = JSON.stringify({ jsonrpc: "2.0", ...request });
-	return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
-}
-
-function parseMcpBodies(transcript: string): readonly unknown[] {
-	const bodies: unknown[] = [];
-	let cursor = 0;
-	while (cursor < transcript.length) {
-		const headerEnd = transcript.indexOf("\r\n\r\n", cursor);
-		if (headerEnd === -1) break;
-		const header = transcript.slice(cursor, headerEnd);
-		const match = /^Content-Length: (?<length>\d+)$/m.exec(header);
-		if (match?.groups?.["length"] === undefined) break;
-		const length = Number.parseInt(match.groups["length"], 10);
-		const bodyStart = headerEnd + 4;
-		const body = transcript.slice(bodyStart, bodyStart + length);
-		bodies.push(JSON.parse(body));
-		cursor = bodyStart + length;
-	}
-	return bodies;
-}
-
-function findTool(tools: readonly unknown[], name: string): Record<string, unknown> {
-	for (const tool of tools) {
-		const record = recordValue(tool);
-		if (record["name"] === name) return record;
-	}
-	throw new Error(`Missing tool ${name}`);
-}
-
-function arrayProperty(record: Record<string, unknown>, key: string): readonly unknown[] {
-	const value = record[key];
-	if (!Array.isArray(value)) throw new Error(`Expected ${key} to be an array`);
-	return value;
-}
-
-function recordProperty(record: Record<string, unknown>, key: string): Record<string, unknown> {
-	return recordValue(record[key]);
-}
-
-function stringProperty(record: Record<string, unknown>, key: string): string {
-	const value = record[key];
-	if (typeof value !== "string") throw new Error(`Expected ${key} to be a string`);
-	return value;
-}
-
-function recordValue(value: unknown): Record<string, unknown> {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		throw new Error("Expected record value");
-	}
-	return value as Record<string, unknown>;
-}

package/packages/omo-codex/plugin/components/codegraph/test/serve-provision.test.ts

@@ -41,7 +41,7 @@ describe("runCodegraphServe provisioning", () => {
 			{
 				args: ["serve", "--mcp"],
 				command: binPath,
-				env: { PATH: "/bin" },
+				env: { CODEGRAPH_NO_DAEMON: "1", PATH: "/bin" },
 			},
 		]);
 	});

package/packages/omo-codex/plugin/components/codegraph/test/serve.test.ts

@@ -1,8 +1,8 @@
 import { describe, expect, it } from "bun:test";
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
+import { Readable, Writable } from "node:stream";
 import { fileURLToPath } from "node:url";
 
 import { resolveServeProcessInvocation, runCodegraphServe } from "../src/serve.ts";
@@ -54,6 +54,7 @@ describe("runCodegraphServe", () => {
 				cwd: resolve(runCwd),
 				env: {
 					CODEGRAPH_INSTALL_DIR: "/tmp/home/.omo/codegraph",
+					CODEGRAPH_NO_DAEMON: "1",
 					CODEGRAPH_NO_DOWNLOAD: "1",
 					CODEGRAPH_TELEMETRY: "0",
 					DO_NOT_TRACK: "1",
@@ -176,6 +177,7 @@ describe("runCodegraphServe", () => {
 						command: binPath,
 						env: {
 							CODEGRAPH_INSTALL_DIR: installDir,
+							CODEGRAPH_NO_DAEMON: "1",
 							CODEGRAPH_NO_DOWNLOAD: "1",
 							CODEGRAPH_TELEMETRY: "0",
 							DO_NOT_TRACK: "1",
@@ -189,6 +191,47 @@ describe("runCodegraphServe", () => {
 		});
 	});
 
+	it("#given project cwd is under a configured excluded root #when serving MCP #then it exposes an unavailable stub without spawning CodeGraph", async () => {
+		// given
+		const excludedRoot = mkdtempSync(join(componentRoot, ".tmp-codegraph-excluded-"));
+		const projectRoot = join(excludedRoot, "repo");
+		const stderr: string[] = [];
+		const stdout: string[] = [];
+		const calls: string[] = [];
+		mkdirSync(projectRoot, { recursive: true });
+
+		try {
+			// when
+			const exitCode = await runCodegraphServe({
+				config: { codegraph: { enabled: true, excluded_roots: [excludedRoot] }, sources: [], warnings: [] },
+				cwd: projectRoot,
+				env: { HOME: "/tmp/home" },
+				homeDir: "/tmp/home",
+				nodeVersion: "22.14.0",
+				resolve: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
+				runProcess: () => {
+					calls.push("spawned");
+					return Promise.resolve(0);
+				},
+				stderr: { write: (chunk) => stderr.push(chunk) },
+				stdin: Readable.from([]),
+				stdout: new Writable({
+					write: (chunk, _encoding, callback) => {
+						stdout.push(String(chunk));
+						callback();
+					},
+				}),
+			});
+
+			// then
+			expect(exitCode).toBe(0);
+			expect(calls).toEqual([]);
+			expect(stderr.join("")).toContain("CodeGraph MCP skipped: project excluded");
+		} finally {
+			rmSync(excludedRoot, { recursive: true, force: true });
+		}
+	});
+
 	it("#given Windows OMO_CODEGRAPH_BIN is a Node script #when resolving serve invocation #then Node executes the script path", () => {
 		// given
 		const scriptPath = "C:\\Users\\runner\\codegraph-fake.cjs";
@@ -217,73 +260,8 @@ describe("runCodegraphServe", () => {
 		});
 	});
 
-	it("#given built serve entry #when invoked with a fake CodeGraph binary #then it runs serve mcp exactly once", () => {
-		// given
-		const tempRoot = createFakeCodegraphRoot();
-		try {
-			// when
-			const result = runBuiltWrapper("dist/serve.js", tempRoot);
-
-			// then
-			expect(result.status).toBe(0);
-			expect(result.stderr).toBe("");
-			expect(readInvocations(tempRoot)).toEqual(['["serve","--mcp"]']);
-		} finally {
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given built cli entry #when invoked with a fake CodeGraph binary #then it runs serve mcp exactly once", () => {
-		// given
-		const tempRoot = createFakeCodegraphRoot();
-		try {
-			// when
-			const result = runBuiltWrapper("dist/cli.js", tempRoot);
-
-			// then
-			expect(result.status).toBe(0);
-			expect(result.stderr).toBe("");
-			expect(readInvocations(tempRoot)).toEqual(['["serve","--mcp"]']);
-		} finally {
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-	});
 });
 
-function createFakeCodegraphRoot(): string {
-	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-wrapper-"));
-	const fakeBinaryPath = join(tempRoot, "codegraph-fake.cjs");
-	writeFileSync(
-		fakeBinaryPath,
-		[
-			"#!/usr/bin/env node",
-			"const fs = require('node:fs');",
-			"fs.appendFileSync(process.env.CODEGRAPH_FAKE_LOG, JSON.stringify(process.argv.slice(2)) + '\\n');",
-			"",
-		].join("\n"),
-	);
-	chmodSync(fakeBinaryPath, 0o755);
-	return tempRoot;
-}
-
-function runBuiltWrapper(entryPath: string, tempRoot: string): ReturnType<typeof spawnSync> {
-	return spawnSync(process.execPath, [join(componentRoot, entryPath)], {
-		cwd: componentRoot,
-		encoding: "utf8",
-		env: {
-			...process.env,
-			CODEGRAPH_ALLOW_UNSAFE_NODE: "1",
-			CODEGRAPH_FAKE_LOG: join(tempRoot, "invocations.log"),
-			OMO_CODEGRAPH_BIN: join(tempRoot, "codegraph-fake.cjs"),
-		},
-		timeout: 5000,
-	});
-}
-
-function readInvocations(tempRoot: string): readonly string[] {
-	return readFileSync(join(tempRoot, "invocations.log"), "utf8").trim().split("\n");
-}
-
 async function withProcessPlatform(platform: NodeJS.Platform, run: () => Promise<void>): Promise<void> {
 	const descriptor = Object.getOwnPropertyDescriptor(process, "platform");
 	Object.defineProperty(process, "platform", { configurable: true, enumerable: true, value: platform });

package/packages/omo-codex/plugin/components/codegraph/test/sweep-cli.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runCodegraphCli } from "../src/cli.ts";
+
+describe("CodeGraph sweep CLI", () => {
+	it("#given sweep dry-run args with an injected root #when invoked #then it reports candidates as JSON and does not kill", async () => {
+		// given
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-sweep-cli-home-"));
+		const root = join(homeDir, ".codex", "plugins", "cache", "sisyphuslabs", "omo", "4.15.1");
+		const stdout: string[] = [];
+		const killed: string[] = [];
+		try {
+			// when
+			const exitCode = await runCodegraphCli({
+				argv: ["node", "cli.js", "sweep", "--dry-run", "--force", "--root", root],
+				env: { HOME: homeDir },
+				stdout: { write: (chunk) => stdout.push(chunk) },
+				sweepOptions: {
+					killer: {
+						isAlive: () => true,
+						kill: (pid) => {
+							killed.push(`kill:${pid}`);
+							return Promise.resolve();
+						},
+						terminate: (pid) => {
+							killed.push(`term:${pid}`);
+							return Promise.resolve();
+						},
+					},
+					processProvider: () => Promise.resolve([
+						{
+							command: `${process.execPath} ${root}/components/codegraph/dist/serve.js`,
+							pid: 601,
+							ppid: 1,
+						},
+					]),
+				},
+			});
+
+			// then
+			expect(exitCode).toBe(0);
+			expect(killed).toEqual([]);
+			expect(JSON.parse(stdout.join(""))).toMatchObject({
+				action: "swept",
+				candidates: [{ pid: 601 }],
+				dryRun: true,
+				killed: [],
+			});
+		} finally {
+			rmSync(homeDir, { force: true, recursive: true });
+		}
+	});
+});

package/packages/omo-codex/plugin/components/comment-checker/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"description": "Codex plugin that runs comment-checker after edit-like PostToolUse hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/git-bash/AGENTS.md

@@ -0,0 +1,31 @@
+# git-bash — Codex plugin component: Windows git_bash MCP reminder hook
+
+**Generated:** 2026-07-03
+
+## OVERVIEW
+
+Component wrapper (`@sisyphuslabs/codex-git-bash-hook`, private, bin `omo-git-bash-hook`) that steers Windows Codex sessions toward the OMO `git_bash` MCP: a `PreToolUse` hook on `^Bash$` injects one `additionalContext` reminder per session to prefer `git_bash` over built-in `exec_command`; a `PostCompact` hook clears the once-per-session marker so the reminder re-fires after compaction. This component is NOT the MCP — the `git_bash` stdio server is declared plugin-wide in [`.mcp.json`](../../.mcp.json) (`node ../../git-bash-mcp/dist/cli.js mcp`) and implemented by [`packages/git-bash-mcp`](../../../../git-bash-mcp/AGENTS.md). Emits nothing on non-Windows hosts.
+
+## KEY FILES
+
+| File | Role |
+|------|------|
+| `src/codex-hook.ts` | All logic: payload parsing + type guards, Windows detection, reminder marker lifecycle, hook JSON output |
+| `src/cli.ts` | Bin entry; subcommands `hook pre-tool-use` / `hook post-compact` (stdin JSON in, hook JSON on stdout) |
+| `src/index.ts` | Barrel export of the `codex-hook` API |
+| `hooks/hooks.json` | Codex wiring: `PreToolUse` matcher `^Bash$` + `PostCompact`, both `node "${PLUGIN_ROOT}/dist/cli.js"`, 5s timeout |
+| `test/codex-hook.test.ts` | 7 `bun:test` cases (given/when/then): once-per-session reminder, non-Bash / non-Windows skip, PostCompact reset, CLI stream round-trip |
+
+## WHERE TO LOOK
+
+- MCP internals (tools `run` / `which_bash` / `diagnose`, `bash.exe` resolution, timeout env chain) → [`packages/git-bash-mcp/AGENTS.md`](../../../../git-bash-mcp/AGENTS.md). Do not document them here.
+- Install-time handling → `packages/omo-codex/src/install/`: `codex-cache-bundled-mcps.ts` copies the MCP dist into the plugin cache and rewrites the `.mcp.json` arg to `./components/git-bash-mcp/dist/cli.js`; `codex-config-plugins.ts` sets `[plugins."omo@sisyphuslabs".mcp_servers.git_bash]` `enabled = true` only on win32 with Git Bash resolved (`enabled = false` elsewhere); `codex-git-bash-mcp-env.ts` `stampGitBashMcpEnv()` stamps `OMO_CODEX_GIT_BASH_PATH` into the server `env` on win32 when the override env var is set.
+- Component roster + skills sync pipeline → [`packages/omo-codex/AGENTS.md`](../../../AGENTS.md).
+
+## NOTES
+
+- **Windows detection is env-tolerant** (`isWindowsHost`): `platform === "win32"` OR any of `OS=Windows_NT` / `ComSpec` / `SystemRoot` present, so bash-hosted shells on Windows still count.
+- **Marker path:** `${PLUGIN_DATA:-~/.codex/omo-git-bash}/git-bash-reminder/<session_id>.seen`; session id sanitized to `[A-Za-z0-9._-]`. `PostCompact` removes it with `rmSync(force)`.
+- **Hook must never block the user's Bash call:** the CLI swallows parse/fs errors and exits 0 on both hook paths; malformed or empty stdin yields empty output.
+- **Runtime dep-free Node >=20 ESM.** `@oh-my-opencode/utils` is a devDependency only (`file:` link). Build `tsc -p tsconfig.build.json`; tests run via `bun test test/*.test.ts` (unlike the vitest-based `lsp` component).
+- **Windows absolute MCP targets are valid:** `isPluginRuntimePathArg` in `packages/omo-opencode/src/cli/doctor/checks/codex-components.ts` and `script/lazycodex-marketplace-validation.ts` gained `isAbsolute(arg)` so a rewritten `C:\...` git_bash/lsp entrypoint passes validation (commit 3b1681ae8).

package/packages/omo-codex/plugin/components/git-bash/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-git-bash-hook",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"description": "Codex hook component that reminds Windows sessions to prefer the OMO git_bash MCP.",
 	"type": "module",
 	"private": true,

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/AGENTS.md

@@ -0,0 +1,45 @@
+# lazycodex-executor-verify
+
+**Generated:** 2026-07-03
+
+## OVERVIEW
+
+Codex `SubagentStop` hook component: the evidence gate for the `lazycodex-executor` subagent (ultrawork implementation executor). When the executor stops without a valid evidence receipt, the hook emits `{"decision": "block", "reason": <directive>}` and Codex sends it back to work. Matcher is `^lazycodex-executor$` only; `lazycodex-qa-executor` and `lazycodex-gate-reviewer` (same `ultrawork/agents/` family) are NOT gated by this hook.
+
+Valid receipt: `last_assistant_message` contains `EVIDENCE_RECORDED: <path>` where `<path>` resolves to a non-empty regular file strictly inside `<cwd>/.omo/evidence/`. Symlinks and directories rejected; containment checked on realpaths (file inside evidence root inside cwd, traversal-safe). A valid receipt clears attempt state and exits silently.
+
+Escape hatches: after 3 blocked attempts (`MAX_ATTEMPTS`) the stop passes and state clears; a transcript containing a context-pressure marker ("context compacted", "context_length_exceeded", ...) passes immediately. Malformed stdin, unknown events, unrelated agents: silent exit 0 (fail-open).
+
+## KEY FILES
+
+| File | Role |
+|------|------|
+| `src/codex-hook.ts` | Core `runSubagentStopHook()`: input guard, receipt validation, attempt escalation, block decision |
+| `src/state.ts` | Attempt counter at `<cwd>/.omo/lazycodex-executor-verify/<session>-<agent>.json`; atomic tmp+rename write; `MAX_ATTEMPTS = 3` |
+| `src/directive.ts` | Loads `directive.md` at import time; `renderDirective()` fills `{{ATTEMPT_COUNT}}` + `{{LAST_ASSISTANT_MESSAGE}}` |
+| `directive.md` | Korean block message ("your completion claim is not trusted until evidence is recorded"); RUNTIME-READ via `../directive.md` relative to `dist/` |
+| `src/cli.ts` | Node bin `lazycodex-executor-verify hook subagent-stop`: stdin JSON in, block JSON (or nothing) on stdout |
+| `src/types.ts` | `SubagentStopInput` field guard, `StopHookOutput` (block-only shape), injectable `HookFileSystem` |
+| `hooks/hooks.json` | Component-local wiring (Unix `node .../dist/cli.js` command only) |
+| `test/codex-hook.test.ts`, `test/cli.test.ts` | Vitest given/when/then: symlink/traversal/zero-byte receipts, attempt escalation and cap, context pressure, malformed stdin |
+
+## WHERE TO LOOK
+
+| Task | Location |
+|------|----------|
+| Change the block message | `directive.md`; keep both `{{...}}` placeholders and the literal `EVIDENCE_RECORDED: <path>` final-line contract |
+| Change receipt validation | `src/codex-hook.ts` (`hasValidEvidenceReceipt`, `extractEvidencePath`, `isNonEmptyFileInsideEvidenceRoot`) |
+| Change the retry budget | `src/state.ts` `MAX_ATTEMPTS` |
+| Executor-side contract | `../ultrawork/agents/lazycodex-executor.toml` instructs the final `EVIDENCE_RECORDED: <path>` line this hook parses |
+| Plugin-level wiring | `../../hooks/subagent-stop-verifying-lazycodex-executor-evidence.json` (adds `commandWindows` via `../bootstrap/scripts/node-dispatch.ps1`) |
+| Wiring + contract tests | `../../test/aggregate-hooks.test.mjs`, `../../test/component-hook-contract-cases.mjs`, `../../test/hook-status-message.test.mjs`, `../../test/component-bundled-cli.test.mjs` |
+
+## NOTES
+
+- Node >=20, npm + vitest + biome, TypeScript 6 strict. No Bun APIs: Codex launches hooks with Node. `npm test` builds first, then runs vitest.
+- `hooks/hooks.json` (component) and `../../hooks/subagent-stop-verifying-lazycodex-executor-evidence.json` (aggregate) are hand-maintained twins. Edit both or aggregate tests fail. Only the aggregate copy carries the Windows dispatch.
+- `dist/` is gitignored, but root `package.json` `files` ships `.../lazycodex-executor-verify/dist/cli.js` and the hook command targets `dist/cli.js`. Nothing works from a fresh clone until a build runs.
+- `directive.md` is read at runtime, not bundled: `dist/directive.js` resolves `../directive.md`, so the file must stay at component root (it is in `package.json` `files`).
+- `stop_hook_active: true` does NOT bypass the check; the directive says so explicitly. Only the attempt cap and context-pressure markers let a receipt-less stop through.
+- Blocking output is the stable Codex stop-hook contract: `decision: "block"` + `reason`, nothing else. A passing stop is empty stdout, exit 0. The only nonzero exit is a CLI usage error.
+- The receipt regex takes the first `EVIDENCE_RECORDED:` match and a single `\S+` token: no spaces in evidence paths.

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lazycodex-executor-verify",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"description": "Codex SubagentStop evidence verifier for LazyCodex executor completions.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lsp",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"description": "Codex plugin that exposes Language Server Protocol tools and post-edit diagnostics.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",