oh-my-opencode 4.16.2 → 4.17.0

package/packages/omo-codex/plugin/components/ulw-loop/dist/checkpoint.js

@@ -1,3 +1,4 @@
+import { ulwLoopAttemptEvidenceDir } from "./paths.js";
 import { existsSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -79,12 +80,13 @@ function ledgerKind(status, goal, aggregateCompletion) {
     return status === "blocked" ? "goal_blocked" : "goal_failed";
 }
 function buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletion) {
+    const watch = qualityGate?.codeReview.codeQualityStatus === "WATCH";
     const entry = {
         at: now,
         kind: ledgerKind(args.status, goal, aggregateCompletion),
         goalId: goal.id,
         status: goal.status,
-        evidence: args.evidence,
+        evidence: watch ? `${args.evidence} | codeQuality=WATCH: ${qualityGate.codeReview.evidence}` : args.evidence,
     };
     if (codexGoal !== undefined)
         entry.codexGoal = codexGoal;
@@ -148,6 +150,9 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
                 qualityGate = validateQualityGate(await readJsonInput(args.qualityGateJson, repoRoot), {
                     repoRoot,
                     fs: QUALITY_GATE_FS,
+                    ...(plan.evidenceLayoutVersion === 2
+                        ? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) }
+                        : {}),
                 });
             goal.status = "complete";
             goal.completedAt = now;

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli-subcommands.d.ts

@@ -1,4 +1,4 @@
-import type { UlwLoopScope } from "./paths.js";
+import { type UlwLoopScope } from "./paths.js";
 export declare function createGoals(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function status(repoRoot: string, json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function completeGoals(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli-subcommands.js

@@ -6,6 +6,7 @@ import { parseSteeringProposal, printSteerResult } from "./cli-steering.js";
 import { buildCodexGoalInstruction } from "./codex-goal-instruction.js";
 import { recordEvidence } from "./evidence.js";
 import { isEssentialCriterion } from "./goal-status.js";
+import { ulwLoopAttemptEvidenceDir } from "./paths.js";
 import { addUlwLoopGoal, createUlwLoopPlan, startNextUlwLoop, summarizeUlwLoopPlan } from "./plan-crud.js";
 import { readUlwLoopPlan } from "./plan-io.js";
 import { recordFinalReviewBlockers } from "./review-blockers.js";
@@ -34,8 +35,18 @@ export async function createGoals(repoRoot, argv, json, scope) {
 }
 export async function status(repoRoot, json, scope) {
     const plan = await readUlwLoopPlan(repoRoot, scope);
-    if (json)
-        printJson({ ok: true, plan, summary: summarizeUlwLoopPlan(plan) });
+    if (json) {
+        const active = plan.goals.find((goal) => goal.id === plan.activeGoalId);
+        const currentAttemptDir = plan.evidenceLayoutVersion === 2 && active
+            ? ulwLoopAttemptEvidenceDir(active.id, active.attempt, scope)
+            : undefined;
+        printJson({
+            ok: true,
+            plan,
+            summary: summarizeUlwLoopPlan(plan),
+            ...(currentAttemptDir === undefined ? {} : { currentAttemptDir }),
+        });
+    }
     else
         printStatus(plan);
     return 0;

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

@@ -209,17 +209,8 @@ function normalizeCodexGoalMode(value) {
 // components/ulw-loop/src/cli-subcommands.ts
 import { readFile as readFile6 } from "node:fs/promises";
 
-// components/ulw-loop/src/checkpoint.ts
-import { existsSync as existsSync3, statSync } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
-import { resolve as resolve3 } from "node:path";
-
-// components/ulw-loop/src/checkpoint-reconciliation.ts
-import { existsSync } from "node:fs";
-import { readFile as readFile2 } from "node:fs/promises";
-
 // components/ulw-loop/src/paths.ts
-import { join } from "node:path";
+import { isAbsolute, join, relative, sep } from "node:path";
 var SESSION_ENV_KEYS = ["OMO_ULW_LOOP_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID"];
 function normalizeUlwLoopSessionId(sessionId) {
   const trimmed = sessionId?.trim();
@@ -271,6 +262,28 @@ function repoRelative(absolutePath, repoRoot) {
     return absolutePath.slice(backslashPrefix.length).split("\\").join("/");
   return absolutePath.split("\\").join("/");
 }
+function ulwLoopAttemptEvidenceDir(goalId, attempt, scope) {
+  const sessionId = normalizeUlwLoopSessionId(scope?.sessionId) ?? resolveUlwLoopSessionIdFromEnv() ?? "session";
+  return `.omo/evidence/ulw/${sessionId}/${goalId}/a${attempt}`;
+}
+var PLATFORM_PATH_API = { relative, isAbsolute, sep };
+function isWithinAttemptDir(absolutePath, attemptRoot, pathApi = PLATFORM_PATH_API) {
+  const relativePath = pathApi.relative(attemptRoot, absolutePath);
+  if (relativePath === "")
+    return true;
+  if (relativePath === ".." || relativePath.startsWith(`..${pathApi.sep}`))
+    return false;
+  return !pathApi.isAbsolute(relativePath);
+}
+
+// components/ulw-loop/src/checkpoint.ts
+import { existsSync as existsSync3, statSync } from "node:fs";
+import { readFile as readFile5 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
+
+// components/ulw-loop/src/checkpoint-reconciliation.ts
+import { existsSync } from "node:fs";
+import { readFile as readFile2 } from "node:fs/promises";
 
 // components/ulw-loop/src/goal-status.ts
 var ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE = aggregateCodexObjectiveForScope();
@@ -779,6 +792,27 @@ function literal(value, expected, field) {
   invalid(`${field} must be ${String(expected)}.`, field);
 }
 
+// components/ulw-loop/src/quality-gate-verdicts.ts
+function passedVerdict(value, field) {
+  if (value === "not_applicable")
+    invalid(`${field} must not be not_applicable.`, field);
+  return literal(value, "passed", field);
+}
+function codeQualityStatusField(value, field) {
+  if (value === "CLEAR" || value === "WATCH")
+    return value;
+  invalid(`${field} must be CLEAR or WATCH.`, field);
+}
+function adversarialVerdict(row, field) {
+  const value = row["verdict"];
+  if (value === "passed")
+    return { verdict: "passed" };
+  if (value === "not_applicable") {
+    return { verdict: "not_applicable", reason: textField(row["reason"], `${field}.reason`) };
+  }
+  invalid(`${field} must be passed or not_applicable with a reason.`, field);
+}
+
 // components/ulw-loop/src/quality-gate-blockers.ts
 var BLOCKER_FIELD_KEYS = "blocker blockerSignature blockerEvidence blockerOccurrences blockedAt".split(" ");
 var URL_PATTERN = /https?:\/\/\S+/g;
@@ -843,11 +877,6 @@ function kindField(value, field) {
     return value;
   invalid(`${field} must be a supported artifact kind.`, field);
 }
-function passedVerdict(value, field) {
-  if (value === "not_applicable")
-    invalid(`${field} must not be not_applicable.`, field);
-  return literal(value, "passed", field);
-}
 function artifactCompatible(surface, kind) {
   switch (surface) {
     case "cli":
@@ -870,9 +899,13 @@ function checkFile(path, field, opts) {
   const absolute = resolve2(opts.repoRoot, path);
   if (!opts.fs.existsSync(absolute))
     invalid(`${field} must point to an existing artifact.`, field);
-  const stat = opts.fs.statSync(absolute);
-  if (stat.size <= 0)
+  if (opts.fs.statSync(absolute).size <= 0)
     invalid(`${field} must point to a non-empty artifact.`, field);
+  if (opts.currentAttemptDir !== undefined) {
+    const attemptRoot = resolve2(opts.repoRoot, opts.currentAttemptDir);
+    if (!isWithinAttemptDir(absolute, attemptRoot))
+      invalid(`${field} (${path}) must point to an artifact from the current attempt (${opts.currentAttemptDir}).`, field);
+  }
 }
 function artifactMap(refs) {
   const byId = new Map;
@@ -929,7 +962,7 @@ function validateQualityGate(input, opts) {
     codeReview: {
       by: reviewerRoleField(codeReview["by"], REVIEWER_ROLES.codeReview, "codeReview.by"),
       recommendation: literal(codeReview["recommendation"], "APPROVE", "codeReview.recommendation"),
-      codeQualityStatus: literal(codeReview["codeQualityStatus"], "CLEAR", "codeReview.codeQualityStatus"),
+      codeQualityStatus: codeQualityStatusField(codeReview["codeQualityStatus"], "codeReview.codeQualityStatus"),
       reportPath: codeReportPath,
       evidence: textField(codeReview["evidence"], "codeReview.evidence"),
       blockers: emptyBlockers(codeReview["blockers"], "codeReview.blockers")
@@ -993,12 +1026,14 @@ function parseAdversarialCases(value, byId) {
   return value.map((item, index) => {
     const row = section(item, `manualQa.adversarialCases[${index}]`);
     const artifacts = referencedArtifacts(row["artifactRefs"], `manualQa.adversarialCases[${index}].artifactRefs`, byId);
+    const verdictInfo = adversarialVerdict(row, `manualQa.adversarialCases[${index}]`);
     return {
       id: textField(row["id"], `manualQa.adversarialCases[${index}].id`),
       criterionRef: textField(row["criterionRef"], `manualQa.adversarialCases[${index}].criterionRef`),
       scenario: textField(row["scenario"], `manualQa.adversarialCases[${index}].scenario`),
       expectedBehavior: textField(row["expectedBehavior"], `manualQa.adversarialCases[${index}].expectedBehavior`),
-      verdict: passedVerdict(row["verdict"], `manualQa.adversarialCases[${index}].verdict`),
+      verdict: verdictInfo.verdict,
+      ...verdictInfo.reason === undefined ? {} : { reason: verdictInfo.reason },
       artifactRefs: artifacts.map((artifact) => artifact.id)
     };
   });
@@ -1074,12 +1109,13 @@ function ledgerKind2(status, goal, aggregateCompletion) {
   return status === "blocked" ? "goal_blocked" : "goal_failed";
 }
 function buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletion) {
+  const watch = qualityGate?.codeReview.codeQualityStatus === "WATCH";
   const entry = {
     at: now,
     kind: ledgerKind2(args.status, goal, aggregateCompletion),
     goalId: goal.id,
     status: goal.status,
-    evidence: args.evidence
+    evidence: watch ? `${args.evidence} | codeQuality=WATCH: ${qualityGate.codeReview.evidence}` : args.evidence
   };
   if (codexGoal !== undefined)
     entry.codexGoal = codexGoal;
@@ -1135,7 +1171,8 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
       if (final || aggregateCompletion !== undefined)
         qualityGate = validateQualityGate(await readJsonInput2(args.qualityGateJson, repoRoot), {
           repoRoot,
-          fs: QUALITY_GATE_FS
+          fs: QUALITY_GATE_FS,
+          ...plan.evidenceLayoutVersion === 2 ? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) } : {}
         });
       goal.status = "complete";
       goal.completedAt = now;
@@ -1391,6 +1428,7 @@ function buildText(mode, plan, goal, createGoal, isFinal) {
     "- Use the create_goal payload exactly as rendered: objective only.",
     "- Goals are unlimited. Do not add numeric limits.",
     ...modeConstraintLines(mode, isFinal),
+    ...evidenceLayoutLines(plan),
     finalSection(plan, goal, isFinal, mode === "aggregate"),
     ...checkpointLines(plan, mode),
     "",
@@ -1436,6 +1474,13 @@ function formatCriterionLine(criterion) {
   const marker = isEssentialCriterion(criterion) ? "essential" : "non-essential";
   return `-${remainingWork} [${criterion.id}] [${marker}] (${criterion.userModel}) ${criterion.scenario} — expect: ${criterion.expectedEvidence} — status: ${criterion.status}`;
 }
+function evidenceLayoutLines(plan) {
+  if (plan.evidenceLayoutVersion !== 2)
+    return [];
+  return [
+    "- Evidence layout v2: write every artifact for the active goal (QA matrix, review reports, receipts) under the current attempt directory — read currentAttemptDir from `omo ulw-loop status --json` (.omo/evidence/ulw/<session>/<goalId>/a<attempt>). The final checkpoint rejects quality-gate artifacts outside that directory."
+  ];
+}
 function finalSection(plan, goal, isFinal, aggregate) {
   if (!isFinal)
     return "- This is not the final ulw-loop story; do not run the final reviewer/manual-QA/gate-review quality gate yet.";
@@ -1446,8 +1491,11 @@ function finalSection(plan, goal, isFinal, aggregate) {
     "Final story — run mandatory quality gate before update_goal:",
     "- Run targeted verification for changed behavior.",
     "- Confirm every manualQa artifact path exists and has non-zero size.",
-    "- Spawn final reviewers with fork_context=false: lazycodex-code-reviewer, lazycodex-qa-executor, and lazycodex-gate-reviewer. Include the original brief, goal objectives, desired user-visible outcome, diff, and evidence.",
+    '- First spawn lazycodex-code-reviewer and lazycodex-qa-executor in parallel (fork_context: false on the v1 surface; fork_turns: "none" on v2). Include the original brief, goal objectives, desired user-visible outcome, diff, and evidence; wait for BOTH to return and confirm their report artifacts exist on disk (code-review report + manualQa matrix).',
+    "- Only then spawn lazycodex-gate-reviewer (same fork settings), passing those artifact paths.",
     "- Require clean codeReview, manualQa, gateReview, iteration, and criteriaCoverage. criteriaCoverage must summarize originalIntent, desiredOutcome, and userOutcomeReview; counts alone are not approval.",
+    "- On a reviewer REJECT, fix only the cited blockers, rerun the affected verification/Manual-QA, and re-review the delta at most TWICE; if blockers remain, record them and surface to the user.",
+    "- If codeQualityStatus is WATCH, include the WATCH notes verbatim in your final user-facing message.",
     "- If any reviewer is blocked/inconclusive or the quality gate is not clean, do not call update_goal. Record blocker work first:",
     `  ${blockerCommand}`,
     aggregate ? '- If the quality gate is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint the aggregate story:' : '- If the quality gate is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint:',
@@ -1588,6 +1636,7 @@ async function createUlwLoopPlan(repoRoot, args, scope) {
     const goals = deriveGoalCandidates(args.brief).map((goal, index) => makeGoal(goal.title, goal.objective, index, now));
     const plan = {
       version: 1,
+      evidenceLayoutVersion: 2,
       createdAt: now,
       updatedAt: now,
       briefPath: ulwLoopBriefRelativePath(scope),
@@ -2087,9 +2136,16 @@ ledger: ${plan.ledgerPath}
 }
 async function status(repoRoot, json, scope) {
   const plan = await readUlwLoopPlan(repoRoot, scope);
-  if (json)
-    printJson({ ok: true, plan, summary: summarizeUlwLoopPlan(plan) });
-  else
+  if (json) {
+    const active = plan.goals.find((goal2) => goal2.id === plan.activeGoalId);
+    const currentAttemptDir = plan.evidenceLayoutVersion === 2 && active ? ulwLoopAttemptEvidenceDir(active.id, active.attempt, scope) : undefined;
+    printJson({
+      ok: true,
+      plan,
+      summary: summarizeUlwLoopPlan(plan),
+      ...currentAttemptDir === undefined ? {} : { currentAttemptDir }
+    });
+  } else
     printStatus(plan);
   return 0;
 }
@@ -2622,6 +2678,322 @@ function readAll(stdin) {
   });
 }
 
+// components/ulw-loop/src/spawn-guard.ts
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync3, statSync as statSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var SPAWN_TOOL_TOKENS = new Set(["spawn_agent", "collaborationspawn_agent", "collaboration.spawn_agent"]);
+var DEFAULT_FANOUT_LIMIT = 60;
+var GATE_MESSAGE_PATTERN = /lazycodex-gate-reviewer|final gate review/i;
+function applySpawnGuards(payload) {
+  if (payload.hook_event_name !== "PreToolUse" || !SPAWN_TOOL_TOKENS.has(payload.tool_name))
+    return "";
+  const stateDir = ulwLoopDir(payload.cwd, { sessionId: payload.session_id });
+  const plan = readPlan(join2(stateDir, "goals.json"));
+  if (plan === null)
+    return "";
+  const fanOutDenial = consumeFanOutBudget(stateDir);
+  if (fanOutDenial !== null)
+    return deny(fanOutDenial);
+  const missingArtifact = missingGateArtifact(payload, plan);
+  if (missingArtifact !== null)
+    return deny(`spawn code-review + QA first; gate audits their artifacts: missing ${missingArtifact}`);
+  return "";
+}
+async function runSpawnGuardCli(stdin, stdout) {
+  try {
+    const chunks = [];
+    for await (const chunk of stdin)
+      chunks.push(Buffer.from(chunk));
+    const payload = parsePreToolUsePayload(Buffer.concat(chunks).toString("utf8"));
+    if (payload === null)
+      return;
+    const output = applySpawnGuards(payload);
+    if (output.length > 0)
+      stdout.write(output);
+  } catch (error) {
+    if (error instanceof Error)
+      return;
+  }
+}
+function consumeFanOutBudget(stateDir) {
+  const counterPath = join2(stateDir, "spawn-count.json");
+  const count = readCount(counterPath) + 1;
+  writeFileSync(counterPath, JSON.stringify({ count }));
+  const limit = fanOutLimit();
+  if (count <= limit)
+    return null;
+  return `ulw-loop spawn fan-out cap reached (${count}/${limit}). Consolidate work into the agents already running, or raise OMO_SPAWN_FANOUT_LIMIT if this volume is intentional.`;
+}
+function missingGateArtifact(payload, plan) {
+  if (!isGateReviewerSpawn(payload.tool_input))
+    return null;
+  const goal2 = plan.goals.find((candidate) => isFinalRunCompletionCandidate(plan, candidate));
+  if (goal2 === undefined || goal2.status === "complete")
+    return null;
+  if (!goal2.successCriteria.every((criterion) => criterion.status === "pass"))
+    return null;
+  const scope = { sessionId: payload.session_id };
+  if (plan.evidenceLayoutVersion === 2) {
+    const attemptDir = ulwLoopAttemptEvidenceDir(goal2.id, goal2.attempt, scope);
+    for (const name of [`${goal2.id}-code-review.md`, `${goal2.id}-manual-qa.md`]) {
+      const relative2 = `${attemptDir}/${name}`;
+      if (!isNonEmptyFile(join2(payload.cwd, relative2)))
+        return relative2;
+    }
+    return null;
+  }
+  const flatReport = `.omo/evidence/${goal2.id}-code-review.md`;
+  if (!isNonEmptyFile(join2(payload.cwd, flatReport)))
+    return flatReport;
+  if (!hasOtherEvidenceFile(join2(payload.cwd, ".omo", "evidence"), `${goal2.id}-code-review.md`))
+    return `.omo/evidence/<any manual-QA artifact besides ${goal2.id}-code-review.md>`;
+  return null;
+}
+function isGateReviewerSpawn(toolInput) {
+  if (typeof toolInput !== "object" || toolInput === null)
+    return false;
+  const record = toolInput;
+  const agentType = record["agent_type"];
+  if (typeof agentType === "string")
+    return agentType === "lazycodex-gate-reviewer";
+  const message = record["message"];
+  return typeof message === "string" && GATE_MESSAGE_PATTERN.test(message);
+}
+function deny(reason) {
+  return `${JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason,
+      additionalContext: reason
+    }
+  })}
+`;
+}
+function fanOutLimit() {
+  const raw = process.env["OMO_SPAWN_FANOUT_LIMIT"];
+  if (raw === undefined)
+    return DEFAULT_FANOUT_LIMIT;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_FANOUT_LIMIT;
+}
+function isNonEmptyFile(path) {
+  try {
+    return existsSync6(path) && statSync2(path).size > 0;
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function hasOtherEvidenceFile(evidenceDir, excludedName) {
+  try {
+    return readdirSync(evidenceDir).some((name) => name !== excludedName && isNonEmptyFile(join2(evidenceDir, name)));
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function readCount(counterPath) {
+  try {
+    const parsed = JSON.parse(readFileSync3(counterPath, "utf8"));
+    return typeof parsed["count"] === "number" && parsed["count"] >= 0 ? parsed["count"] : 0;
+  } catch (error) {
+    if (error instanceof Error)
+      return 0;
+    throw error;
+  }
+}
+function readPlan(goalsPath) {
+  try {
+    return JSON.parse(readFileSync3(goalsPath, "utf8"));
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+
+// components/ulw-loop/src/stop-resume-hook.ts
+import { existsSync as existsSync7, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join3 } from "node:path";
+var RESUME_CAP = 2;
+var CONTEXT_PRESSURE_MARKERS2 = [
+  "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 runStopResumeHook(input) {
+  const payload = parseStopPayload(input);
+  if (payload === null || payload.stop_hook_active)
+    return "";
+  if (transcriptShowsContextPressure(payload.transcript_path))
+    return "";
+  if (boulderContinuationWillFire(payload.cwd, payload.session_id))
+    return "";
+  const stateDir = ulwLoopDir(payload.cwd, { sessionId: payload.session_id });
+  const plan = readPlan2(join3(stateDir, "goals.json"));
+  if (plan === null || plan.aggregateCompletion?.status === "complete")
+    return "";
+  const goal2 = resumableGoal(plan);
+  if (goal2 === undefined)
+    return "";
+  if (!consumeResumeBudget(stateDir, goal2.id))
+    return "";
+  const output = {
+    decision: "block",
+    reason: renderResumeDirective(plan, goal2, payload.session_id)
+  };
+  return JSON.stringify(output);
+}
+async function runStopResumeHookCli(stdin, stdout) {
+  try {
+    const chunks = [];
+    for await (const chunk of stdin)
+      chunks.push(Buffer.from(chunk));
+    const output = runStopResumeHook(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+    if (output.length > 0)
+      stdout.write(output);
+  } catch (error) {
+    if (error instanceof Error)
+      return;
+  }
+}
+function resumableGoal(plan) {
+  const active = plan.goals.find((goal2) => goal2.id === plan.activeGoalId);
+  if (active !== undefined && isResumableStatus(active.status))
+    return active;
+  return plan.goals.find((goal2) => isResumableStatus(goal2.status));
+}
+function isResumableStatus(status2) {
+  return status2 === "pending" || status2 === "in_progress";
+}
+function consumeResumeBudget(stateDir, goalId) {
+  const ledgerLineCount = countLedgerLines(join3(stateDir, "ledger.jsonl"));
+  const counterPath = join3(stateDir, `auto-resume-${goalId}.json`);
+  const previous = readCounter(counterPath);
+  const count = previous !== null && previous.ledgerLineCount === ledgerLineCount ? previous.count : 0;
+  if (count >= RESUME_CAP) {
+    writeFileSync2(join3(stateDir, `auto-resume-${goalId}.stuck`), `no ledger progress after ${count} resumes
+`);
+    return false;
+  }
+  writeFileSync2(counterPath, JSON.stringify({ count: count + 1, ledgerLineCount }));
+  return true;
+}
+function renderResumeDirective(plan, goal2, sessionId) {
+  const normalized = normalizeUlwLoopSessionId(sessionId);
+  const option = normalized !== null && plan.goalsPath.includes(`/${normalized}/`) ? ` --session-id ${normalized}` : "";
+  return [
+    `The ulw-loop run in this session still has unfinished goals (next: ${goal2.id} — ${goal2.title}).`,
+    "The turn ended before the loop completed. Resume it now:",
+    `1. Run \`omo ulw-loop status${option} --json\` to reload the plan, the active goal, and currentAttemptDir.`,
+    "2. Continue the active goal's remaining success criteria, recording evidence with record-evidence.",
+    `3. Checkpoint through \`omo ulw-loop checkpoint${option}\` when the goal's criteria are proven.`,
+    "If the loop is genuinely blocked on the user, checkpoint the goal as blocked with the reason instead."
+  ].join(`
+`);
+}
+function readPlan2(goalsPath) {
+  try {
+    return JSON.parse(readFileSync4(goalsPath, "utf8"));
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+function countLedgerLines(ledgerPath) {
+  try {
+    return readFileSync4(ledgerPath, "utf8").split(`
+`).filter(Boolean).length;
+  } catch (error) {
+    if (error instanceof Error)
+      return 0;
+    throw error;
+  }
+}
+function readCounter(counterPath) {
+  try {
+    if (!existsSync7(counterPath))
+      return null;
+    const parsed = JSON.parse(readFileSync4(counterPath, "utf8"));
+    if (typeof parsed["count"] !== "number" || typeof parsed["ledgerLineCount"] !== "number")
+      return null;
+    return { count: parsed["count"], ledgerLineCount: parsed["ledgerLineCount"] };
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
+}
+function boulderContinuationWillFire(cwd, sessionId) {
+  try {
+    const raw = JSON.parse(readFileSync4(join3(cwd, ".omo", "boulder.json"), "utf8"));
+    const works = raw["works"];
+    const entries = typeof works === "object" && works !== null ? Object.values(works) : [raw];
+    return entries.some((work) => {
+      if (typeof work !== "object" || work === null)
+        return false;
+      const entry = work;
+      const sessionIds = Array.isArray(entry["session_ids"]) ? entry["session_ids"] : [];
+      const continuable = entry["status"] === "active" || entry["status"] === "paused";
+      return continuable && sessionIds.includes(`codex:${sessionId}`) && boulderPlanHasRemainingTask(cwd, entry);
+    });
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function transcriptShowsContextPressure(transcriptPath) {
+  try {
+    const transcript = readFileSync4(transcriptPath, "utf8").toLowerCase();
+    return CONTEXT_PRESSURE_MARKERS2.some((marker) => transcript.includes(marker));
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function boulderPlanHasRemainingTask(cwd, entry) {
+  const activePlan = entry["active_plan"];
+  if (typeof activePlan !== "string" || activePlan.trim().length === 0)
+    return false;
+  const planPath = isAbsolute2(activePlan) ? activePlan : join3(cwd, activePlan);
+  const worktree = entry["worktree_path"];
+  const candidates = typeof worktree === "string" && worktree.trim().length > 0 && !isAbsolute2(activePlan) ? [join3(isAbsolute2(worktree) ? worktree : join3(cwd, worktree), activePlan), planPath] : [planPath];
+  for (const candidate of candidates) {
+    try {
+      return readFileSync4(candidate, "utf8").split(/\r?\n/).some((line) => line.startsWith("- [ ] "));
+    } catch (error) {
+      if (!(error instanceof Error))
+        throw error;
+    }
+  }
+  return false;
+}
+function parseStopPayload(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  const record = value;
+  const optionalMessage = record["last_assistant_message"];
+  const valid = record["hook_event_name"] === "Stop" && typeof record["session_id"] === "string" && typeof record["turn_id"] === "string" && typeof record["transcript_path"] === "string" && typeof record["cwd"] === "string" && typeof record["model"] === "string" && typeof record["permission_mode"] === "string" && typeof record["stop_hook_active"] === "boolean" && (optionalMessage === undefined || typeof optionalMessage === "string");
+  if (!valid)
+    return null;
+  return {
+    session_id: record["session_id"],
+    cwd: record["cwd"],
+    transcript_path: record["transcript_path"],
+    stop_hook_active: record["stop_hook_active"]
+  };
+}
+
 // components/ulw-loop/src/cli.ts
 var TOP_LEVEL_HELP = `Usage:
   omo ulw-loop <subcommand> [args]
@@ -2651,6 +3023,14 @@ async function main() {
       await runPreToolUseGoalBudgetGuardCli(process.stdin, process.stdout);
       return 0;
     }
+    if (sub === "stop") {
+      await runStopResumeHookCli(process.stdin, process.stdout);
+      return 0;
+    }
+    if (sub === "pre-tool-use-spawn") {
+      await runSpawnGuardCli(process.stdin, process.stdout);
+      return 0;
+    }
     process.stderr.write(`[omo] unknown hook subcommand: ${sub ?? "(none)"}
 `);
     return 1;

package/packages/omo-codex/plugin/components/ulw-loop/dist/codex-goal-instruction.js

@@ -24,6 +24,7 @@ function buildText(mode, plan, goal, createGoal, isFinal) {
         "- Use the create_goal payload exactly as rendered: objective only.",
         "- Goals are unlimited. Do not add numeric limits.",
         ...modeConstraintLines(mode, isFinal),
+        ...evidenceLayoutLines(plan),
         finalSection(plan, goal, isFinal, mode === "aggregate"),
         ...checkpointLines(plan, mode),
         "",
@@ -71,6 +72,13 @@ function formatCriterionLine(criterion) {
     const marker = isEssentialCriterion(criterion) ? "essential" : "non-essential";
     return `-${remainingWork} [${criterion.id}] [${marker}] (${criterion.userModel}) ${criterion.scenario} — expect: ${criterion.expectedEvidence} — status: ${criterion.status}`;
 }
+function evidenceLayoutLines(plan) {
+    if (plan.evidenceLayoutVersion !== 2)
+        return [];
+    return [
+        "- Evidence layout v2: write every artifact for the active goal (QA matrix, review reports, receipts) under the current attempt directory — read currentAttemptDir from `omo ulw-loop status --json` (.omo/evidence/ulw/<session>/<goalId>/a<attempt>). The final checkpoint rejects quality-gate artifacts outside that directory.",
+    ];
+}
 function finalSection(plan, goal, isFinal, aggregate) {
     if (!isFinal)
         return "- This is not the final ulw-loop story; do not run the final reviewer/manual-QA/gate-review quality gate yet.";
@@ -81,8 +89,11 @@ function finalSection(plan, goal, isFinal, aggregate) {
         "Final story — run mandatory quality gate before update_goal:",
         "- Run targeted verification for changed behavior.",
         "- Confirm every manualQa artifact path exists and has non-zero size.",
-        "- Spawn final reviewers with fork_context=false: lazycodex-code-reviewer, lazycodex-qa-executor, and lazycodex-gate-reviewer. Include the original brief, goal objectives, desired user-visible outcome, diff, and evidence.",
+        "- First spawn lazycodex-code-reviewer and lazycodex-qa-executor in parallel (fork_context: false on the v1 surface; fork_turns: \"none\" on v2). Include the original brief, goal objectives, desired user-visible outcome, diff, and evidence; wait for BOTH to return and confirm their report artifacts exist on disk (code-review report + manualQa matrix).",
+        "- Only then spawn lazycodex-gate-reviewer (same fork settings), passing those artifact paths.",
         "- Require clean codeReview, manualQa, gateReview, iteration, and criteriaCoverage. criteriaCoverage must summarize originalIntent, desiredOutcome, and userOutcomeReview; counts alone are not approval.",
+        "- On a reviewer REJECT, fix only the cited blockers, rerun the affected verification/Manual-QA, and re-review the delta at most TWICE; if blockers remain, record them and surface to the user.",
+        "- If codeQualityStatus is WATCH, include the WATCH notes verbatim in your final user-facing message.",
         "- If any reviewer is blocked/inconclusive or the quality gate is not clean, do not call update_goal. Record blocker work first:",
         `  ${blockerCommand}`,
         aggregate