lazycodex-ai 5.0.0-beta.7 → 5.0.0-beta.71

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/README.md

@@ -1,6 +1,6 @@
-# codex-start-work-continuation
+# codex-ulw-execute-continuation
 
-Codex Stop-hook continuation injector for the omo-codex `start-work` skill.
+Codex Stop-hook continuation injector for the omo-codex `ulw-execute` skill.
 
 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:
 
@@ -8,13 +8,13 @@ It reads `.omo/boulder.json` in the hook payload `cwd`, resolves the active work
 {"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 `last_assistant_message` starts with `<start-work-blocked-external>` (or places it immediately after the mandatory `ULTRAWORK MODE ENABLED!` opener), 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.
+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 `last_assistant_message` starts with `<ulw-execute-blocked-external>` (or places it immediately after the mandatory `ULTRAWORK MODE ENABLED!` opener), 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. SubagentStop is deliberately de-wired: the compatibility CLI subcommand returns no output and never injects a root plan.
 
 ## External blocker escape hatch
 
-A plan can stall on something no amount of retrying fixes: a missing credential, missing hardware, a revoked authorization, an unavailable third-party service. `directive.md` instructs the agent to write `<start-work-blocked-external>` as the entire first line of its answer in that case, or as the entire second line when ultrawork's mandatory opener occupies the first. The hook recognizes those structural forms and lets the turn end so the user can act, instead of continuing the same unchanged external-state check forever. Merely discussing the marker later in an answer still continues the plan.
+A plan can stall on something no amount of retrying fixes: a missing credential, missing hardware, a revoked authorization, an unavailable third-party service. `directive.md` instructs the agent to write `<ulw-execute-blocked-external>` as the entire first line of its answer in that case, or as the entire second line when ultrawork's mandatory opener occupies the first. The hook recognizes those structural forms and lets the turn end so the user can act, instead of continuing the same unchanged external-state check forever. Merely discussing the marker later in an answer still continues the plan.
 
-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.
+This pairs with the `ulw-execute` skill at `plugin/skills/ulw-execute/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. The continuation gate performs self-review and own manual QA by default; it escalates to one gate reviewer only when the user explicitly demands strict, rigorous, or high-accuracy review.
 
 ## Counted plan checkboxes
 
@@ -48,7 +48,7 @@ echo "$PAYLOAD_LOOP" | node dist/cli.js hook stop
 rm -rf "$TMP"
 ```
 
-Expect the first command to print JSON containing `"decision":"block"`; expect the anti-loop command to print nothing.
+Expect the first command to print JSON containing `"decision":"block"`; expect the anti-loop command to print nothing. A `SubagentStop` payload passed to `hook subagent-stop` also prints nothing.
 
 ## License
 

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/biome.json

@@ -1,9 +1,9 @@
 {
-	"$schema": "https://biomejs.dev/schemas/2.4.15/schema.json",
+	"$schema": "https://biomejs.dev/schemas/2.5.9/schema.json",
 	"linter": {
 		"enabled": true,
 		"rules": {
-			"recommended": true,
+			"preset": "recommended",
 			"style": {
 				"noDefaultExport": "error",
 				"noEnum": "error",

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/directive.md

@@ -1,4 +1,4 @@
-<start-work-continuation>
+<ulw-execute-continuation>
 
 You are mid-flight on a Prometheus work plan; this turn is an automatic continuation. Do NOT ask whether to continue — the contract is auto-continue until every top-level checkbox is `- [x]`.
 
@@ -17,11 +17,11 @@ You are mid-flight on a Prometheus work plan; this turn is an automatic continua
 
 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. 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.
+3. Follow the `ulw-execute` skill in full. The skill is already loaded from your earlier turn — re-read its file at `packages/omo-codex/plugin/skills/ulw-execute/SKILL.md` if you have lost context.
+4. Apply the checkbox's tier from its ledger entry, or classify it now per the ulw-execute 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.
-6. Every sub-task message MUST be self-contained, executable, not a context handoff: start with `TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and `VERIFY`. It must include all 7 sections and a Manual-QA channel with exact invocation (`curl`, `send-keys`, `browser:control-in-app-browser` action, `page.click`) and PASS/FAIL observable, plus ultraqa classes, artifact, and cleanup receipt. Channels: HTTP (`curl -i`); terminal/TUI (`send-keys` for boot smoke; xterm.js web terminal for color/visual evidence, never `tmux capture-pane`); browser (Codex: `browser:control-in-app-browser` first unless auth/persistent profile needed; else Chrome/agent-browser); computer use.
-7. Treat every worker DoneClaim as untrusted input. Run independent AdversarialVerify before any checkbox can become FullyDone; `confirmed` is the only pass verdict, while `false-positive`, `needs-fix`, and `needs-human-review` loop back to the executor with exact feedback.
+6. Every sub-task message MUST be self-contained, executable, not a context handoff: start with `TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and `VERIFY`. It must include all 7 sections and a Manual-QA channel with exact invocation (`curl`, `send-keys`, `browser:control-in-app-browser` action, `page.click`) and PASS/FAIL observable, plus ultraqa classes, artifact, and cleanup receipt. Channels: HTTP (`curl -i`); terminal/TUI (`send-keys` for boot smoke; xterm.js web terminal for color/visual evidence, never `tmux capture-pane`); browser (Codex: `browser:control-in-app-browser`; otherwise, or for Chrome semantics/stealth/trace/auth, write and run a `playwright-core` script from js eval with `channel: "chrome"`, persistent contexts on CLONED profiles only); computer use.
+7. Treat every worker DoneClaim as untrusted input. Run independent AdversarialVerify before any checkbox can become FullyDone; the main session may run AdversarialVerify when no separate reviewer is available. `confirmed` is the only pass verdict, while `false-positive`, `needs-fix`, and `needs-human-review` loop back to the executor with exact feedback.
 8. Use `multi_agent_v1.wait_agent` for mailbox signals, not proof of completion — a timeout only means no new mailbox update arrived; a running child is alive. For sub-tasks likely to exceed one wait cycle, require `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. Send `TASK STILL ACTIVE: return <deliverable> or BLOCKED: <reason>` only when the child is completed without the deliverable, ack-only, or no longer running. If that followup is still silent or ack-only, record inconclusive, do not count it as pass/review approval, close if safe, and respawn a smaller `fork_context: false` task with the missing deliverable.
 9. After verification of ALL sub-tasks under this checkbox: `apply_patch` the plan to change `- [ ]` → `- [x]`, re-read the plan to confirm the count decreased, append a `task-completed` line to the ledger, then continue.
 10. Do not start fresh on a sub-agent failure. Re-dispatch with a fix-message: `FAILED: <exact error>` + `Diagnosis: <observation>` + `Fix: <instruction>`.
@@ -32,7 +32,7 @@ You are mid-flight on a Prometheus work plan; this turn is an automatic continua
 - No `--dry-run` as evidence. No "should work". No "tests pass" as completion proof.
 - TUI visual evidence MUST render through the real xterm.js web terminal, never `tmux capture-pane`: run `node script/qa/web-terminal-visual-qa.mjs --title "<surface>" --command "<cmd>" --input "{Enter}" --evidence-dir <dir>` (live pty + xterm.js in Chrome; `--from-file <capture>` replays a raw stream), then cite `terminal.png`, `terminal.txt`, and `metadata.json`.
 - No `as any` / `@ts-ignore` / `@ts-expect-error`. No deleting failing tests.
-- Probe every ultraqa adversarial class whose trigger fact holds (malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions — trigger map in the start-work skill) and capture the observable for each. A clean happy-path artifact alone is NOT a PASS when an applicable class went unprobed; record skipped classes with a one-line not-applicable reason.
+- Probe every ultraqa adversarial class whose trigger fact holds (malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions — trigger map in the ulw-execute skill) and capture the observable for each. A clean happy-path artifact alone is NOT a PASS when an applicable class went unprobed; record skipped classes with a one-line not-applicable reason.
 - Cleanup receipt is mandatory. Register each QA teardown (scripts, tmux, browser contexts, PIDs, ports, containers, temp dirs) as a todo when it spawns, then execute it. Leftover QA state = BLOCKED, not PASS.
 - The worktree path (if set in boulder.json) governs every file edit and command. Do not stray into the main repo.
 - PR or branch implementation/review/merge work requires a task-owned git worktree. Treat the main worktree as read-only context.
@@ -40,15 +40,15 @@ You are mid-flight on a Prometheus work plan; this turn is an automatic continua
 
 # Final gate
 
-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. Honor the delivery mode recorded in the goal/ledger at session start: `--make-pr` hands off with the PR URL after the PR opens (merge only on explicit user ask); `--ship` keeps working until the PR is MERGED - CI and review gates fixed and addressed - then removes the worktree and syncs `.omo/` state back.
+Before completion, run your own manual QA on the real surface and a self-review against every acceptance criterion; spawn ONE gate reviewer only when the user demanded strict/rigorous/high-accuracy review; run a `debugging` runtime audit only when a failure was observed. Record the observable evidence under `{{LEDGER_PATH}}`; when a reviewer is spawned, it is allowed at most once per sub-task. 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. Honor the delivery mode recorded in the goal/ledger at session start: `--make-pr` hands off with the PR URL after the PR opens (merge only on explicit user ask); `--ship` keeps working until the PR is MERGED - CI and review gates fixed and addressed - then removes the worktree and syncs `.omo/` state back.
 
 # Stop conditions for THIS turn
 
 - A top-level checkbox flipped to `- [x]` after the 5-phase QA gate (Phase 1 read, Phase 2 automated, Phase 3 channel scenario, Phase 4 adversarial-class probing, Phase 5 gate decision). Then the Stop hook will re-evaluate; if more checkboxes remain you will be continued again.
-- A conclusive external blocker only the user or external state can clear (missing hardware, credential, authorization, or an unavailable service) → after ONE authoritative check, stop retrying and stop reviewer dispatch. Write `<start-work-blocked-external>` as the entire first line of your answer, then state the exact blocker and the observable condition that resumes the work. If ultrawork requires `ULTRAWORK MODE ENABLED!` as the first line, put the blocker marker alone on the second line instead. The Stop hook recognizes both forms and lets this turn end.
-- 3 same-failure cycles on one agent-controllable sub-task → escalate via `multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. DELIVERABLE: diagnose the repeated sub-task failure and recommend the next safe action. VERIFY: cite the failing evidence.","fork_context":false})` and stop dispatch.
+- A conclusive external blocker only the user or external state can clear (missing hardware, credential, authorization, or an unavailable service) → after ONE authoritative check, stop retrying and stop reviewer dispatch. Write `<ulw-execute-blocked-external>` as the entire first line of your answer, then state the exact blocker and the observable condition that resumes the work. If ultrawork requires `ULTRAWORK MODE ENABLED!` as the first line, put the blocker marker alone on the second line instead. The Stop hook recognizes both forms and lets this turn end.
+- 3 materially different failed remediation approaches on one agent-controllable sub-task → spawn ONE rigorous reviewer at most once per sub-task; if still blocked, hand off with the external-blocker marker at `:48`.
 - Safety boundary (destructive command, secret exfiltration, production write) → stop and surface a safe substitute.
-- All top-level checkboxes `- [x]` AND the Global Review and Debugging Gate passed → print the ORCHESTRATION COMPLETE block and end.
+- All top-level checkboxes `- [x]` AND the Final gate passed → print the ORCHESTRATION COMPLETE block and end.
 
 # Output discipline
 
@@ -57,4 +57,4 @@ Before completion, satisfy all five `review-work` lanes and a `debugging` runtim
 
 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>
+</ulw-execute-continuation>

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/dist/cli.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
-// components/start-work-continuation/src/cli.ts
+// components/ulw-execute-continuation/src/cli.ts
 import { readFileSync as readFileSync4 } from "node:fs";
 import { stdin as processStdin, stdout as processStdout } from "node:process";
 
-// components/start-work-continuation/src/boulder-reader.ts
+// components/ulw-execute-continuation/src/boulder-reader.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 
-// components/start-work-continuation/src/plan-checklist.ts
+// components/ulw-execute-continuation/src/plan-checklist.ts
 import { existsSync, readFileSync } from "node:fs";
 var TODO_HEADING_PATTERN = /^##[ \t]+TODOs(?:[ \t]+#+)?[ \t]*$/i;
 var FINAL_VERIFICATION_HEADING_PATTERN = /^##[ \t]+Final Verification Wave(?:[ \t]+#+)?[ \t]*$/i;
@@ -153,7 +153,7 @@ function emptyChecklist() {
   return { completed: 0, remaining: 0, total: 0, nextTaskLabel: null };
 }
 
-// components/start-work-continuation/src/boulder-reader.ts
+// components/ulw-execute-continuation/src/boulder-reader.ts
 var SESSION_ID_PREFIX_PATTERN = /^(codex|opencode):/;
 function readContinuationState(cwd, sessionId) {
   const boulderPath = getBoulderFilePath(cwd);
@@ -171,7 +171,7 @@ function readContinuationState(cwd, sessionId) {
     planName: work.planName,
     planPath,
     boulderPath,
-    ledgerPath: join(cwd, ".omo", "start-work", "ledger.jsonl"),
+    ledgerPath: join(cwd, ".omo", "ulw-execute", "ledger.jsonl"),
     worktreePath: work.worktreePath ?? null,
     checklist
   };
@@ -297,11 +297,11 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// components/start-work-continuation/src/directive.ts
+// components/ulw-execute-continuation/src/directive.ts
 import { readFileSync as readFileSync3 } from "node:fs";
-var START_WORK_CONTINUATION_DIRECTIVE = readFileSync3(new URL("../directive.md", import.meta.url), "utf8");
+var ULW_EXECUTE_CONTINUATION_DIRECTIVE = readFileSync3(new URL("../directive.md", import.meta.url), "utf8");
 
-// components/start-work-continuation/src/codex-hook.ts
+// components/ulw-execute-continuation/src/codex-hook.ts
 function runStopHook(input, fs) {
   if (!isStopInput(input))
     return "";
@@ -333,13 +333,13 @@ function renderDirective(state, sessionId) {
     LEDGER_PATH: state.ledgerPath,
     SESSION_ID: sessionId
   };
-  let rendered = START_WORK_CONTINUATION_DIRECTIVE;
+  let rendered = ULW_EXECUTE_CONTINUATION_DIRECTIVE;
   for (const [placeholder, value] of Object.entries(replacements)) {
     rendered = rendered.replaceAll(`{{${placeholder}}}`, value);
   }
   return rendered;
 }
-var EXTERNAL_BLOCKER_MARKER = "<start-work-blocked-external>";
+var EXTERNAL_BLOCKER_MARKER = "<ulw-execute-blocked-external>";
 var ULTRAWORK_OPENER = "ULTRAWORK MODE ENABLED!";
 function hasAllowedExternalBlockerMarker(lastAssistantMessage) {
   if (lastAssistantMessage === undefined)
@@ -378,7 +378,7 @@ function isStopInput(value) {
   return isRecord2(value) && isStopHookEventName(value["hook_event_name"]) && typeof value["session_id"] === "string" && typeof value["turn_id"] === "string" && typeof value["transcript_path"] === "string" && typeof value["cwd"] === "string" && typeof value["model"] === "string" && typeof value["permission_mode"] === "string" && typeof value["stop_hook_active"] === "boolean" && optionalString(value["last_assistant_message"]);
 }
 function isStopHookEventName(value) {
-  return value === "Stop" || value === "SubagentStop";
+  return value === "Stop";
 }
 function optionalString(value) {
   return value === undefined || typeof value === "string";
@@ -387,7 +387,7 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// components/start-work-continuation/src/cli.ts
+// components/ulw-execute-continuation/src/cli.ts
 var nodeFileSystem = {
   readFileSync(path, encoding) {
     return readFileSync4(path, encoding);
@@ -398,7 +398,7 @@ var subcommand = process.argv[3];
 if (command === "hook" && (subcommand === "stop" || subcommand === "subagent-stop")) {
   await runHookCli();
 } else {
-  process.stderr.write(`Usage: omo-start-work-continuation hook <stop|subagent-stop>
+  process.stderr.write(`Usage: omo-ulw-execute-continuation hook <stop|subagent-stop>
 `);
   process.exitCode = 1;
 }
@@ -422,13 +422,13 @@ function parseHookInput(raw) {
   }
 }
 function readStdin() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve) => {
     let data = "";
     processStdin.setEncoding("utf8");
     processStdin.on("data", (chunk) => {
       data += chunk;
     });
-    processStdin.once("error", () => resolve2(data));
-    processStdin.once("end", () => resolve2(data));
+    processStdin.once("error", () => resolve(data));
+    processStdin.once("end", () => resolve(data));
   });
 }

package/packages/omo-codex/plugin/components/ulw-execute-continuation/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+	"hooks": {
+		"Stop": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/components/ulw-execute-continuation/dist/cli.js\" hook stop",
+						"timeout": 10,
+						"statusMessage": "(OmO 5.0.0-beta.71) Checking Ulw-Execute Continuation"
+					}
+				]
+			}
+		]
+	}
+}

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/package.json

@@ -1,28 +1,28 @@
 {
-	"name": "@code-yeongyu/codex-start-work-continuation",
-	"version": "5.0.0-beta.7",
-	"description": "Codex Stop hook continuation injector for omo-codex start-work plans.",
+	"name": "@code-yeongyu/codex-ulw-execute-continuation",
+	"version": "5.0.0-beta.71",
+	"description": "Codex Stop hook continuation injector for omo-codex ulw-execute plans.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",
 	"license": "MIT",
-	"homepage": "https://github.com/code-yeongyu/codex-start-work-continuation",
+	"homepage": "https://github.com/code-yeongyu/codex-ulw-execute-continuation",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/code-yeongyu/codex-start-work-continuation.git"
+		"url": "git+https://github.com/code-yeongyu/codex-ulw-execute-continuation.git"
 	},
 	"bugs": {
-		"url": "https://github.com/code-yeongyu/codex-start-work-continuation/issues"
+		"url": "https://github.com/code-yeongyu/codex-ulw-execute-continuation/issues"
 	},
 	"keywords": [
 		"codex",
 		"codex-plugin",
-		"start-work",
+		"ulw-execute",
 		"continuation",
 		"hooks",
 		"boulder"
 	],
 	"bin": {
-		"omo-start-work-continuation": "./dist/cli.js"
+		"omo-ulw-execute-continuation": "./dist/cli.js"
 	},
 	"scripts": {
 		"build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && bun build src/cli.ts --target node --format esm --outfile dist/cli.js",
@@ -42,10 +42,10 @@
 		"NOTICE"
 	],
 	"devDependencies": {
-		"@biomejs/biome": "2.4.16",
-		"@types/node": "^25.9.3",
-		"typescript": "^6.0.3",
-		"vitest": "^4.1.8"
+		"@biomejs/biome": "2.5.9",
+		"@types/node": "^26.2.0",
+		"typescript": "^7.0.2",
+		"vitest": "^4.1.11"
 	},
 	"engines": {
 		"node": ">=20.0.0"

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/src/boulder-reader.ts

@@ -50,7 +50,7 @@ export function readContinuationState(cwd: string, sessionId: string): Continuat
 		planName: work.planName,
 		planPath,
 		boulderPath,
-		ledgerPath: join(cwd, ".omo", "start-work", "ledger.jsonl"),
+		ledgerPath: join(cwd, ".omo", "ulw-execute", "ledger.jsonl"),
 		worktreePath: work.worktreePath ?? null,
 		checklist,
 	};

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/src/cli.ts

@@ -17,7 +17,7 @@ const subcommand = process.argv[3];
 if (command === "hook" && (subcommand === "stop" || subcommand === "subagent-stop")) {
 	await runHookCli();
 } else {
-	process.stderr.write("Usage: omo-start-work-continuation hook <stop|subagent-stop>\n");
+	process.stderr.write("Usage: omo-ulw-execute-continuation hook <stop|subagent-stop>\n");
 	process.exitCode = 1;
 }
 

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/src/codex-hook.ts

@@ -1,6 +1,6 @@
 import type { ContinuationState } from "./boulder-reader.js";
 import { readContinuationState } from "./boulder-reader.js";
-import { START_WORK_CONTINUATION_DIRECTIVE } from "./directive.js";
+import { ULW_EXECUTE_CONTINUATION_DIRECTIVE } from "./directive.js";
 import type { ReadonlyFileSystem, StopHookEventName, StopHookOutput, StopInput } from "./types.js";
 
 export function runStopHook(input: unknown, fs: ReadonlyFileSystem): string {
@@ -33,14 +33,14 @@ function renderDirective(state: ContinuationState, sessionId: string): string {
 		LEDGER_PATH: state.ledgerPath,
 		SESSION_ID: sessionId,
 	} as const;
-	let rendered = START_WORK_CONTINUATION_DIRECTIVE;
+	let rendered = ULW_EXECUTE_CONTINUATION_DIRECTIVE;
 	for (const [placeholder, value] of Object.entries(replacements)) {
 		rendered = rendered.replaceAll(`{{${placeholder}}}`, value);
 	}
 	return rendered;
 }
 
-const EXTERNAL_BLOCKER_MARKER = "<start-work-blocked-external>";
+const EXTERNAL_BLOCKER_MARKER = "<ulw-execute-blocked-external>";
 const ULTRAWORK_OPENER = "ULTRAWORK MODE ENABLED!";
 
 // The marker alone is not enough to end the turn. `directive.md` requires the exact blocker and
@@ -96,7 +96,7 @@ function isStopInput(value: unknown): value is StopInput {
 }
 
 function isStopHookEventName(value: unknown): value is StopHookEventName {
-	return value === "Stop" || value === "SubagentStop";
+	return value === "Stop";
 }
 
 function optionalString(value: unknown): boolean {

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/src/directive.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from "node:fs";
 
-export const START_WORK_CONTINUATION_DIRECTIVE: string = readFileSync(
+export const ULW_EXECUTE_CONTINUATION_DIRECTIVE: string = readFileSync(
 	new URL("../directive.md", import.meta.url),
 	"utf8",
 );

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/src/index.ts

@@ -1,5 +1,5 @@
 export type { ContinuationState, PlanChecklist } from "./boulder-reader.js";
 export { readContinuationState } from "./boulder-reader.js";
 export { runStopHook } from "./codex-hook.js";
-export { START_WORK_CONTINUATION_DIRECTIVE } from "./directive.js";
+export { ULW_EXECUTE_CONTINUATION_DIRECTIVE } from "./directive.js";
 export type { ReadonlyFileSystem, StopHookEventName, StopHookOutput, StopInput } from "./types.js";

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/src/types.ts

@@ -1,4 +1,4 @@
-export const STOP_HOOK_EVENTS = ["Stop", "SubagentStop"] as const;
+export const STOP_HOOK_EVENTS = ["Stop"] as const;
 export type StopHookEventName = (typeof STOP_HOOK_EVENTS)[number];
 
 export type StopInput = {

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/test/boulder-reader.test.ts

@@ -11,7 +11,7 @@ afterEach(() => {
 	for (const root of cleanupRoots.splice(0)) rmSync(root, { recursive: true, force: true });
 });
 
-describe("start-work plan checklist consumption", () => {
+describe("ulw-execute plan checklist consumption", () => {
 	it("#given scaffold headings and canonical numbered rows #when parsed #then structured totals and next label match", () => {
 		// given
 		const planPath = createPlan(SCAFFOLD_PLAN_MARKDOWN);
@@ -242,7 +242,7 @@ describe("start-work plan checklist consumption", () => {
 	});
 });
 
-describe("start-work boulder state reader", () => {
+describe("ulw-execute boulder state reader", () => {
 	it("#given active codex work with remaining checklist #when state is read #then continuation fields match baseline", () => {
 		// given
 		const workspace = createWorkspace({
@@ -258,7 +258,7 @@ describe("start-work boulder state reader", () => {
 			planName: "launch-plan",
 			planPath: join(workspace, ".omo", "plans", "plan.md"),
 			boulderPath: join(workspace, ".omo", "boulder.json"),
-			ledgerPath: join(workspace, ".omo", "start-work", "ledger.jsonl"),
+			ledgerPath: join(workspace, ".omo", "ulw-execute", "ledger.jsonl"),
 			worktreePath: null,
 			checklist: {
 				completed: 2,

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/test/cli.test.ts

@@ -12,7 +12,7 @@ afterEach(() => {
 	for (const root of cleanupRoots.splice(0)) rmSync(root, { recursive: true, force: true });
 });
 
-describe("start-work continuation CLI", () => {
+describe("ulw-execute continuation CLI", () => {
 	it("#given valid Stop stdin #when CLI runs #then stdout contains block JSON", () => {
 		// given
 		const cwd = createWorkspace(["codex:s1"]);
@@ -26,12 +26,9 @@ describe("start-work continuation CLI", () => {
 		expect(result.status).toBe(0);
 		const output = parseStopHookOutput(result.stdout);
 		expect(output.decision).toBe("block");
-		expect(output.reason).toContain("Remaining top-level checkboxes: `2` of `4`");
-		expect(output.reason).toContain("Next incomplete task: `1. Implement checklist parser parity`");
-		expect(output.reason).toContain("Your session id in boulder.json: `codex:s1`");
 	});
 
-	it("#given valid SubagentStop stdin #when CLI runs #then stdout contains block JSON", () => {
+	it("#given valid SubagentStop stdin #when CLI runs #then stdout is empty", () => {
 		// given
 		const cwd = createWorkspace(["codex:s1"]);
 		const payload = JSON.stringify(makePayload(cwd, false, "SubagentStop"));
@@ -42,7 +39,7 @@ describe("start-work continuation CLI", () => {
 		// then
 		if (result.error !== undefined) throw result.error;
 		expect(result.status).toBe(0);
-		expect(result.stdout).toContain('"decision":"block"');
+		expect(result.stdout).toBe("");
 	});
 
 	it("#given active stop hook stdin #when CLI runs #then stdout is empty and exit is zero", () => {
@@ -122,11 +119,7 @@ function createWorkspace(sessionIds: readonly string[]): string {
 	return root;
 }
 
-function makePayload(
-	cwd: string,
-	stopHookActive: boolean,
-	eventName: "Stop" | "SubagentStop",
-): Record<string, string | boolean> {
+function makePayload(cwd: string, stopHookActive: boolean, eventName: string): Record<string, string | boolean> {
 	return {
 		session_id: "s1",
 		turn_id: "t1",

package/packages/omo-codex/plugin/components/{start-work-continuation → ulw-execute-continuation}/test/codex-hook.test.ts

@@ -14,7 +14,7 @@ afterEach(() => {
 	for (const root of cleanupRoots.splice(0)) rmSync(root, { recursive: true, force: true });
 });
 
-describe("start-work Stop hook", () => {
+describe("ulw-execute Stop hook", () => {
 	it("#given stop hook is already active #when hook runs #then returns empty output", () => {
 		// given
 		const fs = createMemoryFs();
@@ -58,16 +58,23 @@ describe("start-work Stop hook", () => {
 		const output = runStopHook(createStopInput(workspace), fs);
 
 		// then
-		const parsed = parseBlockOutput(output);
-		expect(parsed.decision).toBe("block");
-		expect(parsed.reason).toContain("- Plan: `launch-plan`");
-		expect(parsed.reason).toContain(`- Plan file: \`${join(workspace, ".omo", "plans", "plan.md")}\``);
-		expect(parsed.reason).toContain(`- Boulder state: \`${join(workspace, ".omo", "boulder.json")}\``);
-		expect(parsed.reason).toContain("- Remaining top-level checkboxes: `2` of `4`");
-		expect(parsed.reason).toContain("- Next incomplete task: `1. Implement checklist parser parity`");
-		expect(parsed.reason).toContain("- Worktree: `/tmp/worktree`");
-		expect(parsed.reason).toContain(`- Ledger: \`${join(workspace, ".omo", "start-work", "ledger.jsonl")}\``);
-		expect(parsed.reason).toContain("- Your session id in boulder.json: `codex:sess_abc`");
+		expect(parseBlockOutput(output).decision).toBe("block");
+	});
+
+	it("#given active Boulder work and a SubagentStop event #when hook runs #then returns empty output", () => {
+		// given
+		const workspace = createWorkspace({
+			boulderJson: createBoulderJson({ sessionIds: ["codex:sess_abc"], status: "active" }),
+			planMarkdown: SCAFFOLD_PLAN_MARKDOWN,
+		});
+		const fs = createMemoryFs();
+		const input = { ...createStopInput(workspace), hook_event_name: "SubagentStop" as const };
+
+		// when
+		const output = runStopHook(input, fs);
+
+		// then
+		expect(output).toBe("");
 	});
 
 	it("#given active codex work and an external-blocker marker #when hook runs #then returns empty output", () => {
@@ -80,7 +87,7 @@ describe("start-work Stop hook", () => {
 		const input = {
 			...createStopInput(workspace),
 			last_assistant_message: [
-				"<start-work-blocked-external>",
+				"<ulw-execute-blocked-external>",
 				"Blocker: the staging deploy credential is missing.",
 				"Resume when a valid credential is provisioned.",
 			].join("\n"),
@@ -104,7 +111,7 @@ describe("start-work Stop hook", () => {
 			...createStopInput(workspace),
 			last_assistant_message: [
 				"ULTRAWORK MODE ENABLED!",
-				"<start-work-blocked-external>",
+				"<ulw-execute-blocked-external>",
 				"Blocker: the staging deploy credential is missing.",
 			].join("\n"),
 		};
@@ -127,7 +134,7 @@ describe("start-work Stop hook", () => {
 		const fs = createMemoryFs();
 		const input = {
 			...createStopInput(workspace),
-			last_assistant_message: "<start-work-blocked-external>",
+			last_assistant_message: "<ulw-execute-blocked-external>",
 		};
 
 		// when
@@ -146,7 +153,7 @@ describe("start-work Stop hook", () => {
 		const fs = createMemoryFs();
 		const input = {
 			...createStopInput(workspace),
-			last_assistant_message: ["ULTRAWORK MODE ENABLED!", "<start-work-blocked-external>", "   "].join("\n"),
+			last_assistant_message: ["ULTRAWORK MODE ENABLED!", "<ulw-execute-blocked-external>", "   "].join("\n"),
 		};
 
 		// when
@@ -165,7 +172,7 @@ describe("start-work Stop hook", () => {
 		const fs = createMemoryFs();
 		const input = {
 			...createStopInput(workspace),
-			last_assistant_message: ["Next turn I may need to emit", "<start-work-blocked-external>"].join("\n"),
+			last_assistant_message: ["Next turn I may need to emit", "<ulw-execute-blocked-external>"].join("\n"),
 		};
 
 		// when
@@ -187,12 +194,7 @@ describe("start-work Stop hook", () => {
 		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");
+		expect(parseBlockOutput(output).decision).toBe("block");
 	});
 
 	it("#given context-window pressure in transcript #when hook runs #then it does not inject continuation text", () => {

package/packages/omo-codex/plugin/components/ulw-loop/AGENTS.md

@@ -42,7 +42,26 @@ Conventions for human contributors and AI agents working on this repository.
 - CLI commands use the `omo-agent-toolkit ulw-loop` form.
 - Do not use any alternate legacy CLI alias anywhere.
 
+## Layout
+
+- `src/cli.ts`: bin entry (`omo-ulw-loop`, `ulw`, `ulw-loop` all map to `dist/cli.js`); documented invocation form `omo-agent-toolkit ulw-loop <subcommand>`.
+- `src/cli-commands.ts`: subcommand dispatch (`ULW_LOOP_SUBCOMMANDS`, `ulwLoopCommand`, flag/value readers).
+- `src/plan-io.ts`: plan persistence, append-only `ledger.jsonl`, `withUlwLoopMutationLock`.
+- `src/quality-gate.ts` (188 LOC), `src/checkpoint.ts` (247), `src/steering.ts` (203): state-transition hotspots (evidence containment, checkpoint reconciliation, steering mutations).
+- `src/quality-gate-artifacts.ts`: artifact-ref / surface-kind primitives shared by the gate validator; `src/quality-gate-aggregate.ts`: non-throwing defect pre-pass that aggregates every gate defect into one error.
+- `src/codex-hook.ts`: UserPromptSubmit steering injection + `create_goal` budget guard.
+- `src/spawn-guard.ts`, `src/stop-resume-hook.ts`: spawn guards, Stop auto-resume.
+- `src/surface.ts`: toolkit surface + reviewer-identity resolution (`lazycodex` default; staged `surface.json` marker or `OMO_AGENT_TOOLKIT_SURFACE` selects `omo-senpi`).
+- `src/ultrawork-skill-pointer.ts`: byte-identical mirror of ultrawork's pointer (pinned by `plugin/test/ultrawork-skill-pointer.test.mjs`).
+- `directive.md`: runtime-read directive (never inlined into TypeScript). GENERATED from the canonical `packages/prompts-core/prompts/ultrawork/codex.md` by `components/ultrawork/scripts/sync-directive.mjs` and checked in, because this package is published standalone with no prompts-core dependency. Do not hand-edit; byte identity is pinned by `test/ultrawork-directive.test.ts`.
+
 ## Build and Hooks
 
 - Build output goes to `dist/`.
 - `hooks/hooks.json` wires `hook user-prompt-submit --with-ultrawork` (UserPromptSubmit), `hook pre-tool-use` (create_goal budget), `hook pre-tool-use-spawn` (spawn guards), and `hook stop` (auto-resume).
+
+## Commands
+
+- `npm test` (vitest --run) / `npm run test:watch`; focused: `bunx vitest run test/<file>.test.ts`
+- `npm run typecheck` / `npm run lint` / `npm run build` (`tsc -p tsconfig.build.json`) / `npm run check`
+- These stay npm even though the repo root is bun-driven: `.github/workflows/ci.yml` runs this component as `npm --prefix "$component" run check` (the loop selects every component whose `package.json` declares `scripts.check`, which includes this one), `scripts.check` itself shells `npm run build`, and the surrounding plugin tree is installed with `npm --prefix packages/omo-codex/plugin ci` in both `ci.yml` and `publish.yml`. Run the bun equivalents (`bun run test`, `bunx tsc -p tsconfig.build.json`, `bunx biome check .`) locally if you prefer, but do not rewrite this section to bun-only while CI invokes npm here.

package/packages/omo-codex/plugin/components/ulw-loop/CHANGELOG.md

@@ -2,9 +2,25 @@
 
 ## [0.1.0] - unreleased
 
+- **Fix:** a `goals.json` written outside the commit log (the removed `omo_agent_toolkit` tool path rewrote it wholesale, never stamping `revision`) no longer loses to an older `revisions/` snapshot when it holds goals that snapshot lacks; the cache wins, is stamped with the snapshot's revision, and the next publish folds it into revision N+1 instead of colliding on an existing record. Raw `ledger.jsonl` lines appended after a published revision are attributed to that revision rather than to the pre-store past a later `ledgerResetRevision` discards. Locked reads and every commit now refuse to rewrite `goals.json` while the reconciled ledger names a `goal_added` goal the projection lacks (`ULW_LOOP_PROJECTION_TRUNCATED`, `details.missingGoalIds`) instead of silently truncating the plan (code-yeongyu/oh-my-openagent#8328).
+- Status nextActions and missing-plan recovery now follow the calling surface: omo-senpi teaches the eval SDK methods and current attempt directory without asking for a driver snapshot; LazyCodex retains its existing CLI guidance byte-for-byte.
+
+- Async `.state.lock` holders now keep their file descriptor open and refresh a 30-second lease through it. An expired lease can be reclaimed even while its process remains alive; sync hooks and older lease-less records retain dead-pid-only ownership. Windows filesystems that refuse unlinking an open lock fail closed. Interrupted kernels can recover after lease expiry without deleting a live owner's lock.
+- Plan and audit mutations publish one immutable `revisions/<revision>.json` record using create-only hard links. Published revision paths are never deleted or reused.
+- `ULW_LOOP_PUBLISH_CONFLICT` retries the complete mutation once while its lock token remains owned.
+- A displaced writer receives `ULW_LOOP_LOCK_LOST` instead of overwriting its successor's state.
+- Filesystems without atomic hard links fail closed with `ULW_LOOP_PUBLISH_UNSUPPORTED_FS` (no copy fallback).
+- Additive plan fields `revision`, `brief`, and `ledgerResetRevision`, plus ledger `revision` and `id`, remain optional on legacy reads. The first mutation hydrates a legacy brief, and objective migration is folded into that mutation rather than committed by a read. Force recreation advances the revision and filters older audit entries instead of truncating the ledger.
+- `goals.json`, `ledger.jsonl`, and `brief.md` are complete-file, temp-and-rename derived views. Shared readers reconcile committed records after a crash, including audit-only steering and idempotency, and locked reads repair lagging views. Logical audit order is revision/sequence, not completion order. Older CLIs see complete but possibly lagging or transiently regressed caches; after force recreation they may see pre-reset entries until views are replaced. Hook budget counters remain separate from plan/audit state. Reconciliation now materializes the logical ledger in memory, replacing the earlier streaming-only dedup implementation.
+- Reconciling a plan reads only the newest commit record (newest revision first, stopping at the first valid one) instead of parsing every record in `revisions/`, so a status probe stays independent of how many revisions a session has committed. The full scan remains where the audit trail needs every record.
+
+- SDK contexts now reject session IDs that normalize to null with `ULW_LOOP_SESSION_ID_INVALID`, before any session state directory is created.
+
+- LazyCodex native spawns now require an explicit bundled role before plan, budget, or artifact checks. Unknown and unnamed roles fail loudly; Senpi admission is unchanged. Guidance follows the actual spawn schema, including V2 `agent_type` when exposed. Installer/bootstrap provide an opt-out-able, ownership-checked medium-worker `default` for unnamed non-forks. An unnamed full-history fork still skips role application inside Codex: configuration cannot repair that upstream gap, and enforcement depends on Codex invoking the trusted hook. Legacy schemas without `agent_type` retain message-carried instructions but are rejected by the schema-blind guard rather than silently falling through.
+
 - Bundled `directive.md` picks up the ultrawork test-proportionality change: the execution-loop PIN step asks for characterization pins only when refactoring behavior whose regressions the change could hide. Stays byte-identical to `prompts-core/ultrawork/codex.md` and the ultrawork component's `directive.md`.
 
-- **Hooks:** new `Stop` hook auto-resumes a turn that died with unfinished goals (defers to start-work-continuation while its plan has remaining tasks, bails under context pressure, and caps at two resumes without ledger movement via a separate `.stuck` marker). New `PreToolUse` spawn guard adds a per-session fan-out cap (`OMO_SPAWN_FANOUT_LIMIT`, default 60) and denies final gate-reviewer spawns while the reviewer artifacts the gate audits are missing.
+- **Hooks:** new `Stop` hook auto-resumes a turn that died with unfinished goals (defers to ulw-execute-continuation while its plan has remaining tasks, bails under context pressure, and caps at two resumes without ledger movement via a separate `.stuck` marker). New `PreToolUse` spawn guard adds a per-session fan-out cap (`OMO_SPAWN_FANOUT_LIMIT`, default 60) and denies final gate-reviewer spawns while the reviewer artifacts the gate audits are missing.
 
 - **Memory:** steering ledger entries no longer embed the full plan four times (`before`/`after` at both the audit and entry level). Accepted steers now record a compact `UlwLoopSteeringPlanSnapshot` (plan counters + only the goals the mutation touched), shrinking a measured real-world entry from 189KB to 7.8KB (~24x) and ending quadratic `ledger.jsonl` growth over long runs.
 - **Memory:** steering dedup (`--idempotency-key` / `promptSignature`) streams the ledger line-by-line with a substring pre-filter instead of `JSON.parse`-ing every entry into memory; dedup returns strip legacy full-plan `before`/`after` payloads from re-surfaced audits. `readSteeringLedgerEntries` streams too.