oh-my-opencode 4.18.1 → 4.18.2

package/packages/omo-codex/plugin/components/lsp/dist/cli.js

@@ -13,13 +13,13 @@ import { homedir as homedir3 } from "node:os";
 import { join as join11, resolve as resolve11 } from "node:path";
 
 // ../../../../lsp-daemon/dist/client.js
-import { connect as connect2 } from "node:net";
+import { connect } from "node:net";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync, realpathSync, statSync } from "node:fs";
 import { basename, delimiter, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2 } from "node:fs";
-import { connect } from "node:net";
+import { Socket } from "node:net";
 import { dirname as dirname3 } from "node:path";
 import { execPath } from "node:process";
 import {
@@ -426,42 +426,48 @@ class DaemonUnreachableError extends Error {
 async function ensureDaemonRunning(paths, deps = defaultEnsureDaemonDeps(), options = {}) {
   const readyTimeoutMs = options.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  if (await deps.probe(paths))
+  const signal = options.signal;
+  throwIfAborted(signal);
+  if (await awaitWithSignal(deps.probe(paths, signal), signal))
     return;
+  throwIfAborted(signal);
   deps.spawnDaemon(paths);
-  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs);
+  await waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal);
 }
-async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs) {
+async function waitUntilReachable(paths, deps, readyTimeoutMs, pollIntervalMs, signal) {
   const deadline = deps.now() + readyTimeoutMs;
   for (;; ) {
-    if (await deps.probe(paths))
+    throwIfAborted(signal);
+    if (await awaitWithSignal(deps.probe(paths, signal), signal))
       return;
     if (deps.now() >= deadline)
       throw new DaemonUnreachableError(paths.socket);
-    await deps.sleep(pollIntervalMs);
+    await awaitWithSignal(deps.sleep(pollIntervalMs, signal), signal);
   }
 }
-async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS) {
+async function probeDaemon(paths, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   const token = readAuthToken(paths);
   if (!token)
     return false;
-  return await pingDaemon(paths, token, timeoutMs) !== null;
+  return await pingDaemon(paths, token, timeoutMs, signal) !== null;
 }
-function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
+function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS, signal) {
   return new Promise((resolve22) => {
-    const socket = connect(paths.socket);
+    const socket = new Socket;
     let settled = false;
+    let timer;
     const finish = (value) => {
       if (settled)
         return;
       settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
       socket.destroy();
       resolve22(value);
     };
-    const timer = setTimeout(() => finish(null), timeoutMs);
-    timer.unref?.();
+    const onAbort = () => finish(null);
     const decoder = createLineDecoder((message) => {
-      clearTimeout(timer);
       finish(parsePingResponse(message));
     });
     socket.once("connect", () => {
@@ -469,9 +475,16 @@ function pingDaemon(paths, token, timeoutMs = PROBE_TIMEOUT_MS) {
     });
     socket.on("data", (chunk) => decoder.push(chunk));
     socket.once("error", () => {
-      clearTimeout(timer);
       finish(null);
     });
+    timer = setTimeout(() => finish(null), timeoutMs);
+    timer.unref?.();
+    if (signal?.aborted) {
+      onAbort();
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    socket.connect(paths.socket);
   });
 }
 function spawnDaemonProcess(paths) {
@@ -489,14 +502,62 @@ function spawnDaemonProcess(paths) {
 }
 function defaultEnsureDaemonDeps() {
   return {
-    probe: (paths) => probeDaemon(paths),
+    probe: (paths, signal) => probeDaemon(paths, PROBE_TIMEOUT_MS, signal),
     spawnDaemon: (paths) => spawnDaemonProcess(paths),
-    sleep: (ms) => new Promise((resolve22) => {
-      setTimeout(resolve22, ms);
-    }),
+    sleep: (ms, signal) => sleepWithSignal(ms, signal),
     now: () => Date.now()
   };
 }
+function sleepWithSignal(ms, signal) {
+  return new Promise((resolve22) => {
+    let settled = false;
+    const finish = () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", finish);
+      resolve22();
+    };
+    const timer = setTimeout(finish, ms);
+    if (signal?.aborted) {
+      finish();
+      return;
+    }
+    signal?.addEventListener("abort", finish, { once: true });
+  });
+}
+function awaitWithSignal(promise, signal) {
+  if (!signal)
+    return promise;
+  if (signal.aborted)
+    return Promise.reject(abortError(signal));
+  return new Promise((resolve22, reject) => {
+    let settled = false;
+    const finish = (run) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      run();
+    };
+    const onAbort = () => finish(() => reject(abortError(signal)));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then((value) => finish(() => resolve22(value)), (error) => finish(() => reject(error)));
+  });
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw abortError(signal);
+}
+function abortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error)
+    return reason;
+  const error = new Error(typeof reason === "string" ? reason : "daemon startup cancelled");
+  error.name = "AbortError";
+  return error;
+}
 function parsePingResponse(message) {
   if (!message || typeof message !== "object" || Array.isArray(message))
     return null;
@@ -692,7 +753,7 @@ class JsonRpcConnection {
         settled = true;
         this.pendingRequests.delete(key);
         cleanup();
-        const rejectCancelled = () => reject(abortError(options.signal));
+        const rejectCancelled = () => reject(abortError2(options.signal));
         if (!requestWritten) {
           cancelAfterWrite = true;
           rejectCancelled();
@@ -896,7 +957,7 @@ ${body}`;
     }
   }
 }
-function abortError(signal) {
+function abortError2(signal) {
   const reason = signal?.reason;
   if (reason instanceof Error)
     return reason;
@@ -3118,11 +3179,11 @@ function waitForDiagnosticsActivity(wait, signal) {
   if (!signal)
     return wait;
   if (signal.aborted)
-    return Promise.reject(abortError2(signal));
+    return Promise.reject(abortError3(signal));
   return new Promise((resolve72, reject) => {
     const onAbort = () => {
       signal.removeEventListener("abort", onAbort);
-      reject(abortError2(signal));
+      reject(abortError3(signal));
     };
     signal.addEventListener("abort", onAbort, { once: true });
     wait.then(() => {
@@ -3157,7 +3218,7 @@ function preCommitAbortReason(source) {
     return reason;
   return new Error("LSP request cancelled before workspace edit commit");
 }
-function abortError2(signal) {
+function abortError3(signal) {
   const reason = signal.reason;
   if (reason instanceof Error)
     return reason;
@@ -3188,7 +3249,7 @@ async function stopClientBestEffort(client) {
     reportBestEffortCleanupError("client stop", error);
   }
 }
-function awaitWithSignal(promise, signal) {
+function awaitWithSignal2(promise, signal) {
   if (!signal)
     return promise;
   return new Promise((resolve72, reject) => {
@@ -3291,7 +3352,7 @@ class LspManager {
       if (managed.initPromise) {
         managed.pendingWaiters++;
         try {
-          await awaitWithSignal(managed.initPromise, signal);
+          await awaitWithSignal2(managed.initPromise, signal);
         } catch (err) {
           managed.pendingWaiters--;
           await this.tryDeleteIfOrphaned(key, managed);
@@ -3329,7 +3390,7 @@ class LspManager {
     };
     this.clients.set(key, newManaged);
     try {
-      await awaitWithSignal(initPromise, signal);
+      await awaitWithSignal2(initPromise, signal);
     } catch (err) {
       newManaged.pendingWaiters--;
       if (this.clients.get(key) === newManaged) {
@@ -4280,7 +4341,7 @@ async function aggregateDiagnosticsForDirectory(directory, extension, severity,
   const fileErrors = [];
   const maxConcurrency = Math.max(1, options.maxConcurrency ?? DIRECTORY_DIAGNOSTICS_MAX_CONCURRENCY);
   options.signal?.throwIfAborted();
-  const client = await manager.getClient(root, server2);
+  const client = await manager.getClient(root, server2, options.signal);
   try {
     let nextIndex = 0;
     const workers = Array.from({ length: Math.min(maxConcurrency, filesToProcess.length) }, async () => {
@@ -4960,14 +5021,14 @@ class DaemonRequestCancelledError extends DaemonRequestError {
 async function callToolViaDaemon(name, args, options) {
   const context = requireContext(options.context);
   const paths = options.paths ?? daemonPaths();
-  const ensure = options.ensure ?? ensureDaemonRunning;
+  const ensure = options.ensure ?? ((ensurePaths, signal) => ensureDaemonRunning(ensurePaths, undefined, signal === undefined ? {} : { signal }));
   const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
   const requestArgs = withContext(args, context);
   let lastError;
   let authRefreshUsed = false;
   for (let attempt = 0;attempt < 3; attempt += 1) {
     try {
-      await ensure(paths);
+      await ensureDaemonAvailable(paths, ensure, options.signal);
       const token = readAuthToken(paths);
       if (!token)
         throw new DaemonRequestError("daemon auth token missing", false);
@@ -4998,6 +5059,27 @@ function requireContext(context) {
 function withContext(args, context) {
   return { ...args, [CONTEXT_KEY]: context };
 }
+function ensureDaemonAvailable(paths, ensure, signal) {
+  if (!signal)
+    return ensure(paths);
+  return new Promise((resolve9, reject) => {
+    let settled = false;
+    const finish = (run) => {
+      if (settled)
+        return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      run();
+    };
+    const onAbort = () => finish(() => reject(new DaemonRequestCancelledError(false)));
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve().then(() => ensure(paths, signal)).then(() => finish(() => resolve9()), (error) => finish(() => reject(signal.aborted ? new DaemonRequestCancelledError(false) : error)));
+  });
+}
 function daemonUnreachableResult(paths, error) {
   const text2 = [
     `LSP daemon unreachable: ${errorText(error)}.`,
@@ -5011,7 +5093,7 @@ function daemonUnreachableResult(paths, error) {
 }
 function sendToolCall(paths, token, name, args, options) {
   return new Promise((resolve9, reject) => {
-    const socket = connect2(paths.socket);
+    const socket = connect(paths.socket);
     const requestId = allocateProxyRequestId();
     let settled = false;
     let requestWritten = false;

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

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "(OmO 4.18.1) Checking LSP Diagnostics"
+						"statusMessage": "(OmO 4.18.2) Checking LSP Diagnostics"
 					}
 				]
 			}
@@ -21,7 +21,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.1) Resetting LSP Diagnostics Cache"
+						"statusMessage": "(OmO 4.18.2) Resetting LSP Diagnostics Cache"
 					}
 				]
 			}

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

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

package/packages/omo-codex/plugin/components/lsp/test/package-smoke.test.ts

@@ -44,6 +44,7 @@ describe("plugin package metadata", () => {
 		expect(postCompactCommand).toBe(`node "${pluginRoot}/dist/cli.js" hook post-compact`);
 		expect(lspServer?.command).toBe("node");
 		expect(lspServer?.args).toEqual(["../../../../lsp-daemon/dist/cli.js", "mcp"]);
+		expect(lspServer?.startup_timeout_sec).toBe(10);
 		expect(cliSource).not.toContain("./lazy-lsp-mcp.js");
 		expect(cliSource).toContain("resolveLspDaemonCliPath");
 		expect(daemonCliPathSource).toContain("@code-yeongyu/lsp-daemon/cli");

package/packages/omo-codex/plugin/components/rules/bundled-rules/hephaestus/gpt-5.5.md

@@ -74,7 +74,7 @@ Diagnostics catch type errors, not logic bugs; tests cover only what their autho
 
 # Global Review and Debugging Gate
 
-Run `review-work` plus a `debugging` runtime audit only before a PR handoff or when the user asks for a review; lane pass/fail semantics live in those skills. A passing review lane binds to the exact commit SHA it reviewed: NEVER re-run a lane at a SHA where that same lane already passed this task; every lane that has not passed at the current SHA still runs. For everything else, the gate above is the whole gate: once you have personally observed the artifact working, report your evidence. Redact secrets, tokens, and PII from ledgers, PR bodies, and handoffs.
+Run `review-work` plus a `debugging` runtime audit only before a PR handoff or when the user asks for a review; lane pass/fail semantics live in those skills. Each passing review lane and debugging audit binds to the exact full commit SHA it reviewed. Immediately append a durable task-evidence/ledger record with its name, full SHA, verdict, and report artifact/source. Before reuse after continuation or compaction, re-read the record and require the exact lane/SHA pair; memory or an unstamped report is not coverage. Every missing pair at the current SHA still runs, and new commits require fresh applicable coverage. For everything else, the gate above is the whole gate: once you have personally observed the artifact working, report your evidence. Redact secrets, tokens, and PII from ledgers, PR bodies, and handoffs.
 
 # Failure Recovery
 

package/packages/omo-codex/plugin/components/rules/bundled-rules/hephaestus/gpt-5.6.md

@@ -19,13 +19,15 @@ Status requests are not stop signals: give the update, keep working. Honor every
 
 # Discovery
 
-Never speculate about code you have not read: verify with tools and re-read on every hand-off. Start broad once - and WIDE: tool calls run as JavaScript through `exec`, so write programs, not single calls. Batch EVERY independent read, search, and doc lookup into ONE `exec` script via `Promise.all` over the `tools` object before the first edit; filter and reduce results in-script so only what you need returns to context. NEVER await independent calls one at a time - sequence only when one result feeds the next. Retrieve again only when the core question is open, a needed fact is missing, or a second-order question (callers, error paths, ownership) changes the design. Stop when you can act. Prefer the root fix over the symptom fix.
+Never speculate about code you have not read: verify with tools and re-read on every hand-off. **USE CODE MODE AGGRESSIVELY FOR BOUNDED DISCOVERY.** When multiple independent tool calls produce results that can be materially filtered, joined, deduplicated, or reduced, make ONE `exec` / eval JavaScript program that calls eligible tools concurrently with `Promise.all` and returns only decision-relevant evidence. For shell-native repo work without programmatic tool access, use ONE Python script with `concurrent.futures`, `subprocess`, and utility functions to batch commands and reduce output. **USE LSP FOR SYMBOLS** - definitions, references, rename impact, workspace symbols, and diagnostics - instead of reconstructing semantics with text search. Use direct calls when one result chooses the next action, outputs are already small, semantic judgment is required between calls, approval or side effects are involved, or native artifacts must be preserved. Retrieve again only for a missing required fact or a second-order question that changes the design. Stop when you can act; prefer the root fix over the symptom.
 
 # Operating Loop
 
 Explore -> Plan (`update_plan`, per Task Tracking) -> Implement -> Verify -> Manually QA.
 
-Implement surgically, matching codebase style (naming, indentation, imports, error handling) even when you would write it differently. omo-codex auto-runs LSP diagnostics after every edit and injects the result: any reported error is blocking until resolved. Verify with targeted tests and builds for changed behavior; if validation cannot run, say why and name the next best check.
+Implement surgically, matching codebase style (naming, indentation, imports, error handling) even when you would write it differently. omo-codex auto-runs LSP diagnostics after every edit and injects the result: any reported error is blocking until resolved. Verify with targeted tests and builds for changed behavior; if validation cannot run, say why and name the next best check. Re-run a validation command only when its inputs changed since its last green run; one full pass right before the final message replaces repeated identical reruns.
+
+Waiting is not free: a status poll replays the whole accumulated context through the model. Run a long command (install, build, suite, container, CI watch) to completion in ONE `exec` call with a timeout sized to the expected wait - or send output to a log file read once on a completion signal - never re-poll the same surface with empty reads or sub-minute waits. If two consecutive checks show no state change, double the wait or switch to a completion signal.
 
 # Subagents
 
@@ -52,7 +54,7 @@ Diagnostics catch type errors, not logic bugs; tests cover only what their autho
 
 "This should work" from reading source does not pass. A defect found in usage is yours to fix this turn.
 
-Run `review-work` plus a `debugging` runtime audit only before a PR handoff or when the user asks for a review; lane pass/fail semantics live in those skills. A passing review lane binds to the exact commit SHA it reviewed: NEVER re-run a lane at a SHA where that same lane already passed this task; every lane that has not passed at the current SHA still runs. For everything else, the gate above is the whole gate: once you have personally observed the artifact working, report your evidence. Redact secrets, tokens, and PII from ledgers, PR bodies, and handoffs.
+Run `review-work` plus a `debugging` runtime audit only before a PR handoff or when the user asks for a review; lane pass/fail semantics live in those skills. Each passing review lane and debugging audit binds to the exact full commit SHA it reviewed. Immediately append a durable task-evidence/ledger record with its name, full SHA, verdict, and report artifact/source. Before reuse after continuation or compaction, re-read the record and require the exact lane/SHA pair; memory or an unstamped report is not coverage. Every missing pair at the current SHA still runs, and new commits require fresh applicable coverage. For everything else, the gate above is the whole gate: once you have personally observed the artifact working, report your evidence. Redact secrets, tokens, and PII from ledgers, PR bodies, and handoffs.
 
 # Failure Recovery
 

package/packages/omo-codex/plugin/components/rules/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.1) Loading Project Rules"
+						"statusMessage": "(OmO 4.18.2) Loading Project Rules"
 					}
 				]
 			}
@@ -19,7 +19,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook user-prompt-submit",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.1) Loading Project Rules"
+						"statusMessage": "(OmO 4.18.2) Loading Project Rules"
 					}
 				]
 			}
@@ -32,7 +32,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.1) Matching Project Rules"
+						"statusMessage": "(OmO 4.18.2) Matching Project Rules"
 					}
 				]
 			}
@@ -45,7 +45,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.1) Resetting Project Rule Cache"
+						"statusMessage": "(OmO 4.18.2) Resetting Project Rule Cache"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-rules",
-	"version": "4.18.1",
+	"version": "4.18.2",
 	"description": "Codex plugin that injects project rule files into model context through lifecycle hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/start-work-continuation/README.md

@@ -2,13 +2,13 @@
 
 Codex Stop-hook continuation injector for the omo-codex `start-work` skill.
 
-It reads `.omo/boulder.json` in the hook payload `cwd`, resolves the active work, inspects the active plan for incomplete top-level checkboxes, and emits Codex Stop-hook JSON when the plan still has work:
+It reads `.omo/boulder.json` in the hook payload `cwd`, resolves the active work, inspects the active plan's top-level checklist, and emits Codex Stop-hook JSON while the plan still has unchecked tasks or its final review/debugging gate remains pending:
 
 ```json
 {"decision":"block","reason":"<directive>"}
 ```
 
-The `reason` is loaded from `directive.md` on every invocation and filled with current plan state. The hook returns no output when `stop_hook_active` is `true`, when no active Boulder work exists, when the work is completed, when the active work is not tied to `codex:<session_id>`, or when all top-level plan checkboxes are complete.
+The `reason` is loaded from `directive.md` on every invocation and filled with current plan state. The hook returns no output when `stop_hook_active` is `true`, when no active Boulder work exists, when the work is completed, when the active work is not tied to `codex:<session_id>`, or when the plan has no readable top-level checklist. An active plan whose checklist is fully checked still blocks Stop until the final gate runs and Boulder is marked completed.
 
 This pairs with the `start-work` skill at `plugin/skills/start-work/SKILL.md`. That skill writes `.omo/boulder.json` with Codex session ids prefixed as `codex:` so the hook can continue only its own active Codex session.
 

package/packages/omo-codex/plugin/components/start-work-continuation/directive.md

@@ -16,7 +16,7 @@ You are mid-flight on a Prometheus work plan; this turn is an automatic continua
 # What to do this turn
 
 1. Read `{{PLAN_PATH}}` AND `{{LEDGER_PATH}}` first — they are the only sources of truth for what remains and what evidence exists; do not trust your memory of prior turns.
-2. Pick the FIRST unchecked top-level checkbox in `## TODOs` or `## Final Verification Wave`. Ignore nested checkboxes under Acceptance Criteria / Evidence / Definition of Done.
+2. When the remaining count is `0`, skip checkbox execution and perform the Final gate now. Otherwise, pick the FIRST unchecked top-level checkbox in `## TODOs` or `## Final Verification Wave`. Ignore nested checkboxes under Acceptance Criteria / Evidence / Definition of Done.
 3. Follow the `start-work` skill in full. The skill is already loaded from your earlier turn — re-read its file at `packages/omo-codex/plugin/skills/start-work/SKILL.md` if you have lost context.
 4. Apply the checkbox's tier from its ledger entry, or classify it now per the start-work skill: LIGHT (default — a narrow change inside existing layers) needs one real-surface proof of the deliverable, with auxiliary surfaces first-class for CLI- or data-shaped work, and only trigger-mapped adversarial classes; HEAVY (new module/abstraction, auth/security, external integration, schema/migration, concurrency, cross-domain refactor, care signals) takes the full per-criterion regime. When unsure, take HEAVY; never downgrade.
 5. Decompose the checkbox into atomic sub-tasks. Dispatch them in PARALLEL via `multi_agent_v1.spawn_agent` calls in this same response unless a sub-task has a NAMED blocking dependency (input from another sub-task or shared file). Use `fork_context: false` unless full history is truly required. Put role and specialty instructions inside `message`. Flat `spawn_agent` requiring `task_name` instead (`multi_agent_v2`)? Add `"task_name"`, use `fork_turns: "none"`, `wait_agent` takes only `timeout_ms`, finished agents end on their own.
@@ -40,7 +40,7 @@ You are mid-flight on a Prometheus work plan; this turn is an automatic continua
 
 # Final gate
 
-Before completion, run `review-work` and a `debugging` runtime audit; inconclusive lanes fail. The gate's pass binds to the commit SHA it reviewed — never re-run it on an already-passed SHA; re-run only when new commits land. Do not create a PR, PR handoff, branch handoff, merge, or final completion answer until this gate passes. For PR/branch work, stay in the task-owned worktree: create/update the PR, wait for CI/review/Cubic gates, merge by default unless explicitly opted out, then clean up. Redact secrets, tokens, credentials, auth headers, cookies, env dumps, logs, and PII.
+Before completion, satisfy all five `review-work` lanes and a `debugging` runtime audit; inconclusive lanes or an inconclusive audit fail. Each pass binds to the exact full commit SHA it reviewed. Immediately append a durable task-evidence record to `{{LEDGER_PATH}}` for every passing lane and the debugging audit with its name, full SHA, verdict, and report artifact/source. Before same-SHA reuse after any continuation or compaction, re-read the ledger record and verify the exact lane/SHA pair; memory, chat history, or an unstamped report is not coverage. New commits require fresh applicable coverage. Do not create a PR, PR handoff, branch handoff, merge, or final completion answer until this gate passes. For PR/branch work, stay in the task-owned worktree: create/update the PR, wait for CI/review/Cubic gates, merge by default unless explicitly opted out, then clean up. After the gate and lifecycle pass, mark the Boulder work completed before the final answer. Redact secrets, tokens, credentials, auth headers, cookies, env dumps, logs, and PII.
 
 # Stop conditions for THIS turn
 
@@ -54,6 +54,6 @@ Before completion, run `review-work` and a `debugging` runtime audit; inconclusi
 - Surface only state changes: sub-agent dispatched, scenario PASS/FAIL with artifact path, checkbox marked, evidence appended.
 - Do NOT print "Should I continue?", restate the plan, or recap prior turns — the Stop hook continues you; the ledger and plan are the durable record.
 
-Begin now. Pick the next checkbox, dispatch the parallel sub-agents, verify, mark, continue.
+Begin now. If no checkbox remains, run the Final gate; otherwise pick the next checkbox, dispatch the parallel sub-agents, verify, mark, continue.
 
 </start-work-continuation>

package/packages/omo-codex/plugin/components/start-work-continuation/dist/cli.js

@@ -21,7 +21,7 @@ function readContinuationState(cwd, sessionId) {
     return null;
   const planPath = resolveBoulderPlanPathForWork(cwd, work);
   const checklist = getPlanChecklist(planPath);
-  if (checklist.remaining === 0)
+  if (checklist.total === 0)
     return null;
   return {
     planName: work.planName,
@@ -239,7 +239,7 @@ function renderDirective(state, sessionId) {
     BOULDER_PATH: state.boulderPath,
     REMAINING_COUNT: String(state.checklist.remaining),
     TOTAL_COUNT: String(state.checklist.total),
-    NEXT_TASK_LABEL: state.checklist.nextTaskLabel ?? "",
+    NEXT_TASK_LABEL: state.checklist.nextTaskLabel ?? "none (final gate pending)",
     WORKTREE_BLOCK: worktreeBlock,
     LEDGER_PATH: state.ledgerPath,
     SESSION_ID: sessionId

package/packages/omo-codex/plugin/components/start-work-continuation/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/start-work-continuation/dist/cli.js\" hook stop",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.1) Checking Start-Work Continuation"
+						"statusMessage": "(OmO 4.18.2) Checking Start-Work Continuation"
 					}
 				]
 			}
@@ -19,7 +19,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/start-work-continuation/dist/cli.js\" hook subagent-stop",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.1) Checking Start-Work Continuation"
+						"statusMessage": "(OmO 4.18.2) Checking Start-Work Continuation"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/start-work-continuation/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-start-work-continuation",
-	"version": "4.18.1",
+	"version": "4.18.2",
 	"description": "Codex Stop hook continuation injector for omo-codex start-work plans.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/start-work-continuation/src/boulder-reader.ts

@@ -50,7 +50,7 @@ export function readContinuationState(cwd: string, sessionId: string): Continuat
 
 	const planPath = resolveBoulderPlanPathForWork(cwd, work);
 	const checklist = getPlanChecklist(planPath);
-	if (checklist.remaining === 0) return null;
+	if (checklist.total === 0) return null;
 
 	return {
 		planName: work.planName,

package/packages/omo-codex/plugin/components/start-work-continuation/src/codex-hook.ts

@@ -27,7 +27,7 @@ function renderDirective(state: ContinuationState, sessionId: string): string {
 		BOULDER_PATH: state.boulderPath,
 		REMAINING_COUNT: String(state.checklist.remaining),
 		TOTAL_COUNT: String(state.checklist.total),
-		NEXT_TASK_LABEL: state.checklist.nextTaskLabel ?? "",
+		NEXT_TASK_LABEL: state.checklist.nextTaskLabel ?? "none (final gate pending)",
 		WORKTREE_BLOCK: worktreeBlock,
 		LEDGER_PATH: state.ledgerPath,
 		SESSION_ID: sessionId,

package/packages/omo-codex/plugin/components/start-work-continuation/test/boulder-reader.test.ts

@@ -123,7 +123,7 @@ describe("start-work boulder state reader", () => {
 		expect(state?.checklist).toEqual({ completed: 0, remaining: 1, total: 1, nextTaskLabel: "First" });
 	});
 
-	it("#given no remaining top-level checklist items #when state is read #then continuation is absent", () => {
+	it("#given active codex work with no remaining checklist items #when state is read #then final gate continuation remains present", () => {
 		// given
 		const workspace = createWorkspace({
 			boulderJson: createBoulderJson({ status: "active", sessionIds: ["codex:sess_abc"] }),
@@ -133,6 +133,20 @@ describe("start-work boulder state reader", () => {
 		// when
 		const state = readContinuationState(workspace, "sess_abc");
 
+		// then
+		expect(state?.checklist).toEqual({ completed: 1, remaining: 0, total: 1, nextTaskLabel: null });
+	});
+
+	it("#given active codex work with no readable checklist #when state is read #then continuation remains absent", () => {
+		// given
+		const workspace = createWorkspace({
+			boulderJson: createBoulderJson({ status: "active", sessionIds: ["codex:sess_abc"] }),
+			planMarkdown: "# Plan\n\nNo checklist yet.\n",
+		});
+
+		// when
+		const state = readContinuationState(workspace, "sess_abc");
+
 		// then
 		expect(state).toBeNull();
 	});

package/packages/omo-codex/plugin/components/start-work-continuation/test/codex-hook.test.ts

@@ -69,6 +69,26 @@ describe("start-work Stop hook", () => {
 		expect(parsed.reason).toContain("- Your session id in boulder.json: `codex:sess_abc`");
 	});
 
+	it("#given active codex work with zero remaining tasks #when hook runs #then blocks for the final gate", () => {
+		// given
+		const workspace = createWorkspace({
+			boulderJson: createBoulderJson({ sessionIds: ["codex:sess_abc"], status: "active" }),
+			planMarkdown: ["# Plan", "", "## TODOs", "- [x] Done"].join("\n"),
+		});
+		const fs = createMemoryFs();
+
+		// when
+		const output = runStopHook(createStopInput(workspace), fs);
+
+		// then
+		const parsed = parseBlockOutput(output);
+		expect(parsed.decision).toBe("block");
+		expect(parsed.reason).toContain("- Remaining top-level checkboxes: `0` of `1`");
+		expect(parsed.reason).toContain("- Next incomplete task: `none (final gate pending)`");
+		expect(parsed.reason).toContain("When the remaining count is `0`, skip checkbox execution");
+		expect(parsed.reason).toContain("re-read the ledger record and verify the exact lane/SHA pair");
+	});
+
 	it("#given context-window pressure in transcript #when hook runs #then it does not inject continuation text", () => {
 		// given
 		const transcriptPath = "/repo/transcript.jsonl";

package/packages/omo-codex/plugin/components/teammode/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.1) Checking Thread Title Hygiene"
+						"statusMessage": "(OmO 4.18.2) Checking Thread Title Hygiene"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-teammode",
-	"version": "4.18.1",
+	"version": "4.18.2",
 	"description": "Codex team-mode hook component that keeps background thread titles descriptive after create_thread.",
 	"type": "module",
 	"private": true,

package/packages/omo-codex/plugin/components/telemetry/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.1) Recording Session Telemetry"
+						"statusMessage": "(OmO 4.18.2) Recording Session Telemetry"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-telemetry",
-	"version": "4.18.1",
+	"version": "4.18.2",
 	"description": "Codex plugin component that emits omo-codex anonymous daily-active telemetry on SessionStart.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",