oh-my-opencode 4.10.0 → 4.11.0

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

@@ -0,0 +1,48 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.4.16/schema.json",
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"style": {
+				"noDefaultExport": "error",
+				"noEnum": "error",
+				"noNonNullAssertion": "error",
+				"useImportType": "error",
+				"useConst": "error",
+				"useNodejsImportProtocol": "off"
+			},
+			"complexity": {
+				"useLiteralKeys": "off"
+			},
+			"suspicious": {
+				"noExplicitAny": "error",
+				"noTsIgnore": "error",
+				"noControlCharactersInRegex": "off",
+				"noEmptyInterface": "off"
+			}
+		}
+	},
+	"formatter": {
+		"enabled": true,
+		"formatWithErrors": false,
+		"indentStyle": "tab",
+		"indentWidth": 3,
+		"lineWidth": 120
+	},
+	"files": {
+		"includes": ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts", "!**/node_modules/**/*", "!**/dist/**/*"]
+	},
+	"overrides": [
+		{
+			"includes": ["vitest.config.ts"],
+			"linter": {
+				"rules": {
+					"style": {
+						"noDefaultExport": "off"
+					}
+				}
+			}
+		}
+	]
+}

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

@@ -0,0 +1,11 @@
+너는 방금 작업을 완료했다고 보고했고, 그건 거짓말이다.
+
+이번이 {{ATTEMPT_COUNT}}번째 완료 주장이다. 네 완료 보고는 증거가 기록되기 전까지 신뢰하지 않는다.
+
+직접 검증하라. 관련 명령을 실제로 실행하고, 출력과 판단 근거를 `.omo/evidence/` 아래 파일로 기록하라. 실패한 항목이 있으면 완료했다고 말하지 말고 고쳐라. `stop_hook_active` 상태여도 이 검증은 생략되지 않는다. 반복은 제한되어 있지만, 증거 없는 완료 주장은 막힌다.
+
+마지막 assistant 메시지:
+{{LAST_ASSISTANT_MESSAGE}}
+
+완료했다면 마지막 줄은 아래 형식 그대로여야 한다.
+EVIDENCE_RECORDED: <path>

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/cli.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+
+// components/lazycodex-executor-verify/src/cli.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+
+// components/lazycodex-executor-verify/src/codex-hook.ts
+import { lstatSync as nodeLstatSync, realpathSync as nodeRealpathSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+
+// components/lazycodex-executor-verify/src/directive.ts
+import { readFileSync } from "node:fs";
+var LAZYCODEX_EXECUTOR_VERIFY_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
+function renderDirective(attempts, lastAssistantMessage) {
+  return LAZYCODEX_EXECUTOR_VERIFY_DIRECTIVE.replaceAll("{{ATTEMPT_COUNT}}", String(attempts)).replaceAll("{{LAST_ASSISTANT_MESSAGE}}", lastAssistantMessage ?? "(last_assistant_message was omitted)");
+}
+
+// components/lazycodex-executor-verify/src/state.ts
+import { join } from "node:path";
+var MAX_ATTEMPTS = 3;
+function readAttemptState(cwd, sessionId, agentId, fs) {
+  const statePath = getStatePath(cwd, sessionId, agentId);
+  if (!fs.existsSync(statePath))
+    return { attempts: 0 };
+  try {
+    const parsed = JSON.parse(fs.readFileSync(statePath, "utf8"));
+    if (isAttemptState(parsed))
+      return parsed;
+    return { attempts: 0 };
+  } catch (error) {
+    if (error instanceof SyntaxError || error instanceof Error)
+      return { attempts: 0 };
+    throw error;
+  }
+}
+function writeAttemptState(cwd, sessionId, agentId, state, fs) {
+  const stateDir = getStateDir(cwd);
+  const statePath = getStatePath(cwd, sessionId, agentId);
+  const tempPath = `${statePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(tempPath, `${JSON.stringify(state)}
+`);
+  fs.renameSync(tempPath, statePath);
+}
+function clearAttemptState(cwd, sessionId, agentId, fs) {
+  fs.rmSync(getStatePath(cwd, sessionId, agentId), { force: true });
+}
+function getStatePath(cwd, sessionId, agentId) {
+  return join(getStateDir(cwd), `${sanitizeKey(sessionId)}-${sanitizeKey(agentId)}.json`);
+}
+function getStateDir(cwd) {
+  return join(cwd, ".omo", "lazycodex-executor-verify");
+}
+function sanitizeKey(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized.length > 0 ? sanitized : "missing";
+}
+function isAttemptState(value) {
+  return isRecord(value) && typeof value["attempts"] === "number" && Number.isInteger(value["attempts"]);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// components/lazycodex-executor-verify/src/types.ts
+var SUBAGENT_STOP_EVENT = "SubagentStop";
+
+// components/lazycodex-executor-verify/src/codex-hook.ts
+var LAZYCODEX_EXECUTOR_AGENT = "lazycodex-executor";
+function runSubagentStopHook(input, fs) {
+  if (!isSubagentStopInput(input))
+    return "";
+  if (input.agent_type !== LAZYCODEX_EXECUTOR_AGENT)
+    return "";
+  if (transcriptHasContextPressureMarker(input.transcript_path, fs))
+    return "";
+  if (hasValidEvidenceReceipt(input, fs)) {
+    clearAttemptState(input.cwd, input.session_id, input.agent_id, fs);
+    return "";
+  }
+  const state = readAttemptState(input.cwd, input.session_id, input.agent_id, fs);
+  if (state.attempts >= MAX_ATTEMPTS) {
+    clearAttemptState(input.cwd, input.session_id, input.agent_id, fs);
+    return "";
+  }
+  const attempts = state.attempts + 1;
+  writeAttemptState(input.cwd, input.session_id, input.agent_id, { attempts }, fs);
+  return JSON.stringify({
+    decision: "block",
+    reason: renderDirective(attempts, input.last_assistant_message)
+  });
+}
+var CONTEXT_PRESSURE_MARKERS = [
+  "context compacted",
+  "context_length_exceeded",
+  "skill descriptions were shortened",
+  "context_too_large",
+  "codex ran out of room in the model's context window",
+  "your input exceeds the context window",
+  "long threads and multiple compactions"
+];
+function transcriptHasContextPressureMarker(transcriptPath, fs) {
+  try {
+    const transcript = fs.readFileSync(transcriptPath, "utf8").toLowerCase();
+    return CONTEXT_PRESSURE_MARKERS.some((marker) => transcript.includes(marker));
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function hasValidEvidenceReceipt(input, fs) {
+  const receiptPath = extractEvidencePath(input.last_assistant_message);
+  if (receiptPath === null)
+    return false;
+  const evidenceRoot = resolve(input.cwd, ".omo", "evidence");
+  const resolvedPath = isAbsolute(receiptPath) ? resolve(receiptPath) : resolve(input.cwd, receiptPath);
+  if (!isPathInsideDirectory(resolvedPath, evidenceRoot))
+    return false;
+  try {
+    return isNonEmptyFileInsideEvidenceRoot(resolvedPath, evidenceRoot, input.cwd, fs);
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function isPathInsideDirectory(filePath, directoryPath) {
+  const relativePath = relative(directoryPath, filePath);
+  return relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function isNonEmptyFileInsideEvidenceRoot(filePath, evidenceRoot, cwd, fs) {
+  if (!fs.existsSync(filePath))
+    return false;
+  const realCwd = realPath(cwd, fs);
+  const realEvidenceRoot = realPath(evidenceRoot, fs);
+  const realFilePath = realPath(filePath, fs);
+  if (!isPathInsideDirectory(realEvidenceRoot, realCwd))
+    return false;
+  if (!isPathInsideDirectory(realFilePath, realEvidenceRoot))
+    return false;
+  return isNonEmptyFile(filePath, fs);
+}
+function isNonEmptyFile(filePath, fs) {
+  if (!fs.existsSync(filePath))
+    return false;
+  const linkStat = fs.lstatSync?.(filePath) ?? nodeLstatSync(filePath);
+  if (linkStat.isSymbolicLink?.() === true)
+    return false;
+  const stat = fs.statSync(filePath);
+  if (stat.size <= 0)
+    return false;
+  return stat.isFile?.() ?? true;
+}
+function realPath(path, fs) {
+  return fs.realpathSync?.(path) ?? nodeRealpathSync(path);
+}
+function extractEvidencePath(message) {
+  if (message === undefined)
+    return null;
+  const match = /EVIDENCE_RECORDED:\s*(\S+)/.exec(message);
+  const receiptPath = match?.[1];
+  return receiptPath === undefined ? null : receiptPath;
+}
+function isSubagentStopInput(value) {
+  return isRecord2(value) && value["hook_event_name"] === SUBAGENT_STOP_EVENT && typeof value["agent_type"] === "string" && typeof value["agent_id"] === "string" && typeof value["session_id"] === "string" && typeof value["cwd"] === "string" && typeof value["transcript_path"] === "string" && typeof value["model"] === "string" && typeof value["permission_mode"] === "string" && typeof value["stop_hook_active"] === "boolean" && optionalString(value["turn_id"]) && optionalString(value["last_assistant_message"]);
+}
+function optionalString(value) {
+  return value === undefined || typeof value === "string";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// components/lazycodex-executor-verify/src/cli.ts
+var nodeFileSystem = {
+  existsSync,
+  mkdirSync,
+  readFileSync: readFileSync2,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+};
+var command = process.argv[2];
+var subcommand = process.argv[3];
+if (command === "hook" && subcommand === "subagent-stop") {
+  await runHookCli();
+} else {
+  process.stderr.write(`Usage: lazycodex-executor-verify hook subagent-stop
+`);
+  process.exitCode = 1;
+}
+async function runHookCli() {
+  const raw = await readStdin();
+  if (raw.trim().length === 0)
+    return;
+  const parsed = parseHookInput(raw);
+  const output = runSubagentStopHook(parsed, nodeFileSystem);
+  if (output.length > 0)
+    processStdout.write(output);
+}
+function parseHookInput(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      return;
+    throw error;
+  }
+}
+function readStdin() {
+  return new Promise((resolve2) => {
+    let data = "";
+    processStdin.setEncoding("utf8");
+    processStdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    processStdin.once("error", () => resolve2(data));
+    processStdin.once("end", () => resolve2(data));
+  });
+}

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/codex-hook.d.ts

@@ -0,0 +1,2 @@
+import type { HookFileSystem } from "./types.js";
+export declare function runSubagentStopHook(input: unknown, fs: HookFileSystem): string;

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/codex-hook.js

@@ -0,0 +1,123 @@
+import { lstatSync as nodeLstatSync, realpathSync as nodeRealpathSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+import { renderDirective } from "./directive.js";
+import { clearAttemptState, MAX_ATTEMPTS, readAttemptState, writeAttemptState } from "./state.js";
+import { SUBAGENT_STOP_EVENT } from "./types.js";
+const LAZYCODEX_EXECUTOR_AGENT = "lazycodex-executor";
+export function runSubagentStopHook(input, fs) {
+    if (!isSubagentStopInput(input))
+        return "";
+    if (input.agent_type !== LAZYCODEX_EXECUTOR_AGENT)
+        return "";
+    if (transcriptHasContextPressureMarker(input.transcript_path, fs))
+        return "";
+    if (hasValidEvidenceReceipt(input, fs)) {
+        clearAttemptState(input.cwd, input.session_id, input.agent_id, fs);
+        return "";
+    }
+    const state = readAttemptState(input.cwd, input.session_id, input.agent_id, fs);
+    if (state.attempts >= MAX_ATTEMPTS) {
+        clearAttemptState(input.cwd, input.session_id, input.agent_id, fs);
+        return "";
+    }
+    const attempts = state.attempts + 1;
+    writeAttemptState(input.cwd, input.session_id, input.agent_id, { attempts }, fs);
+    return JSON.stringify({
+        decision: "block",
+        reason: renderDirective(attempts, input.last_assistant_message),
+    });
+}
+const CONTEXT_PRESSURE_MARKERS = [
+    "context compacted",
+    "context_length_exceeded",
+    "skill descriptions were shortened",
+    "context_too_large",
+    "codex ran out of room in the model's context window",
+    "your input exceeds the context window",
+    "long threads and multiple compactions",
+];
+function transcriptHasContextPressureMarker(transcriptPath, fs) {
+    try {
+        const transcript = fs.readFileSync(transcriptPath, "utf8").toLowerCase();
+        return CONTEXT_PRESSURE_MARKERS.some((marker) => transcript.includes(marker));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}
+function hasValidEvidenceReceipt(input, fs) {
+    const receiptPath = extractEvidencePath(input.last_assistant_message);
+    if (receiptPath === null)
+        return false;
+    const evidenceRoot = resolve(input.cwd, ".omo", "evidence");
+    const resolvedPath = isAbsolute(receiptPath) ? resolve(receiptPath) : resolve(input.cwd, receiptPath);
+    if (!isPathInsideDirectory(resolvedPath, evidenceRoot))
+        return false;
+    try {
+        return isNonEmptyFileInsideEvidenceRoot(resolvedPath, evidenceRoot, input.cwd, fs);
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}
+function isPathInsideDirectory(filePath, directoryPath) {
+    const relativePath = relative(directoryPath, filePath);
+    return relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function isNonEmptyFileInsideEvidenceRoot(filePath, evidenceRoot, cwd, fs) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const realCwd = realPath(cwd, fs);
+    const realEvidenceRoot = realPath(evidenceRoot, fs);
+    const realFilePath = realPath(filePath, fs);
+    if (!isPathInsideDirectory(realEvidenceRoot, realCwd))
+        return false;
+    if (!isPathInsideDirectory(realFilePath, realEvidenceRoot))
+        return false;
+    return isNonEmptyFile(filePath, fs);
+}
+function isNonEmptyFile(filePath, fs) {
+    if (!fs.existsSync(filePath))
+        return false;
+    const linkStat = fs.lstatSync?.(filePath) ?? nodeLstatSync(filePath);
+    if (linkStat.isSymbolicLink?.() === true)
+        return false;
+    const stat = fs.statSync(filePath);
+    if (stat.size <= 0)
+        return false;
+    return stat.isFile?.() ?? true;
+}
+function realPath(path, fs) {
+    return fs.realpathSync?.(path) ?? nodeRealpathSync(path);
+}
+function extractEvidencePath(message) {
+    if (message === undefined)
+        return null;
+    const match = /EVIDENCE_RECORDED:\s*(\S+)/.exec(message);
+    const receiptPath = match?.[1];
+    return receiptPath === undefined ? null : receiptPath;
+}
+function isSubagentStopInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === SUBAGENT_STOP_EVENT &&
+        typeof value["agent_type"] === "string" &&
+        typeof value["agent_id"] === "string" &&
+        typeof value["session_id"] === "string" &&
+        typeof value["cwd"] === "string" &&
+        typeof value["transcript_path"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["stop_hook_active"] === "boolean" &&
+        optionalString(value["turn_id"]) &&
+        optionalString(value["last_assistant_message"]));
+}
+function optionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/directive.d.ts

@@ -0,0 +1,2 @@
+export declare const LAZYCODEX_EXECUTOR_VERIFY_DIRECTIVE: string;
+export declare function renderDirective(attempts: number, lastAssistantMessage: string | undefined): string;

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/directive.js

@@ -0,0 +1,5 @@
+import { readFileSync } from "node:fs";
+export const LAZYCODEX_EXECUTOR_VERIFY_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
+export function renderDirective(attempts, lastAssistantMessage) {
+    return LAZYCODEX_EXECUTOR_VERIFY_DIRECTIVE.replaceAll("{{ATTEMPT_COUNT}}", String(attempts)).replaceAll("{{LAST_ASSISTANT_MESSAGE}}", lastAssistantMessage ?? "(last_assistant_message was omitted)");
+}

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { runSubagentStopHook } from "./codex-hook.js";
+export { LAZYCODEX_EXECUTOR_VERIFY_DIRECTIVE, renderDirective } from "./directive.js";
+export { MAX_ATTEMPTS } from "./state.js";
+export type { HookFileSystem, StopHookOutput, SubagentStopInput } from "./types.js";

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/index.js

@@ -0,0 +1,3 @@
+export { runSubagentStopHook } from "./codex-hook.js";
+export { LAZYCODEX_EXECUTOR_VERIFY_DIRECTIVE, renderDirective } from "./directive.js";
+export { MAX_ATTEMPTS } from "./state.js";

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/state.d.ts

@@ -0,0 +1,9 @@
+import type { HookFileSystem } from "./types.js";
+export declare const MAX_ATTEMPTS = 3;
+export type AttemptState = {
+    readonly attempts: number;
+};
+export declare function readAttemptState(cwd: string, sessionId: string, agentId: string, fs: HookFileSystem): AttemptState;
+export declare function writeAttemptState(cwd: string, sessionId: string, agentId: string, state: AttemptState, fs: HookFileSystem): void;
+export declare function clearAttemptState(cwd: string, sessionId: string, agentId: string, fs: HookFileSystem): void;
+export declare function getStatePath(cwd: string, sessionId: string, agentId: string): string;

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/state.js

@@ -0,0 +1,45 @@
+import { join } from "node:path";
+export const MAX_ATTEMPTS = 3;
+export function readAttemptState(cwd, sessionId, agentId, fs) {
+    const statePath = getStatePath(cwd, sessionId, agentId);
+    if (!fs.existsSync(statePath))
+        return { attempts: 0 };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(statePath, "utf8"));
+        if (isAttemptState(parsed))
+            return parsed;
+        return { attempts: 0 };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || error instanceof Error)
+            return { attempts: 0 };
+        throw error;
+    }
+}
+export function writeAttemptState(cwd, sessionId, agentId, state, fs) {
+    const stateDir = getStateDir(cwd);
+    const statePath = getStatePath(cwd, sessionId, agentId);
+    const tempPath = `${statePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.mkdirSync(stateDir, { recursive: true });
+    fs.writeFileSync(tempPath, `${JSON.stringify(state)}\n`);
+    fs.renameSync(tempPath, statePath);
+}
+export function clearAttemptState(cwd, sessionId, agentId, fs) {
+    fs.rmSync(getStatePath(cwd, sessionId, agentId), { force: true });
+}
+export function getStatePath(cwd, sessionId, agentId) {
+    return join(getStateDir(cwd), `${sanitizeKey(sessionId)}-${sanitizeKey(agentId)}.json`);
+}
+function getStateDir(cwd) {
+    return join(cwd, ".omo", "lazycodex-executor-verify");
+}
+function sanitizeKey(value) {
+    const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+    return sanitized.length > 0 ? sanitized : "missing";
+}
+function isAttemptState(value) {
+    return isRecord(value) && typeof value["attempts"] === "number" && Number.isInteger(value["attempts"]);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/types.d.ts

@@ -0,0 +1,39 @@
+export declare const SUBAGENT_STOP_EVENT = "SubagentStop";
+export type SubagentStopInput = {
+    readonly hook_event_name: typeof SUBAGENT_STOP_EVENT;
+    readonly agent_type: string;
+    readonly agent_id: string;
+    readonly session_id: string;
+    readonly cwd: string;
+    readonly transcript_path: string;
+    readonly model: string;
+    readonly permission_mode: string;
+    readonly stop_hook_active: boolean;
+    readonly turn_id?: string;
+    readonly last_assistant_message?: string;
+};
+export type StopHookOutput = {
+    readonly decision: "block";
+    readonly reason: string;
+};
+export type FileStat = {
+    readonly size: number;
+    readonly isFile?: () => boolean;
+    readonly isSymbolicLink?: () => boolean;
+};
+export type HookFileSystem = {
+    existsSync(path: string): boolean;
+    lstatSync?(path: string): FileStat;
+    mkdirSync(path: string, options: {
+        readonly recursive: true;
+    }): unknown;
+    readFileSync(path: string, encoding: "utf8"): string;
+    realpathSync?(path: string): string;
+    renameSync(oldPath: string, newPath: string): void;
+    rmSync(path: string, options: {
+        readonly force: true;
+        readonly recursive?: boolean;
+    }): void;
+    statSync(path: string): FileStat;
+    writeFileSync(path: string, data: string): void;
+};

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/dist/types.js

@@ -0,0 +1 @@
+export const SUBAGENT_STOP_EVENT = "SubagentStop";

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

@@ -0,0 +1,17 @@
+{
+	"hooks": {
+		"SubagentStop": [
+			{
+				"matcher": "^lazycodex-executor$",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/components/lazycodex-executor-verify/dist/cli.js\" hook subagent-stop",
+						"timeout": 10,
+						"statusMessage": "LazyCodex(4.11.0): Verifying LazyCodex Executor Evidence"
+					}
+				]
+			}
+		]
+	}
+}

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

@@ -0,0 +1,44 @@
+{
+	"name": "@code-yeongyu/codex-lazycodex-executor-verify",
+	"version": "4.11.0",
+	"description": "Codex SubagentStop evidence verifier for LazyCodex executor completions.",
+	"type": "module",
+	"packageManager": "npm@11.12.1",
+	"license": "MIT",
+	"keywords": [
+		"codex",
+		"codex-plugin",
+		"lazycodex",
+		"hooks",
+		"evidence"
+	],
+	"bin": {
+		"lazycodex-executor-verify": "./dist/cli.js"
+	},
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"test": "npm run build --silent && vitest --run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"check": "tsc --noEmit && biome check . && npm run build"
+	},
+	"files": [
+		"dist",
+		"directive.md",
+		"hooks",
+		"README.md",
+		"LICENSE",
+		"NOTICE"
+	],
+	"devDependencies": {
+		"@biomejs/biome": "2.4.16",
+		"@types/node": "^25.9.3",
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.8"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/src/cli.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+
+import { runSubagentStopHook } from "./codex-hook.js";
+import type { HookFileSystem } from "./types.js";
+
+const nodeFileSystem: HookFileSystem = {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	renameSync,
+	rmSync,
+	statSync,
+	writeFileSync,
+};
+
+const command = process.argv[2];
+const subcommand = process.argv[3];
+
+if (command === "hook" && subcommand === "subagent-stop") {
+	await runHookCli();
+} else {
+	process.stderr.write("Usage: lazycodex-executor-verify hook subagent-stop\n");
+	process.exitCode = 1;
+}
+
+async function runHookCli(): Promise<void> {
+	const raw = await readStdin();
+	if (raw.trim().length === 0) return;
+	const parsed = parseHookInput(raw);
+	const output = runSubagentStopHook(parsed, nodeFileSystem);
+	if (output.length > 0) processStdout.write(output);
+}
+
+function parseHookInput(raw: string): unknown | undefined {
+	try {
+		const parsed: unknown = JSON.parse(raw);
+		return parsed;
+	} catch (error) {
+		if (error instanceof SyntaxError) return undefined;
+		throw error;
+	}
+}
+
+function readStdin(): Promise<string> {
+	return new Promise((resolve) => {
+		let data = "";
+		processStdin.setEncoding("utf8");
+		processStdin.on("data", (chunk: string) => {
+			data += chunk;
+		});
+		processStdin.once("error", () => resolve(data));
+		processStdin.once("end", () => resolve(data));
+	});
+}