oh-my-opencode 5.0.0-beta.8 → 5.0.0-beta.81

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

@@ -1,21 +1,145 @@
 #!/usr/bin/env node
 
-// packages/omo-codex/plugin/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.ts
+import { existsSync as existsSync5, statSync as statSync2 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { resolve as resolve4 } from "node:path";
 
-// packages/omo-codex/plugin/components/ulw-loop/src/checkpoint-reconciliation.ts
+// components/ulw-loop/src/codex-goal-snapshot.ts
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+class CodexGoalSnapshotError extends Error {
+}
+function safeObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function safeString(value) {
+  return typeof value === "string" ? value : "";
+}
+function safeStatusString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function normalizeStatus(value) {
+  const status = safeStatusString(value).toLowerCase();
+  if (status === "complete" || status === "completed" || status === "done")
+    return "complete";
+  if (status === "cancelled" || status === "canceled")
+    return "cancelled";
+  if (status === "failed" || status === "failure")
+    return "failed";
+  if (status === "paused")
+    return "paused";
+  if (status === "usage_limited")
+    return "usage_limited";
+  if (status === "budget_limited")
+    return "budget_limited";
+  if (status === "active" || status === "in_progress" || status === "pending" || status === "running")
+    return "active";
+  return "unknown";
+}
+function normalizeObjective(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function parseCodexGoalSnapshot(value) {
+  const root = safeObject(value);
+  const goalValue = Object.hasOwn(root, "goal") ? root["goal"] : value;
+  if (goalValue === null || goalValue === undefined || goalValue === false) {
+    return { available: false, raw: value };
+  }
+  const goal = safeObject(goalValue);
+  const objective = safeString(goal["objective"] ?? goal["goal"] ?? goal["description"] ?? goal["title"] ?? root["objective"] ?? root["title"]);
+  const status = normalizeStatus(goal["status"] ?? root["status"]);
+  return {
+    available: Boolean(objective || status !== "unknown"),
+    ...objective ? { objective } : {},
+    status,
+    raw: value
+  };
+}
+async function readCodexGoalSnapshotInput(raw, cwd = process.cwd()) {
+  if (!raw?.trim())
+    return null;
+  const trimmed = raw.trim();
+  try {
+    return parseCodexGoalSnapshot(JSON.parse(trimmed));
+  } catch {
+    const path = resolve(cwd, trimmed);
+    if (!existsSync(path)) {
+      throw new CodexGoalSnapshotError(`Codex goal snapshot is neither valid JSON nor a readable path: ${trimmed}`);
+    }
+    try {
+      return parseCodexGoalSnapshot(JSON.parse(await readFile(path, "utf-8")));
+    } catch (error) {
+      throw new CodexGoalSnapshotError(`Codex goal snapshot path does not contain valid JSON: ${trimmed}${error instanceof Error ? ` (${error.message})` : ""}`);
+    }
+  }
+}
+function reconcileCodexGoalSnapshot(snapshot, options) {
+  const effectiveSnapshot = snapshot ?? { available: false, raw: null };
+  const errors = [];
+  const warnings = [];
+  const nextActions = [];
+  const expected = options.expectedObjective;
+  if (!effectiveSnapshot.available) {
+    nextActions.push(`call get_goal; if none, create_goal with codexObjective "${expected}" verbatim`);
+    return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, nextActions, errors };
+  }
+  const normalized = (objectives) => new Set(objectives.map(normalizeObjective).filter(Boolean));
+  const accepted = normalized([expected, ...options.acceptedObjectives ?? []]);
+  const acknowledged = normalized(options.acknowledgedObjectives ?? []);
+  const actual = normalizeObjective(effectiveSnapshot.objective ?? "");
+  let unacknowledgedObjective;
+  if (actual && !accepted.has(actual) && !acknowledged.has(actual)) {
+    warnings.push(`driver_objective_differs: expected "${expected}", got "${actual}".`);
+    unacknowledgedObjective = actual;
+  }
+  const actualStatus = effectiveSnapshot.status ?? "unknown";
+  if (actualStatus === "paused" || actualStatus === "usage_limited" || actualStatus === "budget_limited") {
+    nextActions.push("/goal resume or raise the budget");
+  }
+  if (actualStatus === "complete")
+    nextActions.push(`driver closed early: call create_goal with codexObjective "${expected}" verbatim`);
+  return {
+    ok: errors.length === 0,
+    snapshot: effectiveSnapshot,
+    warnings,
+    nextActions,
+    errors,
+    ...unacknowledgedObjective === undefined ? {} : { unacknowledgedObjective }
+  };
+}
+function formatCodexGoalReconciliation(reconciliation) {
+  const parts = [...reconciliation.errors, ...reconciliation.nextActions, ...reconciliation.warnings];
+  return parts.join(" ");
+}
+
+// components/ulw-loop/src/driver-objective-ack.ts
+function normalizeDriverObjective(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function acknowledgedDriverObjectives(plan) {
+  return plan.acknowledgedDriverObjectives ?? [];
+}
+function acknowledgeDriverObjective(plan, objective) {
+  if (objective === undefined)
+    return false;
+  const normalized = normalizeDriverObjective(objective);
+  if (!normalized || acknowledgedDriverObjectives(plan).includes(normalized))
+    return false;
+  plan.acknowledgedDriverObjectives = [...acknowledgedDriverObjectives(plan), normalized];
+  return true;
+}
 
-// packages/omo-codex/plugin/components/ulw-loop/src/paths.ts
+// components/ulw-loop/src/paths.ts
 import { isAbsolute, join, relative, sep } from "node:path";
-// packages/omo-codex/plugin/components/ulw-loop/src/constants.ts
+// components/ulw-loop/src/constants.ts
 var ULW_LOOP_DIR = ".omo/ulw-loop";
 var ULW_LOOP_BRIEF = "brief.md";
 var ULW_LOOP_GOALS = "goals.json";
 var ULW_LOOP_LEDGER = "ledger.jsonl";
+var ULW_LOOP_STATE_LOCK = ".state.lock";
 var ULW_LOOP_STEERING_MUTATION_KINDS = [
   "add_subgoal",
   "split_subgoal",
@@ -31,10 +155,8 @@ var ULW_LOOP_SUCCESS_CRITERION_USER_MODELS = [
   "regression",
   "adversarial"
 ];
-// packages/omo-codex/plugin/components/ulw-loop/src/runtime.ts
+// components/ulw-loop/src/runtime.ts
 class UlwLoopError extends Error {
-  code;
-  details;
   constructor(message, code, opts) {
     super(message, opts?.cause === undefined ? undefined : { cause: opts.cause });
     this.name = "UlwLoopError";
@@ -47,8 +169,8 @@ class UlwLoopError extends Error {
 function iso() {
   return new Date().toISOString();
 }
-// packages/omo-codex/plugin/components/ulw-loop/src/paths.ts
-var SESSION_ENV_KEYS = ["OMO_ULW_LOOP_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID"];
+// components/ulw-loop/src/paths.ts
+var SESSION_ENV_KEYS = ["OMO_ULW_LOOP_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "PI_SESSION_ID"];
 function normalizeUlwLoopSessionId(sessionId) {
   const trimmed = sessionId?.trim();
   if (!trimmed)
@@ -81,14 +203,11 @@ function ulwLoopGoalsRelativePath(scope) {
 function ulwLoopLedgerRelativePath(scope) {
   return `${ulwLoopRelativeDir(scope)}/${ULW_LOOP_LEDGER}`;
 }
-function ulwLoopBriefPath(repoRoot, scope) {
-  return join(ulwLoopDir(repoRoot, scope), ULW_LOOP_BRIEF);
-}
 function ulwLoopGoalsPath(repoRoot, scope) {
   return join(ulwLoopDir(repoRoot, scope), ULW_LOOP_GOALS);
 }
-function ulwLoopLedgerPath(repoRoot, scope) {
-  return join(ulwLoopDir(repoRoot, scope), ULW_LOOP_LEDGER);
+function ulwLoopStateLockPath(repoRoot, scope) {
+  return join(ulwLoopDir(repoRoot, scope), ULW_LOOP_STATE_LOCK);
 }
 function repoRelative(absolutePath, repoRoot) {
   const slashPrefix = `${repoRoot}/`;
@@ -99,8 +218,15 @@ function repoRelative(absolutePath, repoRoot) {
     return absolutePath.slice(backslashPrefix.length).split("\\").join("/");
   return absolutePath.split("\\").join("/");
 }
+function ulwLoopEvidenceRoot(scope) {
+  const sessionId = normalizeUlwLoopSessionId(scope?.sessionId);
+  return sessionId === null ? ".omo/evidence" : `.omo/evidence/ulw/${sessionId}`;
+}
 function ulwLoopAttemptEvidenceDir(goalId, attempt, scope) {
-  const sessionId = normalizeUlwLoopSessionId(scope?.sessionId) ?? resolveUlwLoopSessionIdFromEnv() ?? "session";
+  const sessionId = normalizeUlwLoopSessionId(scope?.sessionId);
+  if (sessionId === null) {
+    throw new UlwLoopError(`Evidence for ${goalId} attempt ${attempt} needs a session scope; pass --session-id <id> so the attempt directory lives under .omo/evidence/ulw/<id>/.`, "ULW_LOOP_SESSION_SCOPE_REQUIRED", { details: { goalId, attempt } });
+  }
   return `.omo/evidence/ulw/${sessionId}/${goalId}/a${attempt}`;
 }
 var PLATFORM_PATH_API = { relative, isAbsolute, sep };
@@ -113,7 +239,7 @@ function isWithinAttemptDir(absolutePath, attemptRoot, pathApi = PLATFORM_PATH_A
   return !pathApi.isAbsolute(relativePath);
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/goal-status.ts
+// components/ulw-loop/src/goal-status.ts
 var ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE = aggregateCodexObjectiveForScope();
 function aggregateCodexObjectiveForScope(scope) {
   return `Complete the durable ulw-loop plan in ${ulwLoopGoalsRelativePath(scope)}, including later accepted/appended stories, under the original brief constraints; use ${ulwLoopLedgerRelativePath(scope)} as the audit trail.`;
@@ -196,198 +322,553 @@ function hasEssentialCriteriaPass(goal) {
   return criteria.length > 0 && criteria.every((criterion) => criterion.status === "pass");
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/checkpoint-reconciliation.ts
-function normalizeObjective(value) {
-  return value.replace(/\s+/g, " ").trim();
+// components/ulw-loop/src/checkpoint-codex-validation.ts
+async function validateCheckpointCodexGoal(input) {
+  const snapshot = await readCodexGoalSnapshotInput(input.raw, input.repoRoot);
+  const expected = expectedCodexObjective(input.plan, input.goal);
+  const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
+    expectedObjective: expected,
+    acknowledgedObjectives: acknowledgedDriverObjectives(input.plan),
+    ...codexGoalMode(input.plan) === "aggregate" ? { acceptedObjectives: compatibleCodexObjectives(input.plan) } : {}
+  });
+  if (!reconciliation.ok)
+    throw new CodexGoalSnapshotError(formatCodexGoalReconciliation(reconciliation));
+  return {
+    raw: snapshot?.raw,
+    nextActions: reconciliation.nextActions,
+    warnings: reconciliation.warnings,
+    ...reconciliation.unacknowledgedObjective === undefined ? {} : { unacknowledgedObjective: reconciliation.unacknowledgedObjective }
+  };
 }
-function textMentionsUlwLoopPlanArtifact(value) {
-  const normalized = (value ?? "").toLowerCase();
-  return normalized.includes(ULW_LOOP_DIR.toLowerCase()) || normalized.includes(ULW_LOOP_GOALS.toLowerCase()) || normalized.includes(ULW_LOOP_LEDGER.toLowerCase());
+function combineCheckpointValidationErrors(codexError, gateError) {
+  return new UlwLoopError(`${codexError.message}
+${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
+    details: { ...codexError.details ?? {}, ...gateError.details ?? {} }
+  });
 }
-function textMentionsGoalId(value, goalId) {
-  return (value ?? "").toLowerCase().includes(goalId.toLowerCase());
+
+// components/ulw-loop/src/evidence-artifacts.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+function fail(message, code, details) {
+  throw new UlwLoopError(message, code, { details });
 }
-function textHasCompletionValidationEvidence(value) {
-  const normalized = (value ?? "").toLowerCase();
-  const done = /\b(?:planned work|implementation|deliverables?|scope|task|work)\b/.test(normalized) && /\b(?:done|complete|completed|finished|shipped)\b/.test(normalized);
-  const verified = /\b(?:validation|verification|tests?|build|lint|review|quality gate|code-review)\b/.test(normalized) && /\b(?:passed|complete|completed|clean|green|approve|approved|clear)\b/.test(normalized);
-  return done && verified;
+function stored(repoRoot, absolute) {
+  const rel = relative2(repoRoot, absolute);
+  const inside = rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
+  return inside ? rel.split(sep2).join("/") : absolute;
 }
-async function snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope) {
-  const actual = normalizeObjective(snapshotObjective).toLowerCase();
-  if (textMentionsUlwLoopPlanArtifact(actual))
-    return true;
-  if (actual.length < 24 || !existsSync(ulwLoopBriefPath(repoRoot, scope)))
-    return false;
+function resolveEvidenceArtifacts(repoRoot, artifacts) {
+  if (artifacts === undefined)
+    return;
+  const seen = new Set;
+  const resolved = [];
+  for (const [index, candidate] of artifacts.entries()) {
+    const path = typeof candidate === "string" ? candidate.trim() : "";
+    if (!path)
+      fail(`Artifact ${index + 1} must be a non-empty path.`, "ULW_LOOP_ARGUMENT_INVALID", { index });
+    const absolute = resolve2(repoRoot, path);
+    if (!existsSync2(absolute))
+      fail(`Evidence artifact does not exist: ${path} (resolved to ${absolute}).`, "ULW_LOOP_EVIDENCE_ARTIFACT_MISSING", {
+        path,
+        resolved: absolute
+      });
+    const value = stored(repoRoot, absolute);
+    if (!seen.has(value)) {
+      seen.add(value);
+      resolved.push(value);
+    }
+  }
+  return resolved;
+}
+
+// components/ulw-loop/src/plan-commit.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { linkSync, mkdirSync as mkdirSync2, renameSync, rmSync, writeFileSync } from "node:fs";
+import { rename, writeFile } from "node:fs/promises";
+import { join as join4 } from "node:path";
+
+// components/ulw-loop/src/ledger.ts
+import { join as join3 } from "node:path";
+
+// components/ulw-loop/src/plan-log.ts
+import { existsSync as existsSync3, readdirSync, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+function hasCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+function readOptional(path) {
   try {
-    const brief = normalizeObjective(await readFile(ulwLoopBriefPath(repoRoot, scope), "utf8")).toLowerCase();
-    return brief.length >= 24 && (brief.includes(actual) || actual.includes(brief));
+    return readFileSync(path, "utf8");
   } catch (error) {
-    if (error instanceof Error)
-      return false;
+    if (hasCode(error, "ENOENT"))
+      return;
     throw error;
   }
 }
-async function canReconcileCompletedTaskScopedAggregateSnapshot(repoRoot, plan, goal, snapshotObjective, evidence, scope) {
-  if (codexGoalMode(plan) !== "aggregate")
-    return false;
-  if (goal.status !== "in_progress" || plan.activeGoalId !== goal.id)
-    return false;
-  if (isFinalRunCompletionCandidate(plan, goal)) {
-    return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
+function logNames(dir) {
+  try {
+    return readdirSync(join2(dir, "revisions")).filter((name) => /^\d{8,}\.json$/.test(name)).sort();
+  } catch (error) {
+    if (hasCode(error, "ENOENT"))
+      return [];
+    throw error;
   }
-  if (!textMentionsUlwLoopPlanArtifact(evidence) || !textMentionsGoalId(evidence, goal.id))
-    return false;
-  if (!textHasCompletionValidationEvidence(evidence))
-    return false;
-  return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
 }
-async function canReconcileActiveFinalTaskScopedAggregateSnapshot(repoRoot, plan, goal, snapshotObjective, evidence, scope) {
-  if (codexGoalMode(plan) !== "aggregate")
-    return false;
-  if (goal.status !== "in_progress" || plan.activeGoalId !== goal.id)
-    return false;
-  if (!isFinalRunCompletionCandidate(plan, goal))
-    return false;
-  if (!textHasCompletionValidationEvidence(evidence))
-    return false;
-  return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
+function readRecord(dir, name) {
+  try {
+    const record = JSON.parse(readFileSync(join2(dir, "revisions", name), "utf8"));
+    return record.version === 1 && Number.isInteger(record.revision) && record.plan?.version === 1 && Array.isArray(record.plan.goals) && Array.isArray(record.ledger) ? record : undefined;
+  } catch (error) {
+    if (!(error instanceof SyntaxError))
+      throw error;
+    return;
+  }
 }
-function buildCompletedLegacyGoalRemediation(goal) {
-  return [
-    "If get_goal returns a different completed legacy/thread objective, do not repeat --status complete in this thread.",
-    `Record a non-terminal blocker with: omo-agent-toolkit ulw-loop checkpoint --goal-id ${goal.id} --status blocked --evidence "<completed legacy Codex goal blocks create_goal in this thread>" --codex-goal-json "<different completed get_goal JSON or path>".`,
-    "Then continue only from a Codex goal context with no active/completed conflicting goal, in the same repo/worktree, and create the intended goal there."
-  ].join(" ");
+function readRecords(dir) {
+  const records = [];
+  for (const name of logNames(dir)) {
+    const record = readRecord(dir, name);
+    if (record !== undefined)
+      records.push(record);
+  }
+  return records.sort((a, b) => a.revision - b.revision);
+}
+function readNewestRecord(dir) {
+  const names = logNames(dir).sort((a, b) => Number.parseInt(b, 10) - Number.parseInt(a, 10));
+  for (const name of names) {
+    const record = readRecord(dir, name);
+    if (record !== undefined)
+      return record;
+  }
+  return;
 }
-function buildTaskScopedAggregateReconciliationHint(goal, final) {
-  if (final) {
-    return ` Final task-scoped aggregate reconciliation requires the checkpoint goal to be the active in-progress final OMO goal and the completed get_goal objective to map to the ulw-loop brief or artifact. ${buildCompletedLegacyGoalRemediation(goal)}`;
+function reconcilePlan(dir) {
+  const raw = readOptional(join2(dir, "goals.json"));
+  let cached;
+  if (raw !== undefined) {
+    try {
+      cached = JSON.parse(raw);
+    } catch (error) {
+      if (!(error instanceof SyntaxError))
+        throw error;
+    }
+  }
+  const latest = readNewestRecord(dir);
+  if (latest === undefined)
+    return cached;
+  if (cached === undefined)
+    return latest.plan;
+  if ((cached.revision ?? 0) > latest.revision)
+    return cached;
+  if (cached.revision === undefined || cached.revision === latest.revision) {
+    const published = new Set(latest.plan.goals.map((goal) => goal.id));
+    if (Array.isArray(cached.goals) && cached.goals.some((goal) => !published.has(goal.id)))
+      return { ...cached, revision: latest.revision };
   }
-  return ` Completed task-scoped aggregate reconciliation requires the checkpoint goal to be the active in-progress OMO goal, evidence that names that active OMO goal id, names .omo/ulw-loop/goals.json or ledger.jsonl, includes completed implementation plus validation/review evidence, and a get_goal objective that maps to the ulw-loop brief/artifact. ${buildCompletedLegacyGoalRemediation(goal)}`;
+  return latest.plan;
+}
+function assertProjectionComplete(plan, ledger) {
+  const present = new Set(plan.goals.map((goal) => goal.id));
+  const missing = new Set;
+  for (const entry of ledger)
+    if (entry.kind === "goal_added" && entry.goalId !== undefined && !present.has(entry.goalId))
+      missing.add(entry.goalId);
+  if (missing.size === 0)
+    return;
+  throw new UlwLoopError(`Refusing to rewrite goals.json: the ledger records goals the plan projection lacks (${[...missing].join(", ")}). Restore those goals into the newest revisions/ record (keeping plan.revision equal to its file number) before mutating this run.`, "ULW_LOOP_PROJECTION_TRUNCATED", { details: { missingGoalIds: [...missing] } });
+}
+function planExists(repoRoot, scope) {
+  const dir = ulwLoopDir(repoRoot, scope);
+  return existsSync3(join2(dir, "goals.json")) || logNames(dir).length > 0;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/codex-goal-snapshot.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { readFile as readFile2 } from "node:fs/promises";
-import { resolve } from "node:path";
-
-class CodexGoalSnapshotError extends Error {
+// components/ulw-loop/src/ledger.ts
+function readLedgerAt(dir) {
+  const entries = new Map;
+  const lines = (readOptional(join3(dir, "ledger.jsonl")) ?? "").split(/\r?\n/);
+  let reached = 0;
+  for (const [index, line] of lines.entries()) {
+    if (line.trim().length === 0)
+      continue;
+    try {
+      const entry = JSON.parse(line);
+      entry.revision = entry.revision || reached;
+      reached = Math.max(reached, entry.revision);
+      entry.id ??= `legacy-${index + 1}`;
+      entries.set(entry.id, entry);
+    } catch (error) {
+      if (!(error instanceof SyntaxError))
+        throw error;
+    }
+  }
+  for (const record of readRecords(dir))
+    for (const [seq, entry] of record.ledger.entries()) {
+      const id = entry.id ?? `${record.revision}-${seq}`;
+      entries.set(id, { ...entry, revision: record.revision, id });
+    }
+  const reset = reconcilePlan(dir)?.ledgerResetRevision ?? 0;
+  const sequence = (entry) => Number(entry.id?.split("-").at(-1) ?? 0);
+  return [...entries.values()].filter((entry) => (entry.revision ?? 0) >= reset).sort((a, b) => (a.revision ?? 0) - (b.revision ?? 0) || sequence(a) - sequence(b));
 }
-function safeObject(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+function readLedger(repoRoot, scope) {
+  return readLedgerAt(ulwLoopDir(repoRoot, scope));
 }
-function safeString(value) {
-  return typeof value === "string" ? value.trim() : "";
+
+// components/ulw-loop/src/plan-io.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { readdirSync as readdirSync2 } from "node:fs";
+
+// components/ulw-loop/src/plan-missing-recovery.ts
+var ULW_LOOP_CREATE_GOALS_COMMAND = 'omo-agent-toolkit ulw-loop create-goals --brief "<brief>" --json';
+function createGoalsAction(surface) {
+  return surface === "omo-senpi" ? 'agentToolkit.createGoals({ brief: "<brief>" })' : ULW_LOOP_CREATE_GOALS_COMMAND;
+}
+function planMissingRecovery(existingSessionIds, surface = "lazycodex") {
+  const lines = [`Recovery: bootstrap the plan with \`${createGoalsAction(surface)}\`.`];
+  if (existingSessionIds.length === 0)
+    return { message: lines.join(`
+`) };
+  lines.push(surface === "omo-senpi" ? `Existing ulw-loop session ids under .omo/ulw-loop/: ${existingSessionIds.join(", ")}. The SDK is bound to the current session; resume the owning session to target its plan.` : `Existing ulw-loop session ids under .omo/ulw-loop/: ${existingSessionIds.join(", ")}. Re-run with \`--session-id <id>\` to target one of them.`);
+  return { message: lines.join(`
+`), details: { existingSessionIds } };
+}
+function planMissingError(planPath, existingSessionIds, surface = "lazycodex") {
+  const recovery = planMissingRecovery(existingSessionIds, surface);
+  return new UlwLoopError(`No ulw-loop plan found at ${planPath}.
+${recovery.message}`, "ULW_LOOP_PLAN_MISSING", {
+    ...recovery.details === undefined ? {} : { details: recovery.details }
+  });
 }
-function normalizeStatus(value) {
-  const status = safeString(value).toLowerCase();
-  if (status === "complete" || status === "completed" || status === "done")
-    return "complete";
-  if (status === "cancelled" || status === "canceled")
-    return "cancelled";
-  if (status === "failed" || status === "failure")
-    return "failed";
-  if (status === "active" || status === "in_progress" || status === "pending" || status === "running")
-    return "active";
-  return "unknown";
+function sessionScopeRequiredMessage(flag, existingSessionIds) {
+  const lines = [
+    "No ulw-loop session scope: neither the session env (OMO_ULW_LOOP_SESSION_ID / CODEX_SESSION_ID / CODEX_THREAD_ID / PI_SESSION_ID) nor the flag names this run, and the shared .omo/ulw-loop root is never used implicitly because every session in this directory would read and overwrite it.",
+    `Recovery: pass the scope explicitly: \`${flag} <id>\` (subprocess, eval, and hook contexts do not inherit the session env).`
+  ];
+  if (existingSessionIds.length > 0) {
+    lines.push(`Existing ulw-loop session ids under .omo/ulw-loop/: ${existingSessionIds.join(", ")}.`);
+  }
+  return lines.join(`
+`);
 }
-function normalizeObjective2(value) {
-  return value.replace(/\s+/g, " ").trim();
+function sessionIdRequiredMessage(flag) {
+  return [
+    `${flag} requires a non-empty value.`,
+    "Recovery: subprocess, eval, and hook contexts do not inherit the ulw-loop session env (OMO_ULW_LOOP_SESSION_ID / CODEX_SESSION_ID / CODEX_THREAD_ID / PI_SESSION_ID),",
+    `so pass the scope explicitly: \`${flag} <id>\` (for example \`${flag} 01a05b8a-6763-7780-834f-319423b071ce\`).`
+  ].join(`
+`);
 }
-function parseCodexGoalSnapshot(value) {
-  const root = safeObject(value);
-  const goalValue = Object.hasOwn(root, "goal") ? root["goal"] : value;
-  if (goalValue === null || goalValue === undefined || goalValue === false) {
-    return { available: false, raw: value };
+
+// components/ulw-loop/src/state-lock.ts
+import { randomUUID } from "node:crypto";
+import { closeSync, ftruncateSync, mkdirSync, openSync, readFileSync as readFileSync2, statSync, unlinkSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+var ULW_LOOP_LOCK_TIMEOUT_CODE = "ULW_LOOP_LOCK_TIMEOUT";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_STALE_MS = 60000;
+var DEFAULT_LEASE_MS = 30000;
+var SLEEP_CELL = new Int32Array(new SharedArrayBuffer(4));
+var systemClock = {
+  now: Date.now,
+  schedule(fn, ms) {
+    const timer = setTimeout(fn, ms);
+    return {
+      unref: () => {
+        timer.unref();
+      },
+      cancel: () => clearTimeout(timer)
+    };
   }
-  const goal = safeObject(goalValue);
-  const objective = safeString(goal["objective"] ?? goal["goal"] ?? goal["description"] ?? root["objective"]);
-  const status = normalizeStatus(goal["status"] ?? root["status"]);
-  return {
-    available: Boolean(objective || status !== "unknown"),
-    ...objective ? { objective } : {},
-    status,
-    raw: value
+};
+async function withStateLock(lockPath, fn, options = {}) {
+  const holder = await acquireAsync(lockPath, options);
+  const clock = options.clock ?? systemClock;
+  let timer;
+  let heartbeatError;
+  const beat = () => {
+    try {
+      holder.record.leaseUntil = clock.now() + (options.leaseMs ?? DEFAULT_LEASE_MS);
+      writeRecord(holder);
+      schedule();
+    } catch (error) {
+      heartbeatError = error;
+    }
+  };
+  const schedule = () => {
+    if (options.heartbeatMs === 0)
+      return;
+    timer = clock.schedule(beat, options.heartbeatMs ?? (options.leaseMs ?? DEFAULT_LEASE_MS) / 3);
+    timer.unref();
   };
+  schedule();
+  try {
+    const result = await fn(holder.record.token);
+    if (heartbeatError !== undefined)
+      throw heartbeatError;
+    return result;
+  } finally {
+    timer?.cancel();
+    closeSync(holder.fd);
+    release(lockPath, holder.record.token);
+  }
 }
-async function readCodexGoalSnapshotInput(raw, cwd = process.cwd()) {
-  if (!raw?.trim())
-    return null;
-  const trimmed = raw.trim();
+function withStateLockSync(lockPath, fn, options = {}) {
+  const holder = acquireSync(lockPath, options);
   try {
-    return parseCodexGoalSnapshot(JSON.parse(trimmed));
-  } catch {
-    const path = resolve(cwd, trimmed);
-    if (!existsSync2(path)) {
-      throw new CodexGoalSnapshotError(`Codex goal snapshot is neither valid JSON nor a readable path: ${trimmed}`);
-    }
+    return fn();
+  } finally {
+    closeSync(holder.fd);
+    release(lockPath, holder.record.token);
+  }
+}
+function isStateLockTimeout(error) {
+  return error instanceof UlwLoopError && error.code === ULW_LOOP_LOCK_TIMEOUT_CODE;
+}
+async function acquireAsync(lockPath, options) {
+  const clock = options.clock ?? systemClock;
+  const deadline = clock.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  mkdirSync(dirname(lockPath), { recursive: true });
+  for (let attempt = 0;; ) {
+    const outcome = attemptOnce(lockPath, options, clock.now(), options.leaseMs ?? DEFAULT_LEASE_MS);
+    if (outcome.kind === "acquired")
+      return outcome.holder;
+    if (outcome.kind === "retry")
+      continue;
+    if (clock.now() >= deadline)
+      throw lockTimeout(lockPath, options);
+    await new Promise((resolve) => clock.schedule(resolve, backoffMs(attempt)));
+    attempt += 1;
+  }
+}
+function acquireSync(lockPath, options) {
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  mkdirSync(dirname(lockPath), { recursive: true });
+  for (let attempt = 0;; ) {
+    const outcome = attemptOnce(lockPath, options, Date.now());
+    if (outcome.kind === "acquired")
+      return outcome.holder;
+    if (outcome.kind === "retry")
+      continue;
+    if (Date.now() >= deadline)
+      throw lockTimeout(lockPath, options);
+    Atomics.wait(SLEEP_CELL, 0, 0, backoffMs(attempt));
+    attempt += 1;
+  }
+}
+function attemptOnce(lockPath, options, now, leaseMs) {
+  try {
+    const holder = tryCreate(lockPath, now, leaseMs);
+    if (holder !== null)
+      return { kind: "acquired", holder };
+    const snapshot = readSnapshot(lockPath, now);
+    if (snapshot === null)
+      return { kind: "retry" };
+    const record = snapshot.record;
+    const stale = record === null ? snapshot.ageMs > (options.staleMs ?? DEFAULT_STALE_MS) : !isProcessAlive(record.pid) || record.leaseUntil !== undefined && now > record.leaseUntil;
+    if (stale && reclaim(lockPath, snapshot.raw))
+      return { kind: "retry" };
+    return { kind: "wait" };
+  } catch (error) {
+    if (hasCode2(error, "EINTR"))
+      return { kind: "wait" };
+    throw error;
+  }
+}
+function writeRecord(holder) {
+  const buf = Buffer.from(JSON.stringify(holder.record));
+  ftruncateSync(holder.fd, 0);
+  let offset = 0;
+  while (offset < buf.length) {
+    const written = writeSync(holder.fd, buf, offset, buf.length - offset, offset);
+    if (written === 0)
+      throw new Error("State lock write made no progress.");
+    offset += written;
+  }
+}
+function tryCreate(lockPath, now, leaseMs) {
+  let fd;
+  try {
+    fd = openSync(lockPath, "wx");
+  } catch (error) {
+    if (hasCode2(error, "EEXIST"))
+      return null;
+    throw error;
+  }
+  const record = {
+    pid: process.pid,
+    createdAt: new Date(now).toISOString(),
+    token: randomUUID(),
+    ...leaseMs === undefined ? {} : { leaseUntil: now + leaseMs }
+  };
+  const holder = { fd, record };
+  try {
+    writeRecord(holder);
+  } catch (error) {
+    closeSync(fd);
     try {
-      return parseCodexGoalSnapshot(JSON.parse(await readFile2(path, "utf-8")));
-    } catch (error) {
-      throw new CodexGoalSnapshotError(`Codex goal snapshot path does not contain valid JSON: ${trimmed}${error instanceof Error ? ` (${error.message})` : ""}`);
+      unlinkSync(lockPath);
+    } catch (cleanup) {
+      if (!hasCode2(cleanup, "ENOENT"))
+        throw cleanup;
     }
+    throw error;
   }
+  return holder;
 }
-function reconcileCodexGoalSnapshot(snapshot, options) {
-  const effectiveSnapshot = snapshot ?? { available: false, raw: null };
-  const errors = [];
-  const warnings = [];
-  if (!effectiveSnapshot.available) {
-    const message = "Codex goal snapshot is absent or reports no active goal; call get_goal and pass its JSON with --codex-goal-json.";
-    if (options.requireSnapshot)
-      errors.push(message);
-    else
-      warnings.push(message);
-    return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
-  }
-  const expected = normalizeObjective2(options.expectedObjective);
-  const accepted = new Set([expected, ...(options.acceptedObjectives ?? []).map((objective) => normalizeObjective2(objective))].filter(Boolean));
-  const actual = normalizeObjective2(effectiveSnapshot.objective ?? "");
-  if (!actual) {
-    errors.push("Codex goal snapshot is missing objective text.");
-  } else if (!accepted.has(actual)) {
-    errors.push(`Codex goal objective mismatch: expected "${expected}", got "${actual}".`);
-  }
-  const allowed = options.allowedStatuses ?? (options.requireComplete ? ["complete"] : ["active", "complete"]);
-  const actualStatus = effectiveSnapshot.status ?? "unknown";
-  if (!allowed.includes(actualStatus)) {
-    errors.push(`Codex goal status mismatch: expected ${allowed.join(" or ")}, got ${actualStatus}.`);
+function readSnapshot(lockPath, now) {
+  try {
+    const raw = readFileSync2(lockPath, "utf8");
+    return { raw, record: parseRecord(raw), ageMs: now - statSync(lockPath).mtimeMs };
+  } catch (error) {
+    if (hasCode2(error, "ENOENT"))
+      return null;
+    throw error;
+  }
+}
+function parseRecord(raw) {
+  try {
+    const record = JSON.parse(raw);
+    if (typeof record !== "object" || record === null)
+      return null;
+    if (!("pid" in record) || typeof record.pid !== "number" || !Number.isInteger(record.pid) || record.pid <= 0)
+      return null;
+    if (!("createdAt" in record) || typeof record.createdAt !== "string")
+      return null;
+    if (!("token" in record) || typeof record.token !== "string" || record.token.length === 0)
+      return null;
+    return {
+      pid: record.pid,
+      createdAt: record.createdAt,
+      token: record.token,
+      ..."leaseUntil" in record && typeof record.leaseUntil === "number" ? { leaseUntil: record.leaseUntil } : {}
+    };
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      return null;
+    throw error;
   }
-  if (options.requireComplete && actualStatus !== "complete") {
-    errors.push('Codex goal is not complete; call update_goal({status: "complete"}) only after the objective is actually complete, then pass the fresh get_goal JSON.');
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (hasCode2(error, "ESRCH"))
+      return false;
+    if (hasCode2(error, "EPERM"))
+      return true;
+    throw error;
+  }
+}
+function reclaim(lockPath, expectedRaw) {
+  const current = readSnapshot(lockPath, Date.now());
+  if (current === null)
+    return true;
+  if (current.raw !== expectedRaw)
+    return false;
+  try {
+    unlinkSync(lockPath);
+  } catch (error) {
+    if (hasCode2(error, "EPERM") || hasCode2(error, "EACCES"))
+      return false;
+    if (!hasCode2(error, "ENOENT"))
+      throw error;
+  }
+  return true;
+}
+function release(lockPath, token) {
+  if (readSnapshot(lockPath, Date.now())?.record?.token !== token)
+    return;
+  try {
+    unlinkSync(lockPath);
+  } catch (error) {
+    if (!hasCode2(error, "ENOENT"))
+      throw error;
   }
-  return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
 }
-function formatCodexGoalReconciliation(reconciliation) {
-  const parts = [...reconciliation.errors, ...reconciliation.warnings];
-  return parts.join(" ");
+function backoffMs(attempt) {
+  return Math.min(100, 5 * 2 ** attempt) + Math.random() * 5;
+}
+function lockTimeout(lockPath, options) {
+  const holder = readSnapshot(lockPath, Date.now())?.record;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const owner = holder == null ? "another process" : `pid ${holder.pid}`;
+  return new UlwLoopError(`ulw-loop state lock ${lockPath} is held by ${owner} for more than ${timeoutMs}ms. The lock owner is still alive. If a JS eval kernel was interrupted while writing, wait for its lease to expire (${options.leaseMs ?? DEFAULT_LEASE_MS} ms) or restart the owning senpi process; never delete a lock owned by a live process.`, ULW_LOOP_LOCK_TIMEOUT_CODE, { details: { lockPath, timeoutMs, ...holder == null ? {} : { holderPid: holder.pid } } });
+}
+function hasCode2(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/plan-io.ts
-import { createReadStream } from "node:fs";
-import { appendFile, mkdir, readFile as readFile3, rename, writeFile } from "node:fs/promises";
-import { createInterface } from "node:readline";
+// components/ulw-loop/src/plan-io.ts
+function readLedger2(repoRoot, scope) {
+  const lockPath = ulwLoopStateLockPath(repoRoot, scope);
+  if (heldLocks.getStore()?.has(lockPath)) {
+    assertStateLockOwned(lockPath);
+    materializeSync(ulwLoopDir(repoRoot, scope));
+  }
+  return readLedger(repoRoot, scope);
+}
 var LEGACY_OBJECTIVE_PREFIX = `Complete all ulw-loop stories in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}: `;
 var LEGACY_OBJECTIVE = `Complete all ulw-loop stories listed in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}. Use ${ULW_LOOP_DIR}/${ULW_LOOP_LEDGER} as the durable audit trail.`;
 var locks = new Map;
-function hasCode(error, code) {
-  return error instanceof Error && "code" in error && error.code === code;
-}
-function isLegacyEnumeratedAggregateObjective(objective) {
-  return objective === LEGACY_OBJECTIVE || Boolean(objective?.startsWith(LEGACY_OBJECTIVE_PREFIX));
+var heldLocks = new AsyncLocalStorage;
+var lockOptions = new AsyncLocalStorage;
+function tokenAt(lockPath) {
+  const raw = readOptional(lockPath);
+  if (raw === undefined)
+    return;
+  try {
+    const record = JSON.parse(raw);
+    return typeof record === "object" && record !== null && "token" in record && typeof record.token === "string" ? record.token : undefined;
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      return;
+    throw error;
+  }
 }
-function isSteeringKind(value) {
-  return value === "steering_accepted" || value === "steering_rejected" || value === "criteria_revised" || value === "batch_updated";
+function assertStateLockOwned(lockPath) {
+  const context = heldLocks.getStore()?.get(lockPath);
+  if (context === undefined)
+    return;
+  if (tokenAt(lockPath) !== context.token)
+    throw new UlwLoopError("The ulw-loop mutation lock changed owners.", "ULW_LOOP_LOCK_LOST");
+}
+function migrationEntries(plan) {
+  for (const context of heldLocks.getStore()?.values() ?? []) {
+    const entries = context.migrations.get(plan.goalsPath);
+    if (entries !== undefined) {
+      context.migrations.delete(plan.goalsPath);
+      return entries;
+    }
+  }
+  return [];
 }
-async function withUlwLoopMutationLock(repoRoot, scopeOrFn, maybeFn) {
+async function withUlwLoopMutationLock(repoRoot, scopeOrFn, maybeFn, options = {}) {
   const scope = typeof scopeOrFn === "function" ? undefined : scopeOrFn;
   const fn = typeof scopeOrFn === "function" ? scopeOrFn : maybeFn;
   if (fn === undefined)
     throw new UlwLoopError("Missing ulw-loop mutation body.", "ULW_LOOP_LOCK_BODY_MISSING");
   const lockKey = `${repoRoot}\x00${ulwLoopRelativeDir(scope)}`;
+  const lockPath = ulwLoopStateLockPath(repoRoot, scope);
+  const locked = () => withStateLock(lockPath, async (token) => {
+    return heldLocks.run(new Map([...heldLocks.getStore() ?? [], [lockPath, { token, migrations: new Map }]]), async () => {
+      for (let attempt = 0;; attempt += 1) {
+        try {
+          return await fn();
+        } catch (error) {
+          if (!(error instanceof UlwLoopError) || error.code !== "ULW_LOOP_PUBLISH_CONFLICT")
+            throw error;
+          assertStateLockOwned(lockPath);
+          if (attempt !== 0)
+            throw error;
+        }
+      }
+    });
+  }, { ...lockOptions.getStore(), ...options });
   const prior = locks.get(lockKey) ?? Promise.resolve(undefined);
-  const run = prior.then(fn, fn);
+  const run = prior.then(locked, locked);
   const gate = run.then(() => {
     return;
   }, () => {
@@ -400,89 +881,144 @@ async function withUlwLoopMutationLock(repoRoot, scopeOrFn, maybeFn) {
   });
   return run;
 }
-async function readUlwLoopPlan(repoRoot, scope) {
+function readUlwLoopPlanSync(repoRoot, scope) {
   const path = ulwLoopGoalsPath(repoRoot, scope);
-  let raw;
-  try {
-    raw = await readFile3(path, "utf8");
-  } catch (error) {
-    if (!hasCode(error, "ENOENT"))
-      throw error;
-    throw new UlwLoopError(`No ulw-loop plan found at ${repoRelative(path, repoRoot)}. Run \`omo-agent-toolkit ulw-loop create-goals ...\` first.`, "ULW_LOOP_PLAN_MISSING", { cause: error });
-  }
-  const parsed = JSON.parse(raw);
-  if (parsed.version !== 1 || !Array.isArray(parsed.goals)) {
+  const parsed = reconcilePlan(ulwLoopDir(repoRoot, scope));
+  if (parsed === undefined)
+    throw planMissingError(repoRelative(path, repoRoot), listUlwLoopSessionIds(repoRoot));
+  if (parsed.version !== 1 || !Array.isArray(parsed.goals))
     throw new UlwLoopError(`Invalid ulw-loop plan at ${repoRelative(path, repoRoot)}.`, "ULW_LOOP_PLAN_INVALID");
-  }
   const previousObjective = parsed.codexObjective;
-  if ((parsed.codexGoalMode ?? "per_story") === "aggregate" && isLegacyEnumeratedAggregateObjective(previousObjective)) {
-    const now = iso();
+  if ((parsed.codexGoalMode ?? "per_story") === "aggregate" && previousObjective !== undefined && (previousObjective === LEGACY_OBJECTIVE || previousObjective.startsWith(LEGACY_OBJECTIVE_PREFIX))) {
     parsed.codexObjective = aggregateCodexObjectiveForScope(scope);
     parsed.codexObjectiveAliases = [...new Set([...parsed.codexObjectiveAliases ?? [], previousObjective])];
-    parsed.updatedAt = now;
-    await writePlan(repoRoot, parsed, scope);
-    await appendLedger(repoRoot, {
-      at: now,
-      kind: "aggregate_objective_migrated",
-      message: "Migrated legacy enumerated aggregate Codex objective to the stable pointer objective.",
-      before: { codexObjective: previousObjective },
-      after: { codexObjective: parsed.codexObjective }
-    }, scope);
+    heldLocks.getStore()?.get(ulwLoopStateLockPath(repoRoot, scope))?.migrations.set(parsed.goalsPath, [
+      {
+        at: iso(),
+        kind: "aggregate_objective_migrated",
+        before: { codexObjective: previousObjective },
+        after: { codexObjective: parsed.codexObjective }
+      }
+    ]);
   }
   return parsed;
 }
-async function writePlan(repoRoot, plan, scope) {
-  await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
-  const path = ulwLoopGoalsPath(repoRoot, scope);
-  const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile(tmpPath, `${JSON.stringify(plan, null, 2)}
-`, "utf8");
-  await rename(tmpPath, path);
+async function readUlwLoopPlan(repoRoot, scope) {
+  if (heldLocks.getStore()?.has(ulwLoopStateLockPath(repoRoot, scope))) {
+    assertStateLockOwned(ulwLoopStateLockPath(repoRoot, scope));
+    await materialize(ulwLoopDir(repoRoot, scope));
+  }
+  return readUlwLoopPlanSync(repoRoot, scope);
+}
+function listUlwLoopSessionIds(repoRoot) {
+  try {
+    return readdirSync2(ulwLoopDir(repoRoot), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch {
+    return [];
+  }
 }
-async function appendLedger(repoRoot, entry, scope) {
-  await appendLedgerEntries(repoRoot, [entry], scope);
+function isSteeringKind(value) {
+  return value === "steering_accepted" || value === "steering_rejected" || value === "criteria_revised" || value === "batch_updated";
 }
-async function appendLedgerEntries(repoRoot, entries, scope) {
-  if (entries.length === 0)
-    return;
-  await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
-  await appendFile(ulwLoopLedgerPath(repoRoot, scope), `${entries.map((entry) => JSON.stringify(entry)).join(`
-`)}
-`, "utf8");
+async function findAcceptedSteeringLedgerEntry(repoRoot, key, scope) {
+  return readLedger2(repoRoot, scope).find((entry) => isSteeringKind(entry.kind) && entry.steering?.invariant.accepted === true && (entry.idempotencyKey === key || entry.steering.idempotencyKey === key || entry.steering.promptSignature === key));
 }
-async function* ledgerLines(repoRoot, scope) {
-  const stream = createReadStream(ulwLoopLedgerPath(repoRoot, scope), { encoding: "utf8" });
-  const lines = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+
+// components/ulw-loop/src/plan-commit.ts
+var hooks = new AsyncLocalStorage2;
+async function beforePlanMutation() {
+  await hooks.getStore()?.beforeMutation?.();
+}
+async function writeViewFile(path, content) {
+  await (hooks.getStore()?.writeView ?? writeFile)(path, content);
+}
+async function commit(repoRoot, scope, mutation) {
+  const { plan } = mutation;
+  const dir = ulwLoopDir(repoRoot, scope);
+  assertStateLockOwned(ulwLoopStateLockPath(repoRoot, scope));
+  await hooks.getStore()?.beforeCommit?.();
+  const next = (plan.revision ?? 0) + 1;
+  const brief = plan.brief ?? readOptional(join4(dir, "brief.md")) ?? "";
+  const entries = [...migrationEntries(plan), ...mutation.entries].map((entry, seq) => ({
+    ...entry,
+    revision: next,
+    id: `${next}-${seq}`
+  }));
+  const record = {
+    version: 1,
+    revision: next,
+    plan: { ...plan, revision: next, brief },
+    ledger: entries
+  };
+  mkdirSync2(join4(dir, "revisions"), { recursive: true });
+  mkdirSync2(join4(dir, "tmp"), { recursive: true });
+  const temp = join4(dir, "tmp", `${process.pid}-${randomUUID2()}.json`);
   try {
-    for await (const line of lines) {
-      if (line.trim().length > 0)
-        yield line;
-    }
-  } catch (error) {
-    if (!hasCode(error, "ENOENT"))
+    writeFileSync(temp, `${JSON.stringify(record)}
+`, { flag: "wx" });
+    try {
+      (hooks.getStore()?.link ?? linkSync)(temp, join4(dir, "revisions", `${String(next).padStart(8, "0")}.json`));
+    } catch (error) {
+      if (hasCode(error, "EEXIST"))
+        throw new UlwLoopError("Another writer published the read revision.", "ULW_LOOP_PUBLISH_CONFLICT", {
+          cause: error
+        });
+      if (["EPERM", "ENOTSUP", "EXDEV"].some((code) => hasCode(error, code)))
+        throw new UlwLoopError("Immutable ulw-loop publication requires atomic hard links.", "ULW_LOOP_PUBLISH_UNSUPPORTED_FS", { cause: error });
       throw error;
+    }
   } finally {
-    lines.close();
-    stream.destroy();
+    rmSync(temp, { force: true });
   }
+  plan.revision = next;
+  plan.brief = brief;
+  for (const [index, entry] of mutation.entries.entries())
+    Object.assign(entry, entries[index + entries.length - mutation.entries.length]);
+  await hooks.getStore()?.afterCommit?.();
+  await materialize(dir);
+}
+function viewContents(dir) {
+  const plan = reconcilePlan(dir);
+  if (plan === undefined || readRecords(dir).length === 0)
+    return [];
+  const ledger = readLedgerAt(dir);
+  assertProjectionComplete(plan, ledger);
+  const views = [
+    ["goals.json", `${JSON.stringify(plan, null, 2)}
+`],
+    ["ledger.jsonl", ledger.length === 0 ? "" : `${ledger.map((entry) => JSON.stringify(entry)).join(`
+`)}
+`],
+    ["brief.md", plan.brief ?? readOptional(join4(dir, "brief.md")) ?? ""]
+  ];
+  return views.filter(([name, content]) => readOptional(join4(dir, name)) !== content);
 }
-async function findAcceptedSteeringLedgerEntry(repoRoot, key, scope) {
-  const probe = JSON.stringify(key);
-  for await (const line of ledgerLines(repoRoot, scope)) {
-    if (!line.includes(probe))
-      continue;
-    const entry = JSON.parse(line);
-    if (!isSteeringKind(entry.kind))
-      continue;
-    if (entry.steering?.invariant.accepted !== true)
-      continue;
-    if (entry.idempotencyKey === key || entry.steering.idempotencyKey === key || entry.steering.promptSignature === key)
-      return entry;
+function materializeSync(dir) {
+  for (const [name, content] of viewContents(dir)) {
+    mkdirSync2(join4(dir, "tmp"), { recursive: true });
+    const temp = join4(dir, "tmp", `${process.pid}-${randomUUID2()}-${name}`);
+    try {
+      writeFileSync(temp, content, { flag: "wx" });
+      renameSync(temp, join4(dir, name));
+    } finally {
+      rmSync(temp, { force: true });
+    }
+  }
+}
+async function materialize(dir) {
+  for (const [name, content] of viewContents(dir)) {
+    mkdirSync2(join4(dir, "tmp"), { recursive: true });
+    const temp = join4(dir, "tmp", `${process.pid}-${randomUUID2()}-${name}`);
+    try {
+      await writeViewFile(temp, content);
+      await rename(temp, join4(dir, name));
+    } finally {
+      rmSync(temp, { force: true });
+    }
   }
-  return;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/evidence.ts
+// components/ulw-loop/src/evidence.ts
 function ulwLoopFail(message, code, details) {
   throw new UlwLoopError(message, code, { details });
 }
@@ -519,6 +1055,7 @@ async function recordEvidence(repoRoot, args, scope) {
     const goal = findGoal(plan, args.goalId);
     const criterion = findCriterion(goal, args.criterionId);
     const evidence = nonEmptyEvidence(args.evidence);
+    const artifacts = resolveEvidenceArtifacts(repoRoot, args.artifacts);
     const kind = ledgerKind(args.status);
     const prevStatus = criterion.status;
     const capturedAt = iso();
@@ -527,9 +1064,12 @@ async function recordEvidence(repoRoot, args, scope) {
     criterion.capturedAt = capturedAt;
     if (args.notes !== undefined)
       criterion.notes = args.notes;
+    if (artifacts !== undefined)
+      criterion.artifacts = artifacts;
+    else
+      delete criterion.artifacts;
     goal.updatedAt = capturedAt;
     plan.updatedAt = capturedAt;
-    await writePlan(repoRoot, plan, scope);
     const ledgerEntry = {
       at: capturedAt,
       kind,
@@ -538,10 +1078,11 @@ async function recordEvidence(repoRoot, args, scope) {
       criterionStatus: args.status,
       evidence,
       capturedEvidence: evidence,
+      ...artifacts === undefined ? {} : { artifacts },
       before: { status: prevStatus },
       after: { goalId: goal.id, criterionId: criterion.id, status: args.status, evidence, capturedAt, prevStatus }
     };
-    await appendLedger(repoRoot, ledgerEntry, scope);
+    await commit(repoRoot, scope, { plan, entries: [ledgerEntry] });
     return { plan, goal, criterion, ledgerEntry };
   });
 }
@@ -588,57 +1129,216 @@ function requireEssentialCriteriaPass(goal) {
   });
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/quality-gate.ts
-import { resolve as resolve2 } from "node:path";
+// components/ulw-loop/src/quality-gate-artifacts.ts
+import { resolve as resolve3 } from "node:path";
 
-// packages/omo-codex/plugin/components/ulw-loop/src/quality-gate-fields.ts
-var PLACEHOLDER_PATTERN = /^(?:placeholder|todo|tbd|n\/a|stub)$/i;
+// components/ulw-loop/src/quality-gate-fields.ts
+var PLACEHOLDER_PATTERN = /^(?:<replace:[^>]+>|placeholder|todo|tbd|n\/a|stub)$/i;
+var activeCollector;
+function withQualityGateCollector(operation) {
+  const previous = activeCollector;
+  const collector = { defects: [], poisonedFields: new Set, poisonedArtifactKinds: new Set };
+  activeCollector = collector;
+  try {
+    const result = operation();
+    if (collector.defects.length === 0)
+      return result;
+    throwQualityGateDefects(collector.defects);
+  } finally {
+    activeCollector = previous;
+  }
+}
+function throwQualityGateDefects(defects) {
+  const uniqueDefects = [
+    ...new Map(defects.map((defect) => [`${defect.field}\x00${defect.message}`, defect])).values()
+  ];
+  const fields = uniqueDefects.slice(0, 25);
+  const truncated = uniqueDefects.length > fields.length;
+  const message = [
+    `Final quality gate has ${fields.length}${truncated ? "+" : ""} validation defects:`,
+    ...fields.map((item) => `- ${item.field}: ${item.message}`)
+  ].join(`
+`);
+  throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", {
+    details: { field: fields[0]?.field, fields, ...truncated ? { truncated: true } : {} }
+  });
+}
 function invalid(message, field) {
-  throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+  if (activeCollector === undefined)
+    throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+  activeCollector.defects.push({ field, message });
+  activeCollector.poisonedFields.add(field);
+  return;
+}
+function isPoisoned(field) {
+  return activeCollector?.poisonedFields.has(field) ?? false;
+}
+function markPoisonedArtifactKind(id) {
+  activeCollector?.poisonedArtifactKinds.add(id);
+}
+function isPoisonedArtifactKind(id) {
+  return activeCollector?.poisonedArtifactKinds.has(id) ?? false;
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function section(value, field) {
-  return isRecord(value) ? value : invalid(`Final quality gate is missing ${field} evidence.`, field);
+  if (isRecord(value))
+    return value;
+  invalid(`Final quality gate is missing ${field} evidence (accepted input: a bare object with manualQa/gateReview/iteration/criteriaCoverage and optional codeReview, or the same object under a top-level "qualityGate" key).`, field);
+  return {};
 }
 function textField(value, field) {
-  if (typeof value !== "string" || value.trim() === "")
+  if (typeof value !== "string" || value.trim() === "") {
     invalid(`Final quality gate requires non-empty ${field}.`, field);
+    return "";
+  }
   const trimmed = value.trim();
   if (PLACEHOLDER_PATTERN.test(trimmed))
     invalid(`Final quality gate rejects placeholder ${field}.`, field);
   return trimmed;
 }
 function numberField(value, field) {
-  return typeof value === "number" && Number.isFinite(value) ? value : invalid(`Final quality gate requires numeric ${field}.`, field);
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  invalid(`Final quality gate requires numeric ${field}.`, field);
+  return 0;
 }
 function stringArray(value, field) {
-  if (!Array.isArray(value) || value.length === 0)
-    return invalid(`Final quality gate requires ${field}.`, field);
+  if (!Array.isArray(value) || value.length === 0) {
+    invalid(`Final quality gate requires ${field}.`, field);
+    return [];
+  }
   return value.map((item) => textField(item, field));
 }
 function emptyBlockers(value, field) {
   if (Array.isArray(value) && value.length === 0)
     return [];
   invalid(`${field} must be empty.`, field);
+  return [];
 }
 function literal(value, expected, field) {
   if (value === expected)
     return expected;
   invalid(`${field} must be ${String(expected)}.`, field);
+  return expected;
+}
+
+// components/ulw-loop/src/quality-gate-artifacts.ts
+var SUPPORTED_SURFACES = ["cli", "http", "tmux", "browser", "gui", "data"];
+var SUPPORTED_KINDS = [
+  "cli-transcript",
+  "log",
+  "screenshot",
+  "image",
+  "http-dump",
+  "data-diff"
+];
+var COMPATIBLE_KINDS = {
+  cli: ["cli-transcript", "log"],
+  tmux: ["cli-transcript", "log"],
+  http: ["http-dump"],
+  browser: ["screenshot", "image"],
+  gui: ["screenshot", "image"],
+  data: ["data-diff"]
+};
+function isSupportedSurface(value) {
+  return SUPPORTED_SURFACES.some((surface) => surface === value);
+}
+function isSupportedKind(value) {
+  return SUPPORTED_KINDS.some((kind) => kind === value);
+}
+function surfaceField(value, field) {
+  if (isSupportedSurface(value))
+    return value;
+  invalid(`${field} must be a supported manual QA surface (${SUPPORTED_SURFACES.join(", ")}).`, field);
+  return "cli";
+}
+function kindField(value, field) {
+  if (isSupportedKind(value))
+    return value;
+  invalid(`${field} must be a supported artifact kind (${SUPPORTED_KINDS.join(", ")}); review/QA reports belong in codeReview.reportPath or gateReview.reportPath, not artifactRefs.`, field);
+  return "log";
+}
+function compatibleKindsFor(surface) {
+  return COMPATIBLE_KINDS[surface];
+}
+function artifactCompatible(surface, kind) {
+  return compatibleKindsFor(surface).includes(kind);
+}
+function checkFile(path, field, opts) {
+  if (opts?.repoRoot === undefined || opts.fs === undefined || isPoisoned(field))
+    return;
+  const absolute = resolve3(opts.repoRoot, path);
+  if (!opts.fs.existsSync(absolute)) {
+    invalid(`${field} must point to an existing artifact.`, field);
+    return;
+  }
+  if (opts.fs.statSync(absolute).size <= 0)
+    invalid(`${field} must point to a non-empty artifact.`, field);
+  if (opts.currentAttemptDir !== undefined && !isWithinAttemptDir(absolute, resolve3(opts.repoRoot, opts.currentAttemptDir)))
+    invalid(`${field} (${path}) must point to an artifact from the current attempt (${opts.currentAttemptDir}).`, field);
+}
+function artifactMap(refs) {
+  const byId = new Map;
+  for (const ref of refs) {
+    if (byId.has(ref.id))
+      invalid(`manualQa.artifactRefs contains duplicate ${ref.id}.`, "manualQa.artifactRefs");
+    byId.set(ref.id, ref);
+  }
+  return byId;
+}
+function parseArtifactRefs(value, opts) {
+  if (!Array.isArray(value) || value.length === 0) {
+    invalid("manualQa.artifactRefs must not be empty.", "manualQa.artifactRefs");
+    return [];
+  }
+  return value.flatMap((item, index) => {
+    const prefix = `manualQa.artifactRefs[${index}]`;
+    const ref = section(item, prefix);
+    if (isPoisoned(prefix))
+      return [];
+    const pathField = `${prefix}.path`;
+    const idField = `${prefix}.id`;
+    const kindFieldName = `${prefix}.kind`;
+    const descriptionField = `${prefix}.description`;
+    const path = textField(ref["path"], pathField);
+    const id = textField(ref["id"], idField);
+    const kind = kindField(ref["kind"], kindFieldName);
+    if (isPoisoned(kindFieldName))
+      markPoisonedArtifactKind(id);
+    const description = textField(ref["description"], descriptionField);
+    checkFile(path, pathField, opts);
+    return [{ id, kind, description, path }];
+  });
+}
+function referencedArtifacts(value, field, byId) {
+  const ids = stringArray(value, field);
+  if (isPoisoned(field))
+    return [];
+  return ids.flatMap((id) => {
+    const artifact = byId.get(id);
+    if (artifact === undefined) {
+      invalid(`${field} references unknown artifact ${id}.`, field);
+      return [];
+    }
+    return [artifact];
+  });
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/quality-gate-verdicts.ts
+// components/ulw-loop/src/quality-gate-verdicts.ts
 function passedVerdict(value, field) {
-  if (value === "not_applicable")
+  if (value === "not_applicable") {
     invalid(`${field} must not be not_applicable.`, field);
+    return "passed";
+  }
   return literal(value, "passed", field);
 }
 function codeQualityStatusField(value, field) {
   if (value === "CLEAR" || value === "WATCH")
     return value;
   invalid(`${field} must be CLEAR or WATCH.`, field);
+  return "CLEAR";
 }
 function adversarialVerdict(row, field) {
   const value = row["verdict"];
@@ -648,9 +1348,90 @@ function adversarialVerdict(row, field) {
     return { verdict: "not_applicable", reason: textField(row["reason"], `${field}.reason`) };
   }
   invalid(`${field} must be passed or not_applicable with a reason.`, field);
+  return { verdict: "passed" };
+}
+
+// components/ulw-loop/src/surface.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+var REVIEWER_ROLES_BY_SURFACE = {
+  lazycodex: {
+    codeReview: "lazycodex-code-reviewer",
+    manualQa: "lazycodex-qa-executor",
+    gateReview: "lazycodex-gate-reviewer"
+  },
+  "omo-senpi": {
+    codeReview: "omo-senpi-code-reviewer",
+    manualQa: "omo-senpi-qa-executor",
+    gateReview: "omo-senpi-gate-reviewer"
+  }
+};
+var GATE_REVIEWER_AGENT_NAMES = new Set(Object.values(REVIEWER_ROLES_BY_SURFACE).map((roles) => roles.gateReview));
+var REQUIRED_GATE_SECTIONS_BY_SURFACE = {
+  lazycodex: ["manualQa", "gateReview", "iteration", "criteriaCoverage"],
+  "omo-senpi": ["manualQa", "gateReview", "iteration", "criteriaCoverage"]
+};
+var OPTIONAL_GATE_SECTIONS_BY_SURFACE = {
+  lazycodex: ["codeReview"],
+  "omo-senpi": []
+};
+var GATE_SECTION_BY_ACCEPTOR = {
+  lazycodex: {
+    codeReview: [REVIEWER_ROLES_BY_SURFACE.lazycodex.codeReview, "main-session"],
+    manualQa: [REVIEWER_ROLES_BY_SURFACE.lazycodex.manualQa, "main-session"],
+    gateReview: [
+      REVIEWER_ROLES_BY_SURFACE.lazycodex.gateReview,
+      "category:deep-high",
+      "category:deep-low",
+      "category:deep",
+      "category:unspecified-high",
+      "category:unspecified-low",
+      "main-session"
+    ]
+  },
+  "omo-senpi": {
+    manualQa: ["main-session"],
+    gateReview: [
+      "category:deep-high",
+      "category:deep-low",
+      "category:deep",
+      "category:unspecified-high",
+      "category:unspecified-low"
+    ]
+  }
+};
+function reviewerRolesFor(surface) {
+  return REVIEWER_ROLES_BY_SURFACE[surface];
+}
+var SURFACE_MARKER_FILENAME = "surface.json";
+var SURFACE_ENV_KEY = "OMO_AGENT_TOOLKIT_SURFACE";
+function parseSurface(value) {
+  return value === "lazycodex" || value === "omo-senpi" ? value : null;
+}
+function resolveToolkitSurface(options) {
+  const env = options?.env ?? process.env;
+  const fromEnv = parseSurface(env[SURFACE_ENV_KEY]);
+  if (fromEnv !== null)
+    return fromEnv;
+  const entryDir = options?.entryDir ?? dirname2(fileURLToPath(import.meta.url));
+  const markerPath = join5(entryDir, SURFACE_MARKER_FILENAME);
+  return readMarkerSurface(markerPath) ?? "lazycodex";
+}
+function readMarkerSurface(markerPath) {
+  try {
+    if (!existsSync4(markerPath))
+      return null;
+    const parsed = JSON.parse(readFileSync3(markerPath, "utf8"));
+    return parseSurface(parsed["surface"]);
+  } catch (error) {
+    if (error instanceof Error)
+      return null;
+    throw error;
+  }
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/quality-gate-blockers.ts
+// components/ulw-loop/src/quality-gate-blockers.ts
 var BLOCKER_FIELD_KEYS = "blocker blockerSignature blockerEvidence blockerOccurrences blockedAt".split(" ");
 var URL_PATTERN = /https?:\/\/\S+/g;
 var PUNCTUATION_PATTERN = /[`"'()[\]{}:,;]/g;
@@ -692,131 +1473,68 @@ function clearGoalBlockerFields(goal) {
     Reflect.deleteProperty(goal, key);
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/quality-gate.ts
-var REVIEWER_ROLES = {
-  codeReview: "lazycodex-code-reviewer",
-  manualQa: "lazycodex-qa-executor",
-  gateReview: "lazycodex-gate-reviewer"
-};
-function reviewerRoleField(value, expected, field) {
-  const actual = textField(value, field);
-  if (actual !== expected)
-    invalid(`${field} must be ${expected}.`, field);
-  return expected;
-}
-function surfaceField(value, field) {
-  if (value === "cli" || value === "http" || value === "tmux" || value === "browser" || value === "gui" || value === "data")
-    return value;
-  invalid(`${field} must be a supported manual QA surface.`, field);
-}
-function kindField(value, field) {
-  if (value === "cli-transcript" || value === "log" || value === "screenshot" || value === "image" || value === "http-dump" || value === "data-diff")
-    return value;
-  invalid(`${field} must be a supported artifact kind.`, field);
-}
-function artifactCompatible(surface, kind) {
-  switch (surface) {
-    case "cli":
-    case "tmux":
-      return kind === "cli-transcript" || kind === "log";
-    case "http":
-      return kind === "http-dump";
-    case "browser":
-    case "gui":
-      return kind === "screenshot" || kind === "image";
-    case "data":
-      return kind === "data-diff";
-    default:
-      invalid("manualQa.surfaceEvidence has an unsupported surface.", "manualQa.surfaceEvidence.surface");
-  }
-}
-function checkFile(path, field, opts) {
-  if (opts === undefined)
-    return;
-  const absolute = resolve2(opts.repoRoot, path);
-  if (!opts.fs.existsSync(absolute))
-    invalid(`${field} must point to an existing artifact.`, field);
-  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;
-  for (const ref of refs) {
-    if (byId.has(ref.id))
-      invalid(`manualQa.artifactRefs contains duplicate ${ref.id}.`, "manualQa.artifactRefs");
-    byId.set(ref.id, ref);
+// components/ulw-loop/src/quality-gate.ts
+function reviewerAcceptorField(value, surface, sectionName) {
+  const field = `${sectionName}.by`;
+  const accepted = GATE_SECTION_BY_ACCEPTOR[surface][sectionName];
+  if (typeof value !== "string" || value.trim() === "") {
+    textField(value, field);
+    return accepted?.[0] ?? "";
   }
-  return byId;
-}
-function parseArtifactRefs(value, opts) {
-  if (!Array.isArray(value) || value.length === 0)
-    invalid("manualQa.artifactRefs must not be empty.", "manualQa.artifactRefs");
-  return value.map((item, index) => {
-    const ref = section(item, `manualQa.artifactRefs[${index}]`);
-    const path = textField(ref["path"], `manualQa.artifactRefs[${index}].path`);
-    checkFile(path, `manualQa.artifactRefs[${index}].path`, opts);
-    return {
-      id: textField(ref["id"], `manualQa.artifactRefs[${index}].id`),
-      kind: kindField(ref["kind"], `manualQa.artifactRefs[${index}].kind`),
-      description: textField(ref["description"], `manualQa.artifactRefs[${index}].description`),
-      path
-    };
-  });
-}
-function referencedArtifacts(value, field, byId) {
-  return stringArray(value, field).map((id) => {
-    const artifact = byId.get(id);
-    if (artifact === undefined)
-      invalid(`${field} references unknown artifact ${id}.`, field);
-    return artifact;
-  });
+  const actual = textField(value, field);
+  if (accepted === undefined || !accepted.includes(actual))
+    invalid(`${field} must be one of ${accepted?.join(", ") ?? "the configured reviewers"}.`, field);
+  return actual;
 }
 function validateQualityGate(input, opts) {
-  const gate = section(input, "qualityGate");
-  const codeReview = section(gate["codeReview"], "codeReview");
+  return withQualityGateCollector(() => validateQualityGateUncollected(input, opts));
+}
+function validateQualityGateUncollected(input, opts) {
+  const surface = opts?.reviewerSurface ?? "lazycodex";
+  const raw = input;
+  const gate = section(raw && typeof raw === "object" && "qualityGate" in raw ? raw["qualityGate"] : input, "qualityGate");
+  for (const name of REQUIRED_GATE_SECTIONS_BY_SURFACE[surface])
+    section(gate[name], name);
+  for (const name of Object.keys(gate)) {
+    if (name === "codeReview" && !OPTIONAL_GATE_SECTIONS_BY_SURFACE[surface].includes(name))
+      invalid("omo-senpi gate has no codeReview lane.", name);
+  }
+  if (surface === "omo-senpi" && gate["codeReview"] !== undefined)
+    invalid("omo-senpi gate has no codeReview lane.", "codeReview");
   const manualQa = section(gate["manualQa"], "manualQa");
   const gateReview = section(gate["gateReview"], "gateReview");
   const iteration = section(gate["iteration"], "iteration");
   const coverage = section(gate["criteriaCoverage"], "criteriaCoverage");
+  const codeReview = gate["codeReview"] !== undefined ? section(gate["codeReview"], "codeReview") : undefined;
+  const manualQaBy = reviewerAcceptorField(manualQa["by"], surface, "manualQa");
+  const gateReviewBy = reviewerAcceptorField(gateReview["by"], surface, "gateReview");
+  const manualQaEvidence = textField(manualQa["evidence"], "manualQa.evidence");
+  const gateReviewEvidence = textField(gateReview["evidence"], "gateReview.evidence");
   const totalCriteria = numberField(coverage["totalCriteria"], "criteriaCoverage.totalCriteria");
   const passCount = numberField(coverage["passCount"], "criteriaCoverage.passCount");
-  if (passCount < totalCriteria)
+  if (!isPoisoned("criteriaCoverage.passCount") && passCount < totalCriteria)
     invalid("criteriaCoverage.passCount must cover totalCriteria.", "criteriaCoverage.passCount");
   const artifactRefs = parseArtifactRefs(manualQa["artifactRefs"], opts);
   const byId = artifactMap(artifactRefs);
   const surfaceEvidence = parseSurfaceEvidence(manualQa["surfaceEvidence"], byId);
   const adversarialCases = parseAdversarialCases(manualQa["adversarialCases"], byId);
-  const codeReportPath = textField(codeReview["reportPath"], "codeReview.reportPath");
   const gateReportPath = textField(gateReview["reportPath"], "gateReview.reportPath");
-  checkFile(codeReportPath, "codeReview.reportPath", opts);
-  checkFile(gateReportPath, "gateReview.reportPath", opts);
-  return {
-    codeReview: {
-      by: reviewerRoleField(codeReview["by"], REVIEWER_ROLES.codeReview, "codeReview.by"),
-      recommendation: literal(codeReview["recommendation"], "APPROVE", "codeReview.recommendation"),
-      codeQualityStatus: codeQualityStatusField(codeReview["codeQualityStatus"], "codeReview.codeQualityStatus"),
-      reportPath: codeReportPath,
-      evidence: textField(codeReview["evidence"], "codeReview.evidence"),
-      blockers: emptyBlockers(codeReview["blockers"], "codeReview.blockers")
-    },
+  if (!isPoisoned("gateReview.reportPath"))
+    checkFile(gateReportPath, "gateReview.reportPath", opts);
+  const common = {
     manualQa: {
-      by: reviewerRoleField(manualQa["by"], REVIEWER_ROLES.manualQa, "manualQa.by"),
+      by: manualQaBy,
       status: literal(manualQa["status"], "passed", "manualQa.status"),
-      evidence: textField(manualQa["evidence"], "manualQa.evidence"),
+      evidence: manualQaEvidence,
       surfaceEvidence,
       adversarialCases,
       artifactRefs
     },
     gateReview: {
-      by: reviewerRoleField(gateReview["by"], REVIEWER_ROLES.gateReview, "gateReview.by"),
+      by: gateReviewBy,
       recommendation: literal(gateReview["recommendation"], "APPROVE", "gateReview.recommendation"),
       reportPath: gateReportPath,
-      evidence: textField(gateReview["evidence"], "gateReview.evidence"),
+      evidence: gateReviewEvidence,
       blockers: emptyBlockers(gateReview["blockers"], "gateReview.blockers")
     },
     iteration: {
@@ -834,17 +1552,41 @@ function validateQualityGate(input, opts) {
       adversarialClassesCovered: stringArray(coverage["adversarialClassesCovered"], "criteriaCoverage.adversarialClassesCovered")
     }
   };
+  if (surface === "omo-senpi")
+    return { surface, ...common };
+  if (codeReview === undefined)
+    return { surface, ...common };
+  const codeReportPath = textField(codeReview["reportPath"], "codeReview.reportPath");
+  checkFile(codeReportPath, "codeReview.reportPath", opts);
+  return {
+    surface,
+    ...common,
+    codeReview: {
+      by: reviewerAcceptorField(codeReview["by"], surface, "codeReview"),
+      recommendation: literal(codeReview["recommendation"], "APPROVE", "codeReview.recommendation"),
+      codeQualityStatus: codeQualityStatusField(codeReview["codeQualityStatus"], "codeReview.codeQualityStatus"),
+      reportPath: codeReportPath,
+      evidence: textField(codeReview["evidence"], "codeReview.evidence"),
+      blockers: emptyBlockers(codeReview["blockers"], "codeReview.blockers")
+    }
+  };
 }
 function parseSurfaceEvidence(value, byId) {
-  if (!Array.isArray(value) || value.length === 0)
+  if (!Array.isArray(value) || value.length === 0) {
     invalid("manualQa.surfaceEvidence must not be empty.", "manualQa.surfaceEvidence");
-  return value.map((item, index) => {
+    return [];
+  }
+  return value.flatMap((item, index) => {
     const row = section(item, `manualQa.surfaceEvidence[${index}]`);
+    if (isPoisoned(`manualQa.surfaceEvidence[${index}]`))
+      return [];
     const surface = surfaceField(row["surface"], `manualQa.surfaceEvidence[${index}].surface`);
     const artifacts = referencedArtifacts(row["artifactRefs"], `manualQa.surfaceEvidence[${index}].artifactRefs`, byId);
     for (const artifact of artifacts) {
+      if (isPoisoned(`manualQa.surfaceEvidence[${index}].surface`) || isPoisonedArtifactKind(artifact.id))
+        continue;
       if (!artifactCompatible(surface, artifact.kind)) {
-        invalid(`manualQa.surfaceEvidence ${surface} artifact ${artifact.kind} is incompatible.`, "manualQa.surfaceEvidence");
+        invalid(`manualQa.surfaceEvidence ${surface} artifact ${artifact.kind} is incompatible; surface "${surface}" accepts artifact kinds: ${compatibleKindsFor(surface).join(", ")}.`, "manualQa.surfaceEvidence");
       }
     }
     return {
@@ -858,10 +1600,14 @@ function parseSurfaceEvidence(value, byId) {
   });
 }
 function parseAdversarialCases(value, byId) {
-  if (!Array.isArray(value) || value.length === 0)
+  if (!Array.isArray(value) || value.length === 0) {
     invalid("manualQa.adversarialCases must not be empty.", "manualQa.adversarialCases");
-  return value.map((item, index) => {
+    return [];
+  }
+  return value.flatMap((item, index) => {
     const row = section(item, `manualQa.adversarialCases[${index}]`);
+    if (isPoisoned(`manualQa.adversarialCases[${index}]`))
+      return [];
     const artifacts = referencedArtifacts(row["artifactRefs"], `manualQa.adversarialCases[${index}].artifactRefs`, byId);
     const verdictInfo = adversarialVerdict(row, `manualQa.adversarialCases[${index}]`);
     return {
@@ -876,8 +1622,8 @@ function parseAdversarialCases(value, byId) {
   });
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/cli-arg-parser.ts
-import { readFile as readFile4 } from "node:fs/promises";
+// components/ulw-loop/src/cli-arg-parser.ts
+import { readFile as readFile2 } from "node:fs/promises";
 var VALUE_FLAGS = new Set("--brief --brief-file --session-id --codex-goal-mode --validation-batch-json --goal --goal-id --criterion-id --status --evidence --notes --codex-goal-json --quality-gate-json --kind --rationale --title --objective --target-goal-id --source --after-json --directive-json --directive-file --idempotency-key --proposals-json".split(" "));
 var SUBCOMMANDS = new Set("create-goals status complete-goals criteria record-evidence checkpoint steer add-goal record-review-blockers".split(" "));
 function hasFlag(argv, flag) {
@@ -925,7 +1671,7 @@ async function readJsonInput(value) {
   if (value === undefined)
     return;
   try {
-    return JSON.parse(looksLikeJson(value) ? value : await readFile4(value, "utf8"));
+    return JSON.parse(looksLikeJson(value) ? value : await readFile2(value, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : "unknown error";
     throw new UlwLoopError(`Invalid JSON input: ${message}`, "ULW_LOOP_JSON_INPUT_INVALID", { cause: error });
@@ -934,13 +1680,13 @@ async function readJsonInput(value) {
 async function parseCodexGoalJson(value) {
   if (value === undefined)
     return;
-  const raw = looksLikeJson(value) ? value : await readFile4(value, "utf8");
   try {
+    const raw = looksLikeJson(value) ? value : await readFile2(value, "utf8");
     JSON.parse(raw);
     return raw;
   } catch (error) {
     const message = error instanceof Error ? error.message : "unknown error";
-    throw new UlwLoopError(`Invalid --codex-goal-json: ${message}`, "ULW_LOOP_CODEX_GOAL_JSON_INVALID", { cause: error });
+    throw new UlwLoopError(`Invalid --codex-goal-json: ${looksLikeJson(value) ? message : "neither valid JSON nor a readable path"}`, "ULW_LOOP_CODEX_GOAL_JSON_INVALID", { cause: error });
   }
 }
 function required(argv, flag, code) {
@@ -967,7 +1713,7 @@ function parseRecordEvidenceArgs(argv) {
   return notes ? { ...result, notes } : result;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/validation-batch.ts
+// components/ulw-loop/src/validation-batch.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -987,23 +1733,23 @@ async function parseValidationBatches(input, goals) {
   if (raw === undefined)
     return;
   if (!Array.isArray(raw))
-    fail("--validation-batch-json must be a JSON array.");
+    fail2("--validation-batch-json must be a JSON array.");
   const batches = raw.map(batchFromObject);
   validateBatches(batches, goals);
   return batches;
 }
 function batchFromObject(value) {
   if (!isObject(value))
-    fail("validation batch entries must be objects.");
+    fail2("validation batch entries must be objects.");
   const batchId = text(value, "batchId");
   const memberIds = strings(value, "memberIds");
   const finalGoalId = text(value, "finalGoalId");
   if (batchId === undefined)
-    fail("validation batch requires batchId.");
+    fail2("validation batch requires batchId.");
   if (memberIds === undefined || memberIds.length < 2)
-    fail("validation batch requires at least two memberIds.");
+    fail2("validation batch requires at least two memberIds.");
   if (finalGoalId === undefined)
-    fail("validation batch requires finalGoalId.");
+    fail2("validation batch requires finalGoalId.");
   return { batchId, memberIds, finalGoalId };
 }
 function validateBatches(batches, goals) {
@@ -1012,17 +1758,17 @@ function validateBatches(batches, goals) {
   const members = new Set;
   for (const batch of batches) {
     if (batchIds.has(batch.batchId))
-      fail(`duplicate validation batch id: ${batch.batchId}.`);
+      fail2(`duplicate validation batch id: ${batch.batchId}.`);
     batchIds.add(batch.batchId);
     if (new Set(batch.memberIds).size !== batch.memberIds.length)
-      fail(`validation batch ${batch.batchId} has duplicate memberIds.`);
+      fail2(`validation batch ${batch.batchId} has duplicate memberIds.`);
     if (!batch.memberIds.includes(batch.finalGoalId))
-      fail(`validation batch ${batch.batchId} finalGoalId must be a member.`, "ULW_LOOP_VALIDATION_BATCH_FINAL_NOT_MEMBER");
+      fail2(`validation batch ${batch.batchId} finalGoalId must be a member.`, "ULW_LOOP_VALIDATION_BATCH_FINAL_NOT_MEMBER");
     for (const memberId of batch.memberIds) {
       if (!goalIds.has(memberId))
-        fail(`validation batch ${batch.batchId} references unknown goal: ${memberId}.`, "ULW_LOOP_VALIDATION_BATCH_MEMBER_UNKNOWN");
+        fail2(`validation batch ${batch.batchId} references unknown goal: ${memberId}.`, "ULW_LOOP_VALIDATION_BATCH_MEMBER_UNKNOWN");
       if (members.has(memberId))
-        fail(`goal appears in multiple validation batches: ${memberId}.`, "ULW_LOOP_VALIDATION_BATCH_OVERLAP");
+        fail2(`goal appears in multiple validation batches: ${memberId}.`, "ULW_LOOP_VALIDATION_BATCH_OVERLAP");
       members.add(memberId);
     }
   }
@@ -1081,18 +1827,15 @@ function memberResolved(plan, goalId) {
   const goal = plan.goals.find((candidate) => candidate.id === goalId);
   return goal !== undefined && isMemberResolved(goal, plan);
 }
-function fail(message, code = "ULW_LOOP_VALIDATION_BATCH_INVALID") {
+function fail2(message, code = "ULW_LOOP_VALIDATION_BATCH_INVALID") {
   throw new UlwLoopError(message, code);
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/checkpoint.ts
-var QUALITY_GATE_FS = { existsSync: existsSync3, statSync };
+// components/ulw-loop/src/checkpoint.ts
+var QUALITY_GATE_FS = { existsSync: existsSync5, statSync: statSync2 };
 function ulwLoopFail2(message, code) {
   throw new UlwLoopError(message, code);
 }
-function normalizeObjective3(value) {
-  return value.replace(/\s+/g, " ").trim();
-}
 function nonEmptyEvidence2(value) {
   const trimmed = value.trim();
   return trimmed || ulwLoopFail2("Evidence must be a non-empty string.", "ulw_loop_evidence_required");
@@ -1111,11 +1854,11 @@ async function readJsonInput2(raw, repoRoot) {
     if (!(error instanceof SyntaxError))
       throw error;
   }
-  const path = resolve3(repoRoot, trimmed);
-  if (!existsSync3(path))
+  const path = resolve4(repoRoot, trimmed);
+  if (!existsSync5(path))
     return ulwLoopFail2("Quality gate JSON is neither valid JSON nor a readable path.", "ulw_loop_json_input_invalid");
   try {
-    return JSON.parse(await readFile5(path, "utf8"));
+    return JSON.parse(await readFile3(path, "utf8"));
   } catch (error) {
     return ulwLoopFail2(`Quality gate path does not contain valid JSON${error instanceof Error ? `: ${error.message}` : "."}`, "ulw_loop_json_input_invalid");
   }
@@ -1155,13 +1898,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 watch = qualityGate?.surface === "lazycodex" && qualityGate.codeReview?.codeQualityStatus === "WATCH";
   const entry = {
     at: now,
     kind: ledgerKind2(args.status, goal, aggregateCompletion),
     goalId: goal.id,
     status: goal.status,
-    evidence: watch ? `${args.evidence} | codeQuality=WATCH: ${qualityGate.codeReview.evidence}` : args.evidence
+    evidence: watch && qualityGate.surface === "lazycodex" ? `${args.evidence} | codeQuality=WATCH: ${qualityGate.codeReview?.evidence ?? ""}` : args.evidence
   };
   if (codexGoal !== undefined)
     entry.codexGoal = codexGoal;
@@ -1175,7 +1918,7 @@ function buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletio
     entry.requiredExternalDecision = goal.requiredExternalDecision;
   return entry;
 }
-async function checkpointUlwLoop(repoRoot, args, scope) {
+async function checkpointUlwLoop(repoRoot, args, scope, dependencies) {
   return withUlwLoopMutationLock(repoRoot, scope, async () => {
     const plan = await readUlwLoopPlan(repoRoot, scope);
     const goal = findGoal2(plan, args.goalId);
@@ -1184,6 +1927,8 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
     let aggregateCompletion;
     let qualityGate;
     let codexGoal;
+    let nextActions = [];
+    let warnings = [];
     if (args.status === "complete") {
       const aggregate = codexGoalMode(plan) === "aggregate";
       const final = isFinalRunCompletionCandidate(plan, goal);
@@ -1196,23 +1941,24 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
         requireEssentialCriteriaPass(goal);
       else
         requireAllCriteriaPass(goal);
-      const snapshot = await readCodexGoalSnapshotInput(args.codexGoalJson, repoRoot);
-      const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
-        expectedObjective: expectedCodexObjective(plan, goal),
-        ...aggregate ? { acceptedObjectives: compatibleCodexObjectives(plan) } : {},
-        allowedStatuses: aggregate ? final ? ["complete"] : ["active"] : ["complete"],
-        requireSnapshot: true,
-        requireComplete: !aggregate || final
-      });
-      codexGoal = reconciliation.snapshot.raw;
-      if (!reconciliation.ok) {
-        const objective = snapshot?.objective;
-        const mismatchedTaskObjective = snapshot?.available === true && objective !== undefined && normalizeObjective3(objective) !== normalizeObjective3(expectedCodexObjective(plan, goal));
-        const completedTaskScoped = mismatchedTaskObjective && snapshot.status === "complete" && await canReconcileCompletedTaskScopedAggregateSnapshot(repoRoot, plan, goal, objective, evidence, scope);
-        const activeFinalTaskScoped = mismatchedTaskObjective && snapshot.status === "active" && await canReconcileActiveFinalTaskScopedAggregateSnapshot(repoRoot, plan, goal, objective, evidence, scope);
-        const taskScoped = completedTaskScoped || activeFinalTaskScoped;
-        if (!taskScoped)
-          throw new UlwLoopError(`${formatCodexGoalReconciliation(reconciliation)}${aggregate && snapshot?.status === "complete" && objective !== undefined ? buildTaskScopedAggregateReconciliationHint(goal, final) : ""}`, "ulw_loop_codex_snapshot_mismatch");
+      let codexValidationError;
+      try {
+        const validation = await validateCheckpointCodexGoal({
+          repoRoot,
+          plan,
+          goal,
+          raw: args.codexGoalJson,
+          evidence,
+          ...scope === undefined ? {} : { scope }
+        });
+        codexGoal = validation.raw;
+        nextActions = validation.nextActions;
+        warnings = validation.warnings;
+        acknowledgeDriverObjective(plan, validation.unacknowledgedObjective);
+      } catch (error) {
+        if (!(error instanceof UlwLoopError))
+          throw error;
+        codexValidationError = error;
       }
       if (closesBatch)
         requireBatchFinalReady(plan, goal);
@@ -1221,13 +1967,22 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
       if (final)
         aggregateCompletion = makeAggregateCompletion(now, evidence, codexGoal);
       if (final || aggregateCompletion !== undefined || closesBatch) {
-        qualityGate = validateQualityGate(await readJsonInput2(args.qualityGateJson, repoRoot), {
-          repoRoot,
-          fs: QUALITY_GATE_FS,
-          ...plan.evidenceLayoutVersion === 2 ? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) } : {}
-        });
-        requireBatchGate(plan, goal, qualityGate);
+        try {
+          qualityGate = validateQualityGate(await readJsonInput2(args.qualityGateJson, repoRoot), {
+            repoRoot,
+            fs: QUALITY_GATE_FS,
+            reviewerSurface: dependencies?.surface ?? resolveToolkitSurface(),
+            ...plan.evidenceLayoutVersion === 2 ? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) } : {}
+          });
+          requireBatchGate(plan, goal, qualityGate);
+        } catch (error) {
+          if (!(error instanceof UlwLoopError) || codexValidationError === undefined)
+            throw error;
+          throw combineCheckpointValidationErrors(codexValidationError, error);
+        }
       }
+      if (codexValidationError !== undefined)
+        throw codexValidationError;
       goal.status = "complete";
       goal.completedAt = now;
       goal.evidence = evidence;
@@ -1241,30 +1996,155 @@ async function checkpointUlwLoop(repoRoot, args, scope) {
     goal.updatedAt = now;
     if (aggregateCompletion !== undefined)
       plan.aggregateCompletion = aggregateCompletion;
+    if (aggregateCompletion !== undefined)
+      nextActions = [...nextActions, 'aggregate complete — now update_goal({status:"complete"})'];
     plan.updatedAt = now;
-    await writePlan(repoRoot, plan, scope);
     const ledgerEntry = buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletion);
-    await appendLedger(repoRoot, ledgerEntry, scope);
+    const entries = [ledgerEntry];
     const closedBatch = args.status === "complete" ? batchClosedBy(plan, goal.id) : undefined;
     if (closedBatch !== undefined)
-      await appendLedger(repoRoot, { at: now, kind: "batch_closed", goalId: goal.id, message: closedBatch.batchId }, scope);
-    return aggregateCompletion === undefined ? { plan, goal, ledgerEntry } : { plan, goal, ledgerEntry, aggregateCompletion };
+      entries.push({ at: now, kind: "batch_closed", goalId: goal.id, message: closedBatch.batchId });
+    await commit(repoRoot, scope, { plan, entries });
+    return aggregateCompletion === undefined ? { plan, goal, ledgerEntry, nextActions, warnings } : { plan, goal, ledgerEntry, aggregateCompletion, nextActions, warnings };
   });
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/cli-output.ts
+// components/ulw-loop/src/checkpoint-template.ts
+function artifactPath(base, name) {
+  return `${base}/${name}`;
+}
+function gateTemplate(surface, base) {
+  const artifacts = [
+    {
+      id: "artifact-cli",
+      kind: "cli-transcript",
+      description: "<replace:artifact description>",
+      path: artifactPath(base, "cli-transcript.txt")
+    },
+    {
+      id: "artifact-data",
+      kind: "data-diff",
+      description: "<replace:artifact description>",
+      path: artifactPath(base, "data-diff.txt")
+    }
+  ];
+  const manualQa = {
+    by: "main-session",
+    status: "passed",
+    evidence: "<replace:manual QA evidence>",
+    surfaceEvidence: [
+      {
+        id: "surface-cli",
+        criterionRef: "<replace:criterion id>",
+        surface: "cli",
+        invocation: "<replace:command>",
+        verdict: "passed",
+        artifactRefs: ["artifact-cli"]
+      },
+      {
+        id: "surface-data",
+        criterionRef: "<replace:criterion id>",
+        surface: "data",
+        invocation: "<replace:command>",
+        verdict: "passed",
+        artifactRefs: ["artifact-data"]
+      }
+    ],
+    adversarialCases: [
+      {
+        id: "<replace:adversarial case id>",
+        criterionRef: "<replace:criterion id>",
+        scenario: "<replace:scenario>",
+        expectedBehavior: "<replace:expected behavior>",
+        verdict: "not_applicable",
+        reason: "<replace:reason>",
+        artifactRefs: ["artifact-cli"]
+      }
+    ],
+    artifactRefs: artifacts
+  };
+  const common = {
+    manualQa,
+    gateReview: {
+      by: surface === "omo-senpi" ? "category:deep-high" : "main-session",
+      recommendation: "APPROVE",
+      reportPath: artifactPath(base, "gate-review.md"),
+      evidence: "<replace:gate review evidence>",
+      blockers: [],
+      notes: []
+    },
+    iteration: {
+      fullRerun: true,
+      status: "passed",
+      rerunCommands: ["<replace:verification command>"],
+      evidence: "<replace:iteration evidence>"
+    },
+    criteriaCoverage: {
+      totalCriteria: 0,
+      passCount: 0,
+      originalIntent: "<replace:original intent>",
+      desiredOutcome: "<replace:desired outcome>",
+      userOutcomeReview: "<replace:user outcome review>",
+      adversarialClassesCovered: ["<replace:adversarial class>"]
+    }
+  };
+  return common;
+}
+async function checkpointTemplate(repoRoot, scope, goalId, dependencies) {
+  const plan = await readUlwLoopPlan(repoRoot, scope);
+  const surface = dependencies?.surface ?? resolveToolkitSurface();
+  const targetId = goalId ?? plan.activeGoalId;
+  const active = plan.goals.find((goal) => goal.id === targetId);
+  if (goalId !== undefined && active === undefined)
+    throw new UlwLoopError(`Unknown ulw-loop id: ${goalId}.`, "ULW_LOOP_GOAL_NOT_FOUND", { details: { goalId } });
+  const hasAttempt = plan.evidenceLayoutVersion === 2 && active !== undefined;
+  const attemptDir = hasAttempt ? ulwLoopAttemptEvidenceDir(active.id, active.attempt, scope) : ".omo/evidence";
+  const guidance = [
+    "codex-goal-json requires goal.objective to equal the plan's codexObjective verbatim; do not paraphrase it.",
+    "Fill every <replace:...> value with plausible non-empty evidence and use real, non-empty artifact files.",
+    'Passing codex-goal-json example: {"goal":{"objective":"<plan codexObjective verbatim>","status":"complete"}}.',
+    'Passing quality-gate-json example requires gateReview {"by":"category:deep-high","recommendation":"APPROVE","evidence":"review passed","reportPath":"<attemptDir>/gate-review.md","blockers":[],"notes":[]}, manualQa.artifactRefs objects, iteration, and criteriaCoverage.',
+    ...surface === "lazycodex" ? [
+      "Self-review defaults: manualQa.by and gateReview.by are main-session. Alternatives: manualQa.by accepts lazycodex-qa-executor; gateReview.by accepts lazycodex-gate-reviewer, category:deep-high, category:deep-low, category:unspecified-high, or category:unspecified-low. Optional codeReview.by accepts lazycodex-code-reviewer or main-session."
+    ] : [],
+    ...hasAttempt ? [] : ["This plan is evidence-layout v1; artifacts go under .omo/evidence/."]
+  ].join(" ");
+  return {
+    qualityGateTemplate: gateTemplate(surface, attemptDir),
+    codexGoalTemplate: {
+      goal: { objective: plan.codexObjective ?? "<replace:codex objective>", status: "complete" }
+    },
+    guidance,
+    ...hasAttempt ? { attemptDir } : {}
+  };
+}
+
+// components/ulw-loop/src/cli-output.ts
 var ULW_LOOP_HELP = `Usage:
+  omo-agent-toolkit hook user-prompt-submit [--with-ultrawork]  (Codex UserPromptSubmit hook)
+  omo-agent-toolkit help | --help | -h                          (this message)
+  omo-agent-toolkit ulw-loop help
   omo-agent-toolkit ulw-loop create-goals --brief "..." [--brief-file <path>] [--from-stdin] [--codex-goal-mode aggregate|per_story] [--validation-batch-json <json-or-path>] [--force] [--json]
   omo-agent-toolkit ulw-loop status [--json]
   omo-agent-toolkit ulw-loop complete-goals [--retry-failed] [--json]
   omo-agent-toolkit ulw-loop criteria --goal-id <id> [--json]
   omo-agent-toolkit ulw-loop record-evidence --goal-id <id> --criterion-id <id> --status pass|fail|blocked --evidence "..." [--notes "..."] [--json]
+  omo-agent-toolkit ulw-loop checkpoint --print-template [--goal-id <id>] [--json]
   omo-agent-toolkit ulw-loop checkpoint --goal-id <id> --status complete|failed|blocked --evidence "..." --codex-goal-json <...> [--quality-gate-json <...>] [--no-advance] [--json]
   omo-agent-toolkit ulw-loop steer --kind <kind> ... --evidence "..." --rationale "..." [--proposals-json <json-or-path>] [--json]
   omo-agent-toolkit ulw-loop add-goal --title "..." --objective "..." [--json]
   omo-agent-toolkit ulw-loop record-review-blockers --goal-id <id> --title "..." --objective "..." --evidence "..." --codex-goal-json <...> [--json]
 
-All subcommands accept [--session-id <id>] to isolate state under .omo/ulw-loop/<id>/; without it, Codex session env is used when present.`;
+Every state subcommand needs a session scope: [--session-id <id>] or the session env (OMO_ULW_LOOP_SESSION_ID / CODEX_SESSION_ID / CODEX_THREAD_ID / PI_SESSION_ID); state lives under .omo/ulw-loop/<id>/ and the unscoped root is never used implicitly. status --json exposes the currentAttemptDir; put all quality-gate artifacts under it.
+Every subcommand accepts --help | -h to print its own usage line.`;
+function subcommandHelp(subcommand) {
+  const lines = ULW_LOOP_HELP.split(`
+`).filter((line) => line.trimStart().startsWith(`omo-agent-toolkit ulw-loop ${subcommand}`));
+  if (lines.length === 0)
+    return ULW_LOOP_HELP;
+  return ["Usage:", ...lines].join(`
+`);
+}
 function printJson(value) {
   process.stdout.write(`${JSON.stringify(value, null, 2)}
 `);
@@ -1330,17 +2210,18 @@ function normalizeCodexGoalMode(value) {
   throw new UlwLoopError("Invalid --codex-goal-mode; expected aggregate or per_story.", "ULW_LOOP_CODEX_GOAL_MODE_INVALID", { details: { value } });
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/codex-goal-instruction.ts
+// components/ulw-loop/src/codex-goal-instruction.ts
 function buildCodexGoalInstruction(args) {
   const mode = codexGoalMode(args.plan);
   const createGoal = buildCreateGoalPayload(args.plan, args.goal);
   const isFinal = args.isFinal ?? isFinalRunCompletionCandidate(args.plan, args.goal);
-  return { text: buildText(mode, args.plan, args.goal, createGoal, isFinal), json: createGoal };
+  const surface = args.surface ?? resolveToolkitSurface();
+  return { text: buildText(mode, args.plan, args.goal, createGoal, isFinal, surface), json: createGoal };
 }
 function buildCreateGoalPayload(plan, goal) {
   return { objective: expectedCodexObjective(plan, goal) };
 }
-function buildText(mode, plan, goal, createGoal, isFinal) {
+function buildText(mode, plan, goal, createGoal, isFinal, surface) {
   return joinLines([
     mode === "aggregate" ? "UlwLoop aggregate-goal handoff" : "UlwLoop active-goal handoff",
     `Mode: ${mode}`,
@@ -1357,7 +2238,7 @@ function buildText(mode, plan, goal, createGoal, isFinal) {
     "- Goals are unlimited. Do not add numeric limits.",
     ...modeConstraintLines(mode, isFinal),
     ...evidenceLayoutLines(plan),
-    finalSection(plan, goal, isFinal, mode === "aggregate"),
+    finalSection(plan, goal, isFinal, mode === "aggregate", surface),
     ...checkpointLines(plan, mode),
     "",
     "create_goal payload:",
@@ -1409,19 +2290,21 @@ function evidenceLayoutLines(plan) {
     "- Evidence layout v2: write every artifact for the active goal (QA matrix, review reports, receipts) under the current attempt directory — read currentAttemptDir from `omo-agent-toolkit 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) {
+function finalSection(plan, goal, isFinal, aggregate, surface) {
+  const roles = reviewerRolesFor(surface);
   if (!isFinal)
     return "- This is not the final ulw-loop story; do not run the final reviewer/manual-QA/gate-review quality gate yet.";
   const option = sessionOption(plan);
+  if (surface === "omo-senpi")
+    return senpiFinalSection(plan, goal, aggregate);
   const blockerCommand = `omo-agent-toolkit ulw-loop record-review-blockers${option} --goal-id ${goal.id} --title "Resolve final code-review blockers" --objective "<blocker-resolution objective>" --evidence "<review findings>" --codex-goal-json "<active get_goal JSON or path>"`;
   const checkpointCommand = `omo-agent-toolkit ulw-loop checkpoint${option} --goal-id ${goal.id} --status complete --evidence "<targeted verification/manualQa/gateReview evidence>" --codex-goal-json "<fresh complete get_goal JSON or path>" --quality-gate-json "<quality gate JSON or path>"`;
   return joinLines([
-    "Final story — run mandatory quality gate before update_goal:",
+    "Final story — self-review and manual QA are the default; use the quality gate before update_goal:",
     "- Run targeted verification for changed behavior.",
     "- Confirm every manualQa artifact path exists and has non-zero size.",
-    '- 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.",
+    `- Run manual QA yourself and write its artifact under currentAttemptDir. Only if the user explicitly demands strict, rigorous, or high-accuracy review, spawn ${roles.gateReview}, optionally also ${roles.codeReview} and ${roles.manualQa}; otherwise set manualQa.by and gateReview.by to "main-session".`,
+    "- Require passed manualQa, approved gateReview, passed iteration, and complete criteriaCoverage; include codeReview only when strict review was requested. 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:",
@@ -1430,6 +2313,20 @@ function finalSection(plan, goal, isFinal, aggregate) {
     `  ${checkpointCommand}`
   ]);
 }
+function senpiFinalSection(plan, goal, aggregate) {
+  const option = sessionOption(plan);
+  const checkpointCommand = `omo-agent-toolkit ulw-loop checkpoint${option} --goal-id ${goal.id} --status complete --evidence "<manualQa/gateReview evidence>" --codex-goal-json "<fresh complete get_goal JSON or path>" --quality-gate-json "$(omo-agent-toolkit ulw-loop checkpoint${option} --print-template)"`;
+  return joinLines([
+    "Final story — run the single-reviewer quality gate before update_goal:",
+    '- Run manual QA yourself and write the non-empty artifact under currentAttemptDir; set manualQa.by to "main-session".',
+    '- Spawn exactly one gate reviewer with task(category: "deep-high").',
+    "- If that task fails with any model_unavailable failure, retry with category:deep-low, then category:unspecified-high, then category:unspecified-low.",
+    "- Set gateReview.by to the exact category:<name> literal used for the successful task.",
+    "- Build the gate JSON with omo-agent-toolkit ulw-loop checkpoint --print-template, then fill manualQa, gateReview, iteration, and criteriaCoverage.",
+    '- Require passed manualQa, approved gateReview, passed iteration, and complete criteriaCoverage before update_goal({status: "complete"}).',
+    aggregate ? `- If the gate is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint the aggregate story: ${checkpointCommand}` : `- If the gate is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint: ${checkpointCommand}`
+  ]);
+}
 function sessionOption(plan) {
   const prefix = ".omo/ulw-loop/";
   const suffix = "/goals.json";
@@ -1443,15 +2340,53 @@ function joinLines(lines) {
 `);
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/plan-crud.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+// components/ulw-loop/src/success-criteria-input.ts
+function invalid2(message, details) {
+  throw new UlwLoopError(`Invalid successCriteria: ${message}`, "ULW_LOOP_ARGUMENT_INVALID", { details });
+}
+function isUserModel(value) {
+  return typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model) => model === value);
+}
+function requireText(value, field, index) {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed || invalid2(`entry ${index + 1} needs a non-empty ${field}.`, { index, field });
+}
+function criterionId(index) {
+  return `C${String(index + 1).padStart(3, "0")}`;
+}
+function criteriaFromInput(input) {
+  if (input.length === 0)
+    invalid2("provide at least one criterion or omit the field for placeholders.", { count: 0 });
+  return input.map((entry, index) => {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+      return invalid2(`entry ${index + 1} must be an object.`, { index });
+    const record = { ...entry };
+    const userModel = record["userModel"] ?? "happy";
+    if (!isUserModel(userModel))
+      return invalid2(`entry ${index + 1} userModel must be one of ${ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.join(", ")}.`, {
+        index,
+        userModel: String(userModel)
+      });
+    const essential = record["essential"];
+    if (essential !== undefined && typeof essential !== "boolean")
+      return invalid2(`entry ${index + 1} essential must be a boolean.`, { index });
+    return {
+      id: criterionId(index),
+      scenario: requireText(record["scenario"], "scenario", index),
+      userModel,
+      expectedEvidence: requireText(record["expectedEvidence"], "expectedEvidence", index),
+      essential: essential ?? true,
+      capturedEvidence: null,
+      status: "pending"
+    };
+  });
+}
 
-// packages/omo-codex/plugin/components/ulw-loop/src/plan-goal-factory.ts
+// components/ulw-loop/src/plan-goal-factory.ts
 function cleanLine(line) {
   return line.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "").trim();
 }
-function normalizeObjective4(value) {
+function normalizeObjective2(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function titleFromObjective(objective, fallback) {
@@ -1471,72 +2406,72 @@ function assertNonEmpty(value, label) {
 function truncateObjective(objective) {
   return objective.length > 80 ? `${objective.slice(0, 77).trimEnd()}...` : objective;
 }
-function seedDefaultSuccessCriteria(goalIndex, objective) {
-  const subject = truncateObjective(normalizeObjective4(objective) || `Goal ${goalIndex + 1}`);
+function replaceVia(goalId, id, surface) {
+  return surface === "omo-senpi" ? `Replace via agentToolkit.steer({ kind: "revise_criterion", source: "finding", goalId: "${goalId}", criterionId: "${id}", scenario, expectedEvidence, evidence, rationale }) (or pass successCriteria to addGoal)` : `Replace via omo-agent-toolkit ulw-loop steer --kind revise_criterion --goal-id ${goalId} --criterion-id ${id} --scenario "<scenario>" --expected-evidence "<proof>" --evidence "<why>" --rationale "<why>"`;
+}
+function seedDefaultSuccessCriteria(goalIndex, objective, options = {}) {
+  const subject = truncateObjective(normalizeObjective2(objective) || `Goal ${goalIndex + 1}`);
+  const goalId = options.goalId ?? `G${String(goalIndex + 1).padStart(3, "0")}`;
+  const surface = options.surface ?? "lazycodex";
   const rows = [
+    ["happy", `happy path for: ${subject}`, `observable happy-path proof for goal ${goalIndex + 1}`, true],
+    ["edge", "edge case (boundary/empty/malformed)", `boundary or malformed-input proof for: ${subject}`, true],
     [
-      "C001",
-      "happy",
-      `happy path for: ${subject}`,
-      `Replace via revise_criterion with observable happy-path proof for goal ${goalIndex + 1}.`,
-      true
-    ],
-    [
-      "C002",
-      "edge",
-      "edge case (boundary/empty/malformed)",
-      `Replace via revise_criterion with boundary or malformed-input proof for: ${subject}.`,
-      true
-    ],
-    [
-      "C003",
       "regression",
       "regression: adjacent surface still works",
-      `Replace via revise_criterion with regression proof for neighboring behavior after: ${subject}.`,
+      `regression proof for neighboring behavior after: ${subject}`,
       false
     ]
   ];
-  return rows.map(([id, userModel, scenario, expectedEvidence, essential]) => ({
-    id,
-    scenario,
-    userModel,
-    expectedEvidence,
-    essential,
-    capturedEvidence: null,
-    status: "pending"
-  }));
+  return rows.map(([userModel, scenario, proof, essential], index) => {
+    const id = criterionId(index);
+    return {
+      id,
+      scenario,
+      userModel,
+      expectedEvidence: `${replaceVia(goalId, id, surface)} with ${proof}.`,
+      essential,
+      capturedEvidence: null,
+      status: "pending"
+    };
+  });
 }
 function deriveGoalCandidates(brief) {
-  const bulletGoals = brief.split(/\r?\n/).map((line) => ({ original: line, cleaned: normalizeObjective4(cleanLine(line)) })).filter(({ cleaned }) => cleaned.length > 0 && cleaned.length <= 1200).filter(({ original, cleaned }, index, all) => /^\s*(?:[-*+]\s+|\d+[.)]\s+)/.test(original) && all.findIndex((candidate) => candidate.cleaned === cleaned) === index).map(({ cleaned }) => cleaned);
-  const paragraphs = brief.split(/\n\s*\n/).map(normalizeObjective4).filter((paragraph) => paragraph.length > 0 && !paragraph.startsWith("#"));
+  const bulletGoals = brief.split(/\r?\n/).map((line) => ({ original: line, cleaned: normalizeObjective2(cleanLine(line)) })).filter(({ cleaned }) => cleaned.length > 0 && cleaned.length <= 1200).filter(({ original, cleaned }, index, all) => /^\s*(?:[-*+]\s+|\d+[.)]\s+)/.test(original) && all.findIndex((candidate) => candidate.cleaned === cleaned) === index).map(({ cleaned }) => cleaned);
+  const paragraphs = brief.split(/\n\s*\n/).map(normalizeObjective2).filter((paragraph) => paragraph.length > 0 && !paragraph.startsWith("#"));
   const selected = (bulletGoals.length > 0 ? bulletGoals : paragraphs).length > 0 ? bulletGoals.length > 0 ? bulletGoals : paragraphs : ["Complete the requested project objective."];
   return selected.map((objective, index) => ({
     title: titleFromObjective(objective, `Goal ${index + 1}`),
     objective
   }));
 }
-function makeGoal(title, objective, index, now) {
+function makeGoal(title, objective, index, now, options = {}) {
   const cleanTitle = assertNonEmpty(title, "title");
   const cleanObjective = assertNonEmpty(objective, "objective");
+  const id = normalizeGoalId(cleanTitle, index);
+  const successCriteria = options.successCriteria === undefined ? seedDefaultSuccessCriteria(index, cleanObjective, {
+    goalId: id,
+    ...options.surface === undefined ? {} : { surface: options.surface }
+  }) : criteriaFromInput(options.successCriteria);
   return {
-    id: normalizeGoalId(cleanTitle, index),
+    id,
     title: cleanTitle,
     objective: cleanObjective,
     status: "pending",
-    successCriteria: seedDefaultSuccessCriteria(index, cleanObjective),
+    successCriteria,
     attempt: 0,
     createdAt: now,
     updatedAt: now
   };
 }
-function appendGoalToPlan(plan, title, objective, now) {
-  const goal = makeGoal(title, objective, plan.goals.length, now);
+function appendGoalToPlan(plan, title, objective, now, options = {}) {
+  const goal = makeGoal(title, objective, plan.goals.length, now, options);
   plan.goals.push(goal);
   plan.updatedAt = now;
   return goal;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/plan-crud.ts
+// components/ulw-loop/src/plan-crud.ts
 function isScheduleEligible(goal) {
   return goal.steeringStatus !== "superseded" && goal.steeringStatus !== "blocked";
 }
@@ -1552,18 +2487,31 @@ function clearGoalBlockerFields2(goal) {
   ])
     delete goal[key];
 }
-async function createUlwLoopPlan(repoRoot, args, scope) {
+async function createUlwLoopPlan(repoRoot, args, scope, surface = "lazycodex") {
   return withUlwLoopMutationLock(repoRoot, scope, async () => {
-    if (!args.force && existsSync4(ulwLoopGoalsPath(repoRoot, scope))) {
-      const existing = await readUlwLoopPlan(repoRoot, scope);
+    let existing;
+    if (planExists(repoRoot, scope)) {
+      try {
+        existing = await readUlwLoopPlan(repoRoot, scope);
+      } catch (error) {
+        if (!args.force)
+          throw error;
+      }
+    }
+    if (!args.force && existing !== undefined) {
       if (isUlwLoopDone(existing))
-        throw completedPlanExistsError(scope);
+        throw completedPlanExistsError(scope, surface);
       throw new UlwLoopError(`Refusing to overwrite existing ${ulwLoopGoalsRelativePath(scope)}; pass --force to recreate it.`, "ULW_LOOP_PLAN_EXISTS");
     }
     const now = iso();
-    const goals = deriveGoalCandidates(args.brief).map((goal, index) => makeGoal(goal.title, goal.objective, index, now));
+    const goals = deriveGoalCandidates(args.brief).map((goal, index) => makeGoal(goal.title, goal.objective, index, now, { surface }));
     const plan = {
       version: 1,
+      revision: existing?.revision ?? 0,
+      ledgerResetRevision: (existing?.revision ?? 0) + 1,
+      brief: args.brief.endsWith(`
+`) ? args.brief : `${args.brief}
+`,
       evidenceLayoutVersion: 2,
       createdAt: now,
       updatedAt: now,
@@ -1578,30 +2526,37 @@ async function createUlwLoopPlan(repoRoot, args, scope) {
       plan.validationBatches = validationBatches;
     if (plan.codexGoalMode === "aggregate")
       plan.codexObjective = aggregateCodexObjectiveForScope(scope);
-    await mkdir2(ulwLoopDir(repoRoot, scope), { recursive: true });
-    await writeFile2(ulwLoopBriefPath(repoRoot, scope), args.brief.endsWith(`
-`) ? args.brief : `${args.brief}
-`, "utf8");
-    await writePlan(repoRoot, plan, scope);
-    await writeFile2(ulwLoopLedgerPath(repoRoot, scope), "", "utf8");
-    await appendLedger(repoRoot, { at: now, kind: "plan_created", message: `${goals.length} goal(s) created` }, scope);
+    await beforePlanMutation();
+    await commit(repoRoot, scope, {
+      plan,
+      entries: [{ at: now, kind: "plan_created", message: `${goals.length} goal(s) created` }]
+    });
     return plan;
   });
 }
-function completedPlanExistsError(scope) {
+function completedPlanExistsError(scope, surface) {
   return new UlwLoopError([
     `Existing ulw-loop aggregate is already complete at ${ulwLoopGoalsRelativePath(scope)}.`,
-    "Start a new run with `omo-agent-toolkit ulw-loop create-goals --session-id <new-id> ...` to isolate fresh state.",
-    "Use --force only when you intentionally want to overwrite the completed evidence."
+    ...surface === "omo-senpi" ? [
+      "Start a new run under a fresh session id (a new senpi session) or call agentToolkit.createGoals({ brief, force: true }) to recreate."
+    ] : [
+      "Start a new run with `omo-agent-toolkit ulw-loop create-goals --session-id <new-id> ...` to isolate fresh state.",
+      "Use --force only when you intentionally want to overwrite the completed evidence."
+    ]
   ].join(" "), "ULW_LOOP_PLAN_EXISTS_COMPLETE");
 }
-async function addUlwLoopGoal(repoRoot, args, scope) {
+async function addUlwLoopGoal(repoRoot, args, scope, surface = "lazycodex") {
   return withUlwLoopMutationLock(repoRoot, scope, async () => {
     const plan = await readUlwLoopPlan(repoRoot, scope);
     const now = iso();
-    const goal = appendGoalToPlan(plan, args.title, args.objective, now);
-    await writePlan(repoRoot, plan, scope);
-    await appendLedger(repoRoot, { at: now, kind: "goal_added", goalId: goal.id, status: goal.status, message: goal.title }, scope);
+    const goal = appendGoalToPlan(plan, args.title, args.objective, now, {
+      surface,
+      ...args.successCriteria === undefined ? {} : { successCriteria: args.successCriteria }
+    });
+    await commit(repoRoot, scope, {
+      plan,
+      entries: [{ at: now, kind: "goal_added", goalId: goal.id, status: goal.status, message: goal.title }]
+    });
     return { plan, goal };
   });
 }
@@ -1614,17 +2569,18 @@ async function startNextUlwLoop(repoRoot, args = {}, scope) {
     const existing = plan.goals.find((goal) => goal.status === "in_progress" && isScheduleEligible(goal));
     if (existing)
       return { plan, goal: existing, resumed: true };
+    const entries = [];
     let next = plan.goals.find((goal) => goal.status === "pending" && isScheduleEligible(goal));
     if (!next && args.retryFailed) {
       next = plan.goals.find((goal) => goal.status === "failed" && !goal.nonRetriable && isScheduleEligible(goal));
       if (next)
-        await appendLedger(repoRoot, {
+        entries.push({
           at: now,
           kind: "goal_retried",
           goalId: next.id,
           status: "pending",
           ...next.failureReason ? { message: next.failureReason } : {}
-        }, scope);
+        });
     }
     if (!next)
       return { done: true, plan };
@@ -1635,8 +2591,14 @@ async function startNextUlwLoop(repoRoot, args = {}, scope) {
     next.updatedAt = now;
     plan.activeGoalId = next.id;
     plan.updatedAt = now;
-    await writePlan(repoRoot, plan, scope);
-    await appendLedger(repoRoot, { at: now, kind: "goal_started", goalId: next.id, status: next.status, message: `Attempt ${next.attempt}` }, scope);
+    entries.push({
+      at: now,
+      kind: "goal_started",
+      goalId: next.id,
+      status: next.status,
+      message: `Attempt ${next.attempt}`
+    });
+    await commit(repoRoot, scope, { plan, entries });
     return { plan, goal: next, resumed: false };
   });
 }
@@ -1663,7 +2625,7 @@ function summarizeUlwLoopPlan(plan) {
   };
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/checkpoint-continuation.ts
+// components/ulw-loop/src/checkpoint-continuation.ts
 async function checkpointAndContinue(repoRoot, args, scope) {
   const result = await checkpointUlwLoop(repoRoot, args, scope);
   if (args.status !== "complete" || result.aggregateCompletion !== undefined || !args.advance)
@@ -1675,13 +2637,18 @@ async function checkpointAndContinue(repoRoot, args, scope) {
   return { ...result, plan: next.plan, next: { resumed: next.resumed, goal: next.goal, instruction } };
 }
 async function checkpoint(repoRoot, argv, json, scope) {
+  if (hasFlag(argv, "--print-template")) {
+    const template = await checkpointTemplate(repoRoot, scope, readValue(argv, "--goal-id"));
+    if (json)
+      printJson({ ok: true, ...template });
+    else
+      printJson(template);
+    return 0;
+  }
   const goalId = required2(argv, "--goal-id");
   const statusValue = checkpointStatus(required2(argv, "--status"));
   const evidence = required2(argv, "--evidence");
-  const codexGoalJson = await parseCodexGoalJson(statusValue === "complete" ? required2(argv, "--codex-goal-json") : readValue(argv, "--codex-goal-json"));
-  if (statusValue === "complete" && codexGoalJson === undefined) {
-    throw new UlwLoopError("Missing --codex-goal-json.", "ULW_LOOP_CODEX_GOAL_JSON_REQUIRED");
-  }
+  const codexGoalJson = await parseCodexGoalJson(readValue(argv, "--codex-goal-json"));
   const qualityGateJson = readValue(argv, "--quality-gate-json");
   const args = {
     goalId,
@@ -1726,10 +2693,10 @@ function checkpointStatus(value) {
   throw new UlwLoopError("Missing or invalid --status; expected complete, failed, or blocked.", "ULW_LOOP_STATUS_INVALID", { details: { status: value } });
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/cli-subcommands.ts
-import { readFile as readFile6 } from "node:fs/promises";
+// components/ulw-loop/src/cli-subcommands.ts
+import { readFile as readFile4 } from "node:fs/promises";
 
-// packages/omo-codex/plugin/components/ulw-loop/src/cli-steering.ts
+// components/ulw-loop/src/cli-steering.ts
 var SOURCES = ["user_prompt_submit", "finding", "cli"];
 var STEERING_KIND_HELP = [
   `Allowed --kind values: ${ULW_LOOP_STEERING_MUTATION_KINDS.join(", ")}`,
@@ -1753,7 +2720,7 @@ function isSource(value) {
 function isModel(value) {
   return ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model) => model === value);
 }
-function fail2(message, code, details) {
+function fail3(message, code, details) {
   throw new UlwLoopError(message, code, { details });
 }
 function kindMessage(prefix) {
@@ -1767,15 +2734,15 @@ function text2(value, field) {
   const trimmed = value.trim();
   if (trimmed.length > 0)
     return trimmed;
-  return fail2(`Empty ${field}.`, "ULW_LOOP_STEERING_FIELD_EMPTY", { field });
+  return fail3(`Empty ${field}.`, "ULW_LOOP_STEERING_FIELD_EMPTY", { field });
 }
 function required3(argv, flag) {
   const value = text2(readValue(argv, flag), flag);
-  return value ?? fail2(`Missing ${flag}.`, "ULW_LOOP_STEERING_FIELD_REQUIRED", { flag });
+  return value ?? fail3(`Missing ${flag}.`, "ULW_LOOP_STEERING_FIELD_REQUIRED", { flag });
 }
 function requiredGoal(argv) {
   const value = text2(parseGoalArg(argv), "--goal-id");
-  return value ?? fail2("Missing --goal-id.", "ULW_LOOP_GOAL_ID_REQUIRED", { flag: "--goal-id" });
+  return value ?? fail3("Missing --goal-id.", "ULW_LOOP_GOAL_ID_REQUIRED", { flag: "--goal-id" });
 }
 function readObject(value, key) {
   return Object.entries(value).find(([name]) => name === key)?.[1];
@@ -1799,7 +2766,7 @@ function objectChildren(value, key) {
   for (const item of candidate) {
     const next = child(item);
     if (next === null)
-      return fail2(`${key} entries require title/objective.`, "ULW_LOOP_STEERING_CHILD_INVALID", { key });
+      return fail3(`${key} entries require title/objective.`, "ULW_LOOP_STEERING_CHILD_INVALID", { key });
     parsed.push(next);
   }
   return parsed;
@@ -1814,13 +2781,13 @@ function parseSteeringKind(argv) {
   const value = readValue(argv, "--kind");
   if (isKind(value))
     return value;
-  return value === undefined ? fail2(kindMessage("Missing --kind."), "ULW_LOOP_STEERING_KIND_REQUIRED", { flag: "--kind", expected: ULW_LOOP_STEERING_MUTATION_KINDS, usage: STEERING_KIND_HELP }) : fail2(kindMessage(`Invalid --kind: ${value}.`), "ULW_LOOP_STEERING_KIND_INVALID", { value, expected: ULW_LOOP_STEERING_MUTATION_KINDS, usage: STEERING_KIND_HELP });
+  return value === undefined ? fail3(kindMessage("Missing --kind."), "ULW_LOOP_STEERING_KIND_REQUIRED", { flag: "--kind", expected: ULW_LOOP_STEERING_MUTATION_KINDS, usage: STEERING_KIND_HELP }) : fail3(kindMessage(`Invalid --kind: ${value}.`), "ULW_LOOP_STEERING_KIND_INVALID", { value, expected: ULW_LOOP_STEERING_MUTATION_KINDS, usage: STEERING_KIND_HELP });
 }
 function parseSteeringSource(argv) {
   const value = readValue(argv, "--source");
   if (value === undefined)
     return "cli";
-  return isSource(value) ? value : fail2(`Invalid --source: ${value}.`, "ULW_LOOP_STEERING_SOURCE_INVALID", { value, expected: SOURCES });
+  return isSource(value) ? value : fail3(`Invalid --source: ${value}.`, "ULW_LOOP_STEERING_SOURCE_INVALID", { value, expected: SOURCES });
 }
 function child(value) {
   if (!isPlain(value))
@@ -1837,12 +2804,12 @@ async function children(argv, flag, needed) {
     return [];
   const raw = await readJsonInput(input);
   if (!Array.isArray(raw))
-    return fail2(`${flag} must be a JSON array.`, "ULW_LOOP_STEERING_JSON_ARRAY_REQUIRED", { flag });
+    return fail3(`${flag} must be a JSON array.`, "ULW_LOOP_STEERING_JSON_ARRAY_REQUIRED", { flag });
   const parsed = [];
   for (const item of raw) {
     const next = child(item);
     if (next === null)
-      return fail2(`${flag} entries require title/objective.`, "ULW_LOOP_STEERING_CHILD_INVALID", { flag });
+      return fail3(`${flag} entries require title/objective.`, "ULW_LOOP_STEERING_CHILD_INVALID", { flag });
     parsed.push(next);
   }
   return parsed;
@@ -1850,11 +2817,11 @@ async function children(argv, flag, needed) {
 async function stringArray2(argv, flag) {
   const raw = await readJsonInput(required3(argv, flag));
   if (!Array.isArray(raw))
-    return fail2(`${flag} must be a JSON array.`, "ULW_LOOP_STEERING_JSON_ARRAY_REQUIRED", { flag });
+    return fail3(`${flag} must be a JSON array.`, "ULW_LOOP_STEERING_JSON_ARRAY_REQUIRED", { flag });
   const values = [];
   for (const item of raw) {
     if (typeof item !== "string")
-      return fail2(`${flag} entries must be strings.`, "ULW_LOOP_STEERING_STRING_ARRAY_REQUIRED", { flag });
+      return fail3(`${flag} entries must be strings.`, "ULW_LOOP_STEERING_STRING_ARRAY_REQUIRED", { flag });
     values.push(text2(item, flag) ?? "");
   }
   return values;
@@ -1863,10 +2830,10 @@ function model(value) {
   const trimmed = text2(value, "--user-model");
   if (trimmed === undefined)
     return;
-  return isModel(trimmed) ? trimmed : fail2(`Invalid --user-model: ${trimmed}.`, "ULW_LOOP_STEERING_USER_MODEL_INVALID", { value: trimmed, expected: ULW_LOOP_SUCCESS_CRITERION_USER_MODELS });
+  return isModel(trimmed) ? trimmed : fail3(`Invalid --user-model: ${trimmed}.`, "ULW_LOOP_STEERING_USER_MODEL_INVALID", { value: trimmed, expected: ULW_LOOP_SUCCESS_CRITERION_USER_MODELS });
 }
 function neverKind(kind) {
-  return fail2(`Unsupported steering kind: ${String(kind)}.`, "ULW_LOOP_STEERING_KIND_UNSUPPORTED", { kind });
+  return fail3(`Unsupported steering kind: ${String(kind)}.`, "ULW_LOOP_STEERING_KIND_UNSUPPORTED", { kind });
 }
 async function parseSteeringProposal(argv) {
   const kind = parseSteeringKind(argv);
@@ -1887,7 +2854,7 @@ async function parseSteeringProposal(argv) {
       const revisedTitle = readValue(argv, "--title");
       const revisedObjective = readValue(argv, "--objective");
       if (revisedTitle === undefined && revisedObjective === undefined)
-        return fail2("revise_pending_wording requires --title or --objective.", "ULW_LOOP_STEERING_UPDATE_REQUIRED", { kind });
+        return fail3("revise_pending_wording requires --title or --objective.", "ULW_LOOP_STEERING_UPDATE_REQUIRED", { kind });
       return normalizeSteeringProposal({ ...base, goalId, targetGoalId: goalId, ...revisedTitle === undefined ? {} : { revisedTitle }, ...revisedObjective === undefined ? {} : { revisedObjective } });
     }
     case "revise_criterion": {
@@ -1897,7 +2864,7 @@ async function parseSteeringProposal(argv) {
       const expectedEvidence = readValue(argv, "--expected-evidence");
       const userModel = model(readValue(argv, "--user-model"));
       if (scenario === undefined && expectedEvidence === undefined && userModel === undefined)
-        return fail2("revise_criterion requires scenario, expected-evidence, or user-model.", "ULW_LOOP_STEERING_UPDATE_REQUIRED", { kind });
+        return fail3("revise_criterion requires scenario, expected-evidence, or user-model.", "ULW_LOOP_STEERING_UPDATE_REQUIRED", { kind });
       return normalizeSteeringProposal({ ...base, goalId, targetGoalId: goalId, criterionId, ...scenario === undefined ? {} : { scenario }, ...expectedEvidence === undefined ? {} : { expectedEvidence }, ...userModel === undefined ? {} : { userModel } });
     }
     case "annotate_ledger":
@@ -1947,10 +2914,10 @@ async function parseSteeringProposals(argv) {
   if (input === undefined)
     return [await parseSteeringProposal(argv)];
   if (readValue(argv, "--kind") !== undefined)
-    return fail2("--kind and --proposals-json are mutually exclusive.", "ULW_LOOP_STEERING_BATCH_CONFLICT", { flags: ["--kind", "--proposals-json"] });
+    return fail3("--kind and --proposals-json are mutually exclusive.", "ULW_LOOP_STEERING_BATCH_CONFLICT", { flags: ["--kind", "--proposals-json"] });
   const raw = await readJsonInput(input);
   if (!Array.isArray(raw) || raw.length === 0)
-    return fail2("--proposals-json must be a non-empty JSON array.", "ULW_LOOP_STEERING_BATCH_ARRAY_REQUIRED", { flag: "--proposals-json" });
+    return fail3("--proposals-json must be a non-empty JSON array.", "ULW_LOOP_STEERING_BATCH_ARRAY_REQUIRED", { flag: "--proposals-json" });
   const proposals = [];
   for (const item of raw)
     proposals.push(normalizeSteeringProposal(proposalFromObject(item)));
@@ -1958,13 +2925,13 @@ async function parseSteeringProposals(argv) {
 }
 function proposalFromObject(value) {
   if (!isPlain(value))
-    return fail2("--proposals-json entries must be objects.", "ULW_LOOP_STEERING_BATCH_ITEM_INVALID", { flag: "--proposals-json" });
+    return fail3("--proposals-json entries must be objects.", "ULW_LOOP_STEERING_BATCH_ITEM_INVALID", { flag: "--proposals-json" });
   const kind = readObject(value, "kind");
   const source = readObject(value, "source") ?? "cli";
   if (!isProposalKind(kind))
-    return fail2(`Invalid batch steering kind: ${String(kind)}.`, "ULW_LOOP_STEERING_KIND_INVALID", { value: kind });
+    return fail3(`Invalid batch steering kind: ${String(kind)}.`, "ULW_LOOP_STEERING_KIND_INVALID", { value: kind });
   if (!isProposalSource(source))
-    return fail2(`Invalid batch steering source: ${String(source)}.`, "ULW_LOOP_STEERING_SOURCE_INVALID", { value: source });
+    return fail3(`Invalid batch steering source: ${String(source)}.`, "ULW_LOOP_STEERING_SOURCE_INVALID", { value: source });
   let proposal = { kind, source, evidence: objectText(value, "evidence") ?? "", rationale: objectText(value, "rationale") ?? "" };
   const goalId = objectText(value, "goalId");
   const targetGoalId = objectText(value, "targetGoalId");
@@ -2036,7 +3003,7 @@ function printSteerBatchResult(result, json) {
   printStatus(result.plan);
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/review-blockers.ts
+// components/ulw-loop/src/review-blockers.ts
 var BLOCKER_FIELDS = "blockedReason blockerSignature blockerOccurrenceCount requiredExternalDecision nonRetriable failedAt failureReason completedAt blocker blockerEvidence blockerOccurrences blockedAt".split(" ");
 function ulwLoopError(message, code) {
   throw new UlwLoopError(message, code);
@@ -2050,12 +3017,13 @@ function nextGoalId(plan) {
 }
 function appendBlockerGoal(plan, args, now) {
   const index = plan.goals.length;
+  const id = nextGoalId(plan);
   const goal = {
-    id: nextGoalId(plan),
+    id,
     title: args.title,
     objective: args.objective,
     status: "pending",
-    successCriteria: seedDefaultSuccessCriteria(index, args.objective),
+    successCriteria: seedDefaultSuccessCriteria(index, args.objective, { goalId: id }),
     attempt: 0,
     createdAt: now,
     updatedAt: now
@@ -2074,10 +3042,14 @@ async function recordFinalReviewBlockers(repoRoot, args, scope) {
     if (!isFinalRunCompletionCandidate(plan, goal))
       ulwLoopError(`${goal.id} is not final.`, "ulw_loop_not_final_story");
     const snapshot = await readCodexGoalSnapshotInput(args.codexGoalJson, repoRoot);
-    const aggregate = codexGoalMode(plan) === "aggregate";
-    const reconciliation = reconcileCodexGoalSnapshot(snapshot, { expectedObjective: expectedCodexObjective(plan, goal), ...aggregate ? { acceptedObjectives: compatibleCodexObjectives(plan) } : {}, allowedStatuses: ["active"], requireSnapshot: true, requireComplete: false });
+    const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
+      expectedObjective: expectedCodexObjective(plan, goal),
+      acceptedObjectives: compatibleCodexObjectives(plan),
+      acknowledgedObjectives: acknowledgedDriverObjectives(plan)
+    });
     if (!reconciliation.ok)
-      ulwLoopError(reconciliation.errors.join(" "), "ulw_loop_codex_snapshot_mismatch");
+      throw new CodexGoalSnapshotError(formatCodexGoalReconciliation(reconciliation));
+    acknowledgeDriverObjective(plan, reconciliation.unacknowledgedObjective);
     const now = iso();
     for (const field of BLOCKER_FIELDS)
       Reflect.deleteProperty(goal, field);
@@ -2089,27 +3061,61 @@ async function recordFinalReviewBlockers(repoRoot, args, scope) {
       delete plan.activeGoalId;
     const newGoal = appendBlockerGoal(plan, args, now);
     plan.updatedAt = now;
-    const codexGoal = reconciliation.snapshot.raw;
+    const codexGoal = snapshot?.raw;
     const blockedEntry = { at: now, kind: "goal_review_blocked", goalId: goal.id, status: goal.status, evidence: args.evidence, codexGoal };
     const addedEntry = { at: now, kind: "goal_added", goalId: newGoal.id, status: newGoal.status, evidence: args.evidence, message: newGoal.title };
     const summaryEntry = { at: now, kind: "goal_review_blocked", goalId: goal.id, status: goal.status, evidence: args.evidence, codexGoal, message: `Review blockers recorded; appended ${newGoal.id}.` };
     Reflect.set(summaryEntry, "kind", "blocker_recorded");
     const ledgerEntries = [blockedEntry, addedEntry, summaryEntry];
-    await writePlan(repoRoot, plan, scope);
-    for (const entry of ledgerEntries)
-      await appendLedger(repoRoot, entry, scope);
-    return { plan, blockedGoal: goal, newGoal, ledgerEntries };
+    await commit(repoRoot, scope, { plan, entries: ledgerEntries });
+    return {
+      plan,
+      blockedGoal: goal,
+      newGoal,
+      ledgerEntries,
+      nextActions: reconciliation.nextActions,
+      warnings: reconciliation.warnings
+    };
   });
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/steering-mutations.ts
+// components/ulw-loop/src/status-next-actions.ts
+function statusNextActions(plan, surface = "lazycodex") {
+  const actions = [];
+  const active = plan.goals.find((goal) => goal.id === plan.activeGoalId);
+  if (plan.goals.length === 0)
+    actions.push(`No goals yet: bootstrap with \`${createGoalsAction(surface)}\`.`);
+  else if (active !== undefined)
+    actions.push(...activeGoalActions(plan, active, surface));
+  for (const goal of plan.goals.filter((candidate) => candidate.status === "review_blocked"))
+    actions.push(surface === "omo-senpi" ? `${goal.id} is review_blocked: capture the reviewer verdict with \`agentToolkit.recordReviewBlockers({ goalId: "${goal.id}", title: "<title>", objective: "<objective>", evidence: "<verdict>" })\`.` : `${goal.id} is review_blocked: capture the reviewer verdict with \`omo-agent-toolkit ulw-loop record-review-blockers --goal-id ${goal.id} --title "<title>" --objective "<objective>" --evidence "<verdict>" --codex-goal-json '<get_goal json>'\`.`);
+  if (plan.evidenceLayoutVersion !== 2 || active === undefined)
+    actions.push("plan is evidence-layout v1; artifacts go under .omo/evidence/");
+  return actions;
+}
+function activeGoalActions(plan, active, surface) {
+  const unresolved = active.successCriteria.filter((criterion) => criterion.status !== "pass");
+  if (unresolved.length > 0)
+    return [
+      surface === "omo-senpi" ? `${active.id} has ${unresolved.length} unresolved criterion(s) (${unresolved.map((criterion) => criterion.id).join(", ")}): record proof with \`agentToolkit.recordEvidence({ goalId: "${active.id}", criterionId: "<id>", status: "pass", evidence: "<observable proof>" })\`.` : `${active.id} has ${unresolved.length} unresolved criterion(s) (${unresolved.map((criterion) => criterion.id).join(", ")}): record proof with \`omo-agent-toolkit ulw-loop record-evidence --goal-id ${active.id} --criterion-id <id> --status pass --evidence "<observable proof>"\`.`
+    ];
+  if (hasAllCriteriaPass(active) && isFinalRunCompletionCandidate(plan, active))
+    return [
+      surface === "omo-senpi" ? `${active.id} passes every criterion and is the final story: complete the driver goal, then call \`agentToolkit.checkpoint({ goalId: "${active.id}", printTemplate: true })\` to build the final quality gate. Use status().result.currentAttemptDir for all quality-gate artifacts.` : `${active.id} passes every criterion and is the final story: update_goal complete, then checkpoint --print-template to build the final quality gate. Use status --json's currentAttemptDir for all quality-gate artifacts.`
+    ];
+  return [
+    surface === "omo-senpi" ? `${active.id} passes every criterion: close it with \`agentToolkit.checkpoint({ goalId: "${active.id}", status: "complete", evidence: "<proof>" })\`. Put quality-gate artifacts under status().result.currentAttemptDir.` : `${active.id} passes every criterion: close it with \`omo-agent-toolkit ulw-loop checkpoint --goal-id ${active.id} --status complete --evidence "<proof>" --codex-goal-json '<get_goal json>'\`. Put quality-gate artifacts under the currentAttemptDir shown by status --json.`
+  ];
+}
+
+// components/ulw-loop/src/steering-mutations.ts
 var read2 = (value, key) => Object.entries(value).find(([name]) => name === key)?.[1];
 var isText = (value) => typeof value === "string" && value.trim().length > 0;
 var text3 = (value, key) => {
   const candidate = read2(value, key);
   return isText(candidate) ? candidate.trim() : undefined;
 };
-var isModel2 = (value) => typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model2) => model2 === value);
+var isModel2 = (value) => typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model) => model === value);
 var after = (proposal) => {
   const candidate = read2(proposal, "after");
   return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) ? candidate : undefined;
@@ -2139,11 +3145,11 @@ function nextId(plan, offset) {
   }, 0);
   return `G${String(max + offset).padStart(3, "0")}`;
 }
-function makeGoal2(plan, childGoal, evidence, now, offset) {
+function makeGoal2(plan, childGoal, evidence, now, offset, surface = "lazycodex") {
   const id = nextId(plan, offset);
   const digits = /^G(\d+)/u.exec(id)?.[1];
   const goalIndex = digits === undefined ? plan.goals.length + offset - 1 : Number(digits) - 1;
-  return { id, title: childGoal.title, objective: childGoal.objective, status: "pending", successCriteria: seedDefaultSuccessCriteria(goalIndex, childGoal.objective), attempt: 0, createdAt: now, updatedAt: now, evidence };
+  return { id, title: childGoal.title, objective: childGoal.objective, status: "pending", successCriteria: seedDefaultSuccessCriteria(goalIndex, childGoal.objective, { goalId: id, surface }), attempt: 0, createdAt: now, updatedAt: now, evidence };
 }
 function reviseWording(plan, proposal, now) {
   const target = goal(plan, targets(proposal)[0]);
@@ -2155,11 +3161,11 @@ function reviseWording(plan, proposal, now) {
   target.steeringRationale = proposal.rationale;
   target.updatedAt = now;
 }
-function splitOrBlock(plan, proposal, now) {
+function splitOrBlock(plan, proposal, now, surface = "lazycodex") {
   const target = goal(plan, targets(proposal)[0]);
   if (target === undefined)
     return;
-  const replacements = children2(proposal).map((item, index) => makeGoal2(plan, item, proposal.evidence, now, index + 1));
+  const replacements = children2(proposal).map((item, index) => makeGoal2(plan, item, proposal.evidence, now, index + 1, surface));
   target.steeringEvidence = proposal.evidence;
   target.steeringRationale = proposal.rationale;
   target.updatedAt = now;
@@ -2184,38 +3190,38 @@ function reviseCriterion(plan, proposal, now) {
   const current = target?.successCriteria[index];
   if (target === undefined || current === undefined)
     return;
-  const model2 = read2(proposal, "userModel");
-  target.successCriteria[index] = { ...current, scenario: text3(proposal, "scenario") ?? current.scenario, expectedEvidence: text3(proposal, "expectedEvidence") ?? current.expectedEvidence, userModel: isModel2(model2) ? model2 : current.userModel };
+  const model = read2(proposal, "userModel");
+  target.successCriteria[index] = { ...current, scenario: text3(proposal, "scenario") ?? current.scenario, expectedEvidence: text3(proposal, "expectedEvidence") ?? current.expectedEvidence, userModel: isModel2(model) ? model : current.userModel };
   target.updatedAt = now;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/steering-snapshot.ts
+// components/ulw-loop/src/steering-snapshot.ts
 function buildSteeringPlanSnapshot(plan, changedGoalIds) {
   const snapshot = {
     updatedAt: plan.updatedAt,
     goalCount: plan.goals.length,
-    goalIds: plan.goals.map((goal2) => goal2.id),
-    goals: plan.goals.filter((goal2) => changedGoalIds.has(goal2.id))
+    goalIds: plan.goals.map((goal) => goal.id),
+    goals: plan.goals.filter((goal) => changedGoalIds.has(goal.id))
   };
   return plan.activeGoalId === undefined ? snapshot : { ...snapshot, activeGoalId: plan.activeGoalId };
 }
-function changedGoalIdsBetween(before, after2) {
-  const beforeById = new Map(before.goals.map((goal2) => [goal2.id, goal2]));
+function changedGoalIdsBetween(before, after) {
+  const beforeById = new Map(before.goals.map((goal) => [goal.id, goal]));
   const changed = new Set;
-  for (const goal2 of after2.goals) {
-    const prior = beforeById.get(goal2.id);
-    if (prior === undefined || JSON.stringify(prior) !== JSON.stringify(goal2))
-      changed.add(goal2.id);
-    beforeById.delete(goal2.id);
+  for (const goal of after.goals) {
+    const prior = beforeById.get(goal.id);
+    if (prior === undefined || JSON.stringify(prior) !== JSON.stringify(goal))
+      changed.add(goal.id);
+    beforeById.delete(goal.id);
   }
   for (const id of beforeById.keys())
     changed.add(id);
   return changed;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/steering.ts
+// components/ulw-loop/src/steering.ts
 var SOURCES2 = ["user_prompt_submit", "finding", "cli"];
-var PROTECTED = new Set(["aggregateCompletion", "codexObjective", "codexObjectiveAliases", "originalConstraints", "qualityGate", "status", "completedAt", "completionStatus"]);
+var PROTECTED = new Set(["aggregateCompletion", "codexObjective", "codexObjectiveAliases", "acknowledgedDriverObjectives", "originalConstraints", "qualityGate", "status", "completedAt", "completionStatus"]);
 var isObject2 = (value) => typeof value === "object" && value !== null;
 var isPlain2 = (value) => isObject2(value) && !Array.isArray(value);
 var read3 = (value, key) => Object.entries(value).find(([name]) => name === key)?.[1];
@@ -2226,7 +3232,7 @@ var text4 = (value, key) => {
 };
 var isKind2 = (value) => typeof value === "string" && ULW_LOOP_STEERING_MUTATION_KINDS.some((kind) => kind === value);
 var isSource2 = (value) => typeof value === "string" && SOURCES2.some((source) => source === value);
-var isModel3 = (value) => typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model2) => model2 === value);
+var isModel3 = (value) => typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model) => model === value);
 var texts = (value, key) => {
   const candidate = read3(value, key);
   return Array.isArray(candidate) && candidate.every((item) => typeof item === "string") ? candidate : [];
@@ -2367,19 +3373,19 @@ function validateCriterion(plan, proposal, reasons) {
     reasons.push("revise_criterion requires goalId");
   else if (criterionId === undefined || target.successCriteria.every((item) => item.id !== criterionId))
     reasons.push("revise_criterion requires criterionId");
-  const model2 = read3(proposal, "userModel");
-  if (read3(proposal, "scenario") === undefined && read3(proposal, "expectedEvidence") === undefined && model2 === undefined)
+  const model = read3(proposal, "userModel");
+  if (read3(proposal, "scenario") === undefined && read3(proposal, "expectedEvidence") === undefined && model === undefined)
     reasons.push("revise_criterion requires update");
-  if (model2 !== undefined && !isModel3(model2))
+  if (model !== undefined && !isModel3(model))
     reasons.push("invalid userModel");
 }
-function applySteeringMutation(plan, proposal, audit) {
+function applySteeringMutation(plan, proposal, audit, surface = "lazycodex") {
   const next = structuredClone(plan);
   if (!audit.invariant.accepted)
     return next;
   const now = proposal.now?.toISOString() ?? iso();
   if (proposal.kind === "add_subgoal")
-    next.goals.push(makeGoal2(next, { title: proposal.title ?? "", objective: proposal.objective ?? "" }, proposal.evidence, now, 1));
+    next.goals.push(makeGoal2(next, { title: proposal.title ?? "", objective: proposal.objective ?? "" }, proposal.evidence, now, 1, surface));
   if (proposal.kind === "reorder_pending") {
     const order = pendingOrder(proposal);
     next.goals = [...order.map((id) => goal2(next, id)).filter((item) => item !== undefined), ...next.goals.filter((item) => !order.includes(item.id))];
@@ -2387,7 +3393,7 @@ function applySteeringMutation(plan, proposal, audit) {
   if (proposal.kind === "revise_pending_wording")
     reviseWording(next, proposal, now);
   if (proposal.kind === "split_subgoal" || proposal.kind === "mark_blocked_superseded")
-    splitOrBlock(next, proposal, now);
+    splitOrBlock(next, proposal, now, surface);
   if (proposal.kind === "revise_criterion")
     reviseCriterion(next, proposal, now);
   if (proposal.kind !== "annotate_ledger")
@@ -2397,8 +3403,8 @@ function applySteeringMutation(plan, proposal, audit) {
 function isProposal(value) {
   return isPlain2(value) && isKind2(read3(value, "kind")) && isSource2(read3(value, "source")) && isText2(read3(value, "evidence")) && isText2(read3(value, "rationale"));
 }
-function parseUlwLoopSteeringDirective(text5) {
-  const match = /(?:^|\s)(?:OMO_ULW_LOOP_STEER|omo\.ulw-loop\.steer|omo ulw-loop steer|omo-agent-toolkit ulw-loop steer):\s*([\s\S]+)$/u.exec(text5);
+function parseUlwLoopSteeringDirective(text) {
+  const match = /(?:^|\s)(?:OMO_ULW_LOOP_STEER|omo\.ulw-loop\.steer|omo ulw-loop steer|omo-agent-toolkit ulw-loop steer):\s*([\s\S]+)$/u.exec(text);
   if (match?.[1] === undefined)
     return null;
   try {
@@ -2410,7 +3416,7 @@ function parseUlwLoopSteeringDirective(text5) {
     throw error;
   }
 }
-async function steerUlwLoop(repoRoot, proposal, scope) {
+async function steerUlwLoop(repoRoot, proposal, scope, surface = "lazycodex") {
   return withUlwLoopMutationLock(repoRoot, scope, async () => {
     const plan = await readUlwLoopPlan(repoRoot, scope);
     const key = proposal.idempotencyKey ?? proposal.promptSignature;
@@ -2421,7 +3427,7 @@ async function steerUlwLoop(repoRoot, proposal, scope) {
     }
     const audit = validateUlwLoopSteeringProposal(plan, proposal);
     const accepted = audit.invariant.accepted;
-    const next = accepted ? applySteeringMutation(plan, proposal, audit) : plan;
+    const next = accepted ? applySteeringMutation(plan, proposal, audit, surface) : plan;
     const finalAudit = { ...audit };
     if (accepted) {
       const changed = changedGoalIdsBetween(plan, next);
@@ -2430,11 +3436,10 @@ async function steerUlwLoop(repoRoot, proposal, scope) {
     }
     const at = proposal.now?.toISOString() ?? iso();
     const batchEntry = accepted ? batchUpdateLedgerEntry(plan, next, at) : null;
-    if (accepted)
-      await writePlan(repoRoot, next, scope);
-    await appendLedger(repoRoot, ledgerEntry(proposal, finalAudit, at), scope);
+    const entries = [ledgerEntry(proposal, finalAudit, at)];
     if (batchEntry !== null)
-      await appendLedger(repoRoot, batchEntry, scope);
+      entries.push(batchEntry);
+    await commit(repoRoot, scope, { plan: next, entries });
     return { plan: next, accepted, audit: finalAudit, rejectedReasons: audit.invariant.rejectedReasons, deduped: false };
   });
 }
@@ -2450,7 +3455,257 @@ function ledgerEntry(proposal, audit, at) {
   return entry;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/steering-batch.ts
+// components/ulw-loop/src/sdk/manifest.ts
+var CRITERION_INPUT = '{ scenario: string, expectedEvidence: string, userModel?: "happy" | "edge" | "regression" | "adversarial", essential?: boolean }';
+var STEER_KINDS = '"add_subgoal" | "split_subgoal" | "reorder_pending" | "revise_pending_wording" | "revise_criterion" | "annotate_ledger" | "mark_blocked_superseded"';
+var ULW_LOOP_MANIFEST = {
+  version: 1,
+  name: "ulw-loop",
+  operations: [
+    {
+      name: "help",
+      method: "help",
+      mutating: false,
+      description: "Return this manifest: every operation with its method name, argument fields, and what it does.",
+      args: {}
+    },
+    {
+      name: "create-goals",
+      method: "createGoals",
+      mutating: true,
+      description: "Create the session plan from a brief; one goal per bullet, each seeded with placeholder criteria until revised.",
+      args: {
+        brief: "string",
+        codexGoalMode: '"aggregate" | "per_story"?',
+        force: "boolean?",
+        validationBatchesJson: "string?"
+      }
+    },
+    {
+      name: "status",
+      method: "status",
+      mutating: false,
+      description: "Read the plan, its summary, structured nextActions, the stable evidenceRoot, and the active goal's currentAttemptDir.",
+      args: {}
+    },
+    {
+      name: "complete-goals",
+      method: "completeGoals",
+      mutating: true,
+      description: "Acquire the next eligible goal or resume the in-progress one; returns { done: true } once the aggregate is complete.",
+      args: { retryFailed: "boolean?" }
+    },
+    {
+      name: "checkpoint",
+      method: "checkpoint",
+      mutating: true,
+      description: "Close the goal as complete, failed, or blocked with evidence; the final goal also needs the quality gate. printTemplate returns that gate's template instead.",
+      args: {
+        goalId: "string",
+        status: '"complete" | "failed" | "blocked"',
+        evidence: "string",
+        codexGoalJson: "string?",
+        qualityGateJson: "string?",
+        printTemplate: "true? (with goalId? only)"
+      }
+    },
+    {
+      name: "steer",
+      method: "steer",
+      mutating: true,
+      description: "Propose an evidence-backed plan mutation; revise_criterion replaces a criterion's scenario, expectedEvidence, or userModel.",
+      args: {
+        kind: STEER_KINDS,
+        source: '"finding" | "user_prompt_submit" | "cli"',
+        evidence: "string",
+        rationale: "string",
+        goalId: "string?",
+        criterionId: "string? (revise_criterion)",
+        scenario: "string? (revise_criterion)",
+        expectedEvidence: "string? (revise_criterion)",
+        userModel: '"happy" | "edge" | "regression" | "adversarial"? (revise_criterion)',
+        title: "string? (add_subgoal)",
+        objective: "string? (add_subgoal)",
+        childGoals: "{ title: string, objective: string }[]? (split_subgoal)",
+        revisedTitle: "string? (revise_pending_wording)",
+        revisedObjective: "string? (revise_pending_wording)",
+        pendingOrder: "string[]? (reorder_pending)",
+        blockedReason: "string? (mark_blocked_superseded)",
+        idempotencyKey: "string?"
+      }
+    },
+    {
+      name: "add-goal",
+      method: "addGoal",
+      mutating: true,
+      description: "Append a goal; pass successCriteria to define its criteria in the same call, otherwise placeholders name the revise call.",
+      args: { title: "string", objective: "string", successCriteria: `${CRITERION_INPUT}[]?` }
+    },
+    {
+      name: "criteria",
+      method: "criteria",
+      mutating: false,
+      description: "List one goal's success criteria with their status and captured evidence.",
+      args: { goalId: "string" }
+    },
+    {
+      name: "record-evidence",
+      method: "recordEvidence",
+      mutating: true,
+      description: "Record a criterion's pass, fail, or blocked evidence; artifacts must exist (resolved against the session cwd) and are stored with the criterion and the ledger entry.",
+      args: {
+        goalId: "string",
+        criterionId: "string",
+        status: '"pass" | "fail" | "blocked"',
+        evidence: "string",
+        notes: "string?",
+        artifacts: "string[]?"
+      }
+    },
+    {
+      name: "record-review-blockers",
+      method: "recordReviewBlockers",
+      mutating: true,
+      description: "Mark the final goal review_blocked and append the blocker goal the reviewer verdict names.",
+      args: { goalId: "string", title: "string", objective: "string", evidence: "string", codexGoalJson: "string?" }
+    }
+  ]
+};
+
+// components/ulw-loop/src/sdk/factory.ts
+function validateCodexGoalJson(raw) {
+  if (raw === undefined)
+    return;
+  try {
+    JSON.parse(raw);
+  } catch (error) {
+    throw new UlwLoopError(`Invalid codexGoal: ${error instanceof Error ? error.message : "not valid JSON"}`, "ULW_LOOP_CODEX_GOAL_JSON_INVALID", { cause: error });
+  }
+}
+function validateContext(context) {
+  if (!context.cwd.trim())
+    throw new UlwLoopError("cwd is required.", "ULW_LOOP_CWD_REQUIRED");
+  const sessionId = context.sessionId.trim();
+  if (!sessionId)
+    throw new UlwLoopError("ULW_LOOP_SESSION_ID_REQUIRED: sessionId is required.", "ULW_LOOP_SESSION_ID_REQUIRED");
+  const normalizedSessionId = normalizeUlwLoopSessionId(sessionId);
+  if (normalizedSessionId === null || /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(sessionId))
+    throw new UlwLoopError("ULW_LOOP_SESSION_ID_INVALID: sessionId normalizes to null.", "ULW_LOOP_SESSION_ID_INVALID");
+  if (context.surface !== "omo-senpi" && context.surface !== "lazycodex")
+    throw new UlwLoopError("surface must be omo-senpi or lazycodex.", "ULW_LOOP_SURFACE_INVALID");
+}
+function errorDetails(error) {
+  const details = error.details === undefined ? undefined : Object.fromEntries(Object.entries(error.details).map(([key, value]) => [key, String(value)]));
+  return details === undefined ? { code: error.code, message: error.message } : { code: error.code, message: error.message, details };
+}
+function failure(operation, error) {
+  return { ok: false, operation, error: errorDetails(error) };
+}
+function caught(operation, error) {
+  return failure(operation, error instanceof UlwLoopError ? error : new UlwLoopError(error.message, "ULW_LOOP_ERROR"));
+}
+function isKnownRequest(request) {
+  return ULW_LOOP_MANIFEST.operations.some((operation) => operation.name === request.operation);
+}
+function unreachable(value) {
+  throw new UlwLoopError(`Unhandled operation: ${String(value)}`, "ULW_LOOP_OPERATION_UNHANDLED");
+}
+function stringsFrom(result, key) {
+  if (!(key in result))
+    return [];
+  const value = Object.entries(result).find(([name]) => name === key)?.[1];
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string").slice(0, 8) : [];
+}
+function checkpointWithValidatedSnapshot(context, scope, args) {
+  validateCodexGoalJson(args.codexGoalJson);
+  return checkpointUlwLoop(context.cwd, args, scope, { surface: context.surface });
+}
+function createAgentToolkit(context, deps = {}) {
+  validateContext(context);
+  const scope = { sessionId: context.sessionId };
+  const notify = async (operation, response) => {
+    if (deps.hooks?.onOperation !== undefined)
+      await deps.hooks.onOperation({ operation, context, response });
+    return response;
+  };
+  const invoke = async (operation, fn) => {
+    try {
+      const result = await fn();
+      const nextActions = typeof result === "object" && result !== null ? stringsFrom(result, "nextActions") : [];
+      const warnings = typeof result === "object" && result !== null ? stringsFrom(result, "warnings") : [];
+      return await notify(operation, {
+        ok: true,
+        operation,
+        result,
+        nextActions,
+        ...warnings.length === 0 ? {} : { warnings }
+      });
+    } catch (error) {
+      if (error instanceof UlwLoopError && error.code === "ULW_LOOP_PLAN_MISSING" && context.surface === "omo-senpi")
+        return notify(operation, failure(operation, planMissingError(ulwLoopGoalsRelativePath(scope), listUlwLoopSessionIds(context.cwd), context.surface)));
+      const response = caught(operation, error instanceof Error ? error : new Error("ULW_LOOP_ERROR"));
+      return notify(operation, response);
+    }
+  };
+  const toolkit = {
+    dispatch: async (request) => {
+      if (!isKnownRequest(request))
+        return failure(request.operation, new UlwLoopError(`Unknown operation: ${request.operation}`, "ULW_LOOP_OPERATION_UNKNOWN"));
+      switch (request.operation) {
+        case "help":
+          return toolkit.help();
+        case "create-goals":
+          return toolkit.createGoals(request.args);
+        case "status":
+          return toolkit.status();
+        case "complete-goals":
+          return toolkit.completeGoals(request.args);
+        case "checkpoint":
+          return toolkit.checkpoint(request.args);
+        case "steer":
+          return toolkit.steer(request.args);
+        case "add-goal":
+          return toolkit.addGoal(request.args);
+        case "criteria":
+          return toolkit.criteria(request.args);
+        case "record-evidence":
+          return toolkit.recordEvidence(request.args);
+        case "record-review-blockers":
+          return toolkit.recordReviewBlockers(request.args);
+        default:
+          return unreachable(request);
+      }
+    },
+    help: () => invoke("help", async () => ULW_LOOP_MANIFEST),
+    createGoals: (args) => invoke("create-goals", () => createUlwLoopPlan(context.cwd, args, scope, context.surface)),
+    status: () => invoke("status", async () => {
+      const plan = await readUlwLoopPlan(context.cwd, scope);
+      const active = plan.goals.find((goal) => goal.id === plan.activeGoalId);
+      return {
+        plan,
+        summary: summarizeUlwLoopPlan(plan),
+        nextActions: statusNextActions(plan, context.surface),
+        evidenceRoot: ulwLoopEvidenceRoot(scope),
+        ...active === undefined || plan.evidenceLayoutVersion !== 2 ? {} : { currentAttemptDir: ulwLoopAttemptEvidenceDir(active.id, active.attempt, scope) }
+      };
+    }),
+    completeGoals: (args = {}) => invoke("complete-goals", () => startNextUlwLoop(context.cwd, args, scope)),
+    checkpoint: (args) => invoke("checkpoint", () => args.printTemplate === true ? checkpointTemplate(context.cwd, scope, args.goalId, { surface: context.surface }) : checkpointWithValidatedSnapshot(context, scope, args)),
+    steer: (args) => invoke("steer", () => steerUlwLoop(context.cwd, args, scope, context.surface)),
+    addGoal: (args) => invoke("add-goal", () => addUlwLoopGoal(context.cwd, args, scope, context.surface)),
+    criteria: (args) => invoke("criteria", async () => {
+      const plan = await readUlwLoopPlan(context.cwd, scope);
+      const goal = plan.goals.find((candidate) => candidate.id === args.goalId);
+      if (goal === undefined)
+        throw new UlwLoopError(`Unknown ulw-loop id: ${args.goalId}.`, "ULW_LOOP_GOAL_NOT_FOUND");
+      return { goalId: goal.id, criteria: goal.successCriteria };
+    }),
+    recordEvidence: (args) => invoke("record-evidence", () => recordEvidence(context.cwd, args, scope)),
+    recordReviewBlockers: (args) => invoke("record-review-blockers", () => recordFinalReviewBlockers(context.cwd, args, scope))
+  };
+  return toolkit;
+}
+// components/ulw-loop/src/steering-batch.ts
 async function steerUlwLoopBatch(repoRoot, proposals, scope) {
   return withUlwLoopMutationLock(repoRoot, scope, async () => {
     const plan = await readUlwLoopPlan(repoRoot, scope);
@@ -2458,7 +3713,7 @@ async function steerUlwLoopBatch(repoRoot, proposals, scope) {
     const failed = prepared.results.find((item) => !item.accepted);
     if (failed !== undefined) {
       const entry = rejectedLedgerEntry(prepared.results);
-      await appendLedger(repoRoot, entry, scope);
+      await commit(repoRoot, scope, { plan, entries: [entry] });
       return rejected(plan, prepared.results, failed.rejectedReasons);
     }
     let next = plan;
@@ -2467,10 +3722,9 @@ async function steerUlwLoopBatch(repoRoot, proposals, scope) {
         next = item.prepared.next;
     const fresh = prepared.items.filter((item) => item.kind === "fresh");
     if (fresh.length > 0) {
-      await writePlan(repoRoot, next, scope);
       const entries = fresh.map((item) => ledgerEntry2(item.prepared.proposal, item.prepared.audit, item.prepared.proposal.now?.toISOString() ?? iso()));
       const batchEntry = batchUpdateLedgerEntry(plan, next, iso());
-      await appendLedgerEntries(repoRoot, batchEntry === null ? entries : [...entries, batchEntry], scope);
+      await commit(repoRoot, scope, { plan: next, entries: batchEntry === null ? entries : [...entries, batchEntry] });
     }
     return { plan: next, accepted: true, results: prepared.results, rejectedReasons: [] };
   });
@@ -2483,16 +3737,16 @@ async function prepareBatch(repoRoot, plan, proposals, scope) {
     const key = proposal.idempotencyKey ?? proposal.promptSignature;
     const prior = key === undefined ? undefined : await findAcceptedSteeringLedgerEntry(repoRoot, key, scope);
     if (prior?.steering !== undefined) {
-      const result2 = { accepted: true, deduped: true, audit: { ...prior.steering, deduped: true }, rejectedReasons: [] };
-      items.push({ kind: "deduped", result: result2 });
-      results.push(result2);
+      const result = { accepted: true, deduped: true, audit: { ...prior.steering, deduped: true }, rejectedReasons: [] };
+      items.push({ kind: "deduped", result });
+      results.push(result);
       continue;
     }
     const audit = validateUlwLoopSteeringProposal(current, proposal);
     if (!audit.invariant.accepted) {
-      const result2 = { accepted: false, deduped: false, audit, rejectedReasons: audit.invariant.rejectedReasons };
-      items.push({ kind: "deduped", result: result2 });
-      results.push(result2);
+      const result = { accepted: false, deduped: false, audit, rejectedReasons: audit.invariant.rejectedReasons };
+      items.push({ kind: "deduped", result });
+      results.push(result);
       continue;
     }
     const next = applySteeringMutation(current, proposal, audit);
@@ -2531,20 +3785,20 @@ function ledgerEntry2(proposal, audit, at) {
   return entry;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/cli-subcommands.ts
+// components/ulw-loop/src/cli-subcommands.ts
 async function createGoals(repoRoot, argv, json, scope) {
   const briefFile = readValue(argv, "--brief-file");
-  const brief = readValue(argv, "--brief") ?? (briefFile === undefined ? undefined : await readFile6(briefFile, "utf8")) ?? (hasFlag(argv, "--from-stdin") ? await readStdin() : undefined) ?? positionalText(argv);
+  const brief = readValue(argv, "--brief") ?? (briefFile === undefined ? undefined : await readFile4(briefFile, "utf8")) ?? (hasFlag(argv, "--from-stdin") ? await readStdin() : undefined) ?? positionalText(argv);
   if (!brief.trim()) {
     throw new UlwLoopError("Missing brief text. Pass --brief, --brief-file, --from-stdin, or positional text.", "ULW_LOOP_BRIEF_REQUIRED");
   }
   const validationBatchesJson = readValue(argv, "--validation-batch-json");
-  const plan = await createUlwLoopPlan(repoRoot, {
+  const plan = unwrap(await toolkitFor(repoRoot, scope).createGoals({
     brief,
     codexGoalMode: normalizeCodexGoalMode(readValue(argv, "--codex-goal-mode")),
     force: hasFlag(argv, "--force"),
     ...validationBatchesJson === undefined ? {} : { validationBatchesJson }
-  }, scope);
+  }));
   if (json)
     printJson({ ok: true, plan, summary: summarizeUlwLoopPlan(plan) });
   else {
@@ -2557,22 +3811,15 @@ ledger: ${plan.ledgerPath}
   return 0;
 }
 async function status(repoRoot, json, scope) {
-  const plan = await readUlwLoopPlan(repoRoot, scope);
-  if (json) {
-    const active = plan.goals.find((goal3) => goal3.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);
+  const status = unwrap(await toolkitFor(repoRoot, scope).status());
+  if (json)
+    printJson({ ok: true, ...status });
+  else
+    printStatus(status.plan);
   return 0;
 }
 async function completeGoals(repoRoot, argv, json, scope) {
-  const result = await startNextUlwLoop(repoRoot, { retryFailed: hasFlag(argv, "--retry-failed") }, scope);
+  const result = unwrap(await toolkitFor(repoRoot, scope).completeGoals({ retryFailed: hasFlag(argv, "--retry-failed") }));
   if ("done" in result) {
     const handoff = blockedDecisionHandoff(result.plan);
     if (json) {
@@ -2601,16 +3848,19 @@ async function steer(repoRoot, argv, json, scope) {
   const proposals = await parseSteeringProposals(argv);
   const single = proposals[0];
   if (single !== undefined && proposals.length === 1 && readValue(argv, "--proposals-json") === undefined) {
-    const result2 = await steerUlwLoop(repoRoot, single, scope);
-    printSteerResult(result2, json);
-    return result2.accepted ? 0 : 1;
+    const result = unwrap(await toolkitFor(repoRoot, scope).steer(single));
+    printSteerResult(result, json);
+    return result.accepted ? 0 : 1;
   }
   const result = await steerUlwLoopBatch(repoRoot, proposals, scope);
   printSteerBatchResult(result, json);
   return result.accepted ? 0 : 1;
 }
 async function addGoal(repoRoot, argv, json, scope) {
-  const result = await addUlwLoopGoal(repoRoot, { title: required4(argv, "--title"), objective: required4(argv, "--objective") }, scope);
+  const result = unwrap(await toolkitFor(repoRoot, scope).addGoal({
+    title: required4(argv, "--title"),
+    objective: required4(argv, "--objective")
+  }));
   if (json)
     printJson({ ok: true, plan: result.plan, goal: result.goal, summary: summarizeUlwLoopPlan(result.plan) });
   else {
@@ -2622,19 +3872,19 @@ async function addGoal(repoRoot, argv, json, scope) {
 }
 async function criteria(repoRoot, argv, json, scope) {
   const goalId = required4(argv, "--goal-id");
-  const goal3 = findGoal3(await readUlwLoopPlan(repoRoot, scope), goalId);
+  const result = unwrap(await toolkitFor(repoRoot, scope).criteria({ goalId }));
   if (json)
-    printJson({ ok: true, goalId: goal3.id, criteria: goal3.successCriteria });
+    printJson({ ok: true, goalId: result.goalId, criteria: result.criteria });
   else {
-    process.stdout.write(`criteria for ${goal3.id}:
-${goal3.successCriteria.map(formatCriterionForCli).join(`
+    process.stdout.write(`criteria for ${result.goalId}:
+${result.criteria.map(formatCriterionForCli).join(`
 `)}
 `);
   }
   return 0;
 }
 async function captureEvidence(repoRoot, argv, json, scope) {
-  const result = await recordEvidence(repoRoot, parseRecordEvidenceArgs(argv), scope);
+  const result = unwrap(await toolkitFor(repoRoot, scope).recordEvidence(parseRecordEvidenceArgs(argv)));
   if (json)
     printJson({ ok: true, ...result, summary: summarizeUlwLoopPlan(result.plan) });
   else {
@@ -2648,13 +3898,13 @@ async function reviewBlockers(repoRoot, argv, json, scope) {
   if (codexGoalJson === undefined) {
     throw new UlwLoopError("Missing --codex-goal-json.", "ULW_LOOP_CODEX_GOAL_JSON_REQUIRED");
   }
-  const result = await recordFinalReviewBlockers(repoRoot, {
+  const result = unwrap(await toolkitFor(repoRoot, scope).recordReviewBlockers({
     goalId: required4(argv, "--goal-id"),
     title: required4(argv, "--title"),
     objective: required4(argv, "--objective"),
     evidence: required4(argv, "--evidence"),
     codexGoalJson
-  }, scope);
+  }));
   if (json) {
     printJson({
       ok: true,
@@ -2662,6 +3912,8 @@ async function reviewBlockers(repoRoot, argv, json, scope) {
       blockedGoal: result.blockedGoal,
       goal: result.newGoal,
       ledgerEntries: result.ledgerEntries,
+      nextActions: result.nextActions,
+      warnings: result.warnings,
       summary: summarizeUlwLoopPlan(result.plan)
     });
   } else {
@@ -2670,6 +3922,20 @@ async function reviewBlockers(repoRoot, argv, json, scope) {
   }
   return 0;
 }
+function toolkitFor(repoRoot, scope) {
+  const sessionId = scope?.sessionId?.trim();
+  if (sessionId === undefined || sessionId.length === 0) {
+    throw new UlwLoopError("Missing --session-id.", "ULW_LOOP_SESSION_ID_REQUIRED", {
+      details: { flag: "--session-id" }
+    });
+  }
+  return createAgentToolkit({ cwd: repoRoot, sessionId, surface: resolveToolkitSurface() });
+}
+function unwrap(response) {
+  if (response.ok)
+    return response.result;
+  throw new UlwLoopError(response.error.message, response.error.code);
+}
 function formatCriterionForCli(criterion) {
   const marker = isEssentialCriterion(criterion) ? "essential" : "non-essential";
   return `- ${criterion.id} [${criterion.status}] [${marker}] (${criterion.userModel}) ${criterion.scenario} evidence: ${criterion.capturedEvidence ?? "pending"}`;
@@ -2680,14 +3946,8 @@ function required4(argv, flag) {
     return value;
   throw new UlwLoopError(`Missing ${flag}.`, "ULW_LOOP_ARGUMENT_MISSING", { details: { flag } });
 }
-function findGoal3(plan, goalId) {
-  const goal3 = plan.goals.find((candidate) => candidate.id === goalId);
-  if (goal3 !== undefined)
-    return goal3;
-  throw new UlwLoopError(`Unknown ulw-loop id: ${goalId}.`, "ULW_LOOP_GOAL_NOT_FOUND", { details: { goalId } });
-}
 
-// packages/omo-codex/plugin/components/ulw-loop/src/cli-commands.ts
+// components/ulw-loop/src/cli-commands.ts
 var ULW_LOOP_SUBCOMMANDS = [
   "help",
   "create-goals",
@@ -2710,7 +3970,6 @@ async function ulwLoopCommand(argv) {
   const repoRoot = process.cwd();
   const json = hasFlag(rest, "--json");
   try {
-    const scope = commandScope(rest);
     if (!isUlwLoopSubcommand(command)) {
       if (json) {
         printJsonError(new UlwLoopError(`Unknown ulw-loop subcommand: ${command}.`, "ULW_LOOP_SUBCOMMAND_UNKNOWN", {
@@ -2722,11 +3981,18 @@ async function ulwLoopCommand(argv) {
 `);
       return 1;
     }
-    switch (command) {
-      case "help":
-        process.stdout.write(`${ULW_LOOP_HELP}
+    if (command !== "help" && (hasFlag(rest, "--help") || hasFlag(rest, "-h"))) {
+      process.stdout.write(`${subcommandHelp(command)}
+`);
+      return 0;
+    }
+    if (command === "help") {
+      process.stdout.write(`${ULW_LOOP_HELP}
 `);
-        return 0;
+      return 0;
+    }
+    const scope = commandScope(repoRoot, rest);
+    switch (command) {
       case "create-goals":
         return await createGoals(repoRoot, rest, json, scope);
       case "status":
@@ -2772,26 +4038,29 @@ var SESSION_ID_FLAG = "--session-id";
 function sessionIdFlagPresent(argv) {
   return hasFlag(argv, SESSION_ID_FLAG) || argv.some((arg) => arg.startsWith(`${SESSION_ID_FLAG}=`));
 }
-function commandScope(argv) {
+function commandScope(repoRoot, argv) {
   if (sessionIdFlagPresent(argv)) {
-    const sessionId2 = readValue(argv, SESSION_ID_FLAG)?.trim();
-    if (!sessionId2) {
-      throw new UlwLoopError(`${SESSION_ID_FLAG} requires a non-empty value.`, "ULW_LOOP_SESSION_ID_REQUIRED", {
+    const sessionId = readValue(argv, SESSION_ID_FLAG)?.trim();
+    if (!sessionId) {
+      throw new UlwLoopError(sessionIdRequiredMessage(SESSION_ID_FLAG), "ULW_LOOP_SESSION_ID_REQUIRED", {
         details: { flag: SESSION_ID_FLAG }
       });
     }
-    return { sessionId: sessionId2 };
+    return { sessionId };
   }
   const sessionId = resolveUlwLoopSessionIdFromEnv();
-  return sessionId === null ? undefined : { sessionId };
+  if (sessionId !== null)
+    return { sessionId };
+  const existingSessionIds = listUlwLoopSessionIds(repoRoot);
+  throw new UlwLoopError(sessionScopeRequiredMessage(SESSION_ID_FLAG, existingSessionIds), "ULW_LOOP_SESSION_SCOPE_REQUIRED", { details: { flag: SESSION_ID_FLAG, existingSessionIds } });
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/ultrawork-directive.ts
-import { readFileSync as readFileSync2 } from "node:fs";
+// components/ulw-loop/src/ultrawork-directive.ts
+import { readFileSync as readFileSync5 } from "node:fs";
 
-// packages/omo-codex/plugin/components/ulw-loop/src/ultrawork-skill-pointer.ts
-import { existsSync as existsSync5, readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+// components/ulw-loop/src/ultrawork-skill-pointer.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 var ULTRAWORK_SKILL_POINTER_TEMPLATE = `<ultrawork-mode>
 ULTRAWORK MODE IS ACTIVE FOR THIS TASK.
 
@@ -2822,22 +4091,22 @@ Do not start the requested work until all three steps are complete.
 `;
 var ULTRAWORK_SKILL_PATH_PLACEHOLDER = "{{ULTRAWORK_SKILL_PATH}}";
 var ULTRAWORK_SKILL_FILE_URL = new URL("../../../skills/ultrawork/SKILL.md", import.meta.url);
-var ULTRAWORK_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
+var ULTRAWORK_DIRECTIVE = readFileSync4(new URL("../directive.md", import.meta.url), "utf8");
 function resolveUltraworkSkillFilePath() {
-  return fileURLToPath(ULTRAWORK_SKILL_FILE_URL);
+  return fileURLToPath2(ULTRAWORK_SKILL_FILE_URL);
 }
 function buildUltraworkSkillPointer(skillFilePath) {
   return ULTRAWORK_SKILL_POINTER_TEMPLATE.replace(ULTRAWORK_SKILL_PATH_PLACEHOLDER, skillFilePath);
 }
 function buildUltraworkAdditionalContext(options = {}) {
   const skillFilePath = options.skillFilePath === undefined ? resolveUltraworkSkillFilePath() : options.skillFilePath;
-  if (skillFilePath !== null && existsSync5(skillFilePath)) {
+  if (skillFilePath !== null && existsSync6(skillFilePath)) {
     return buildUltraworkSkillPointer(skillFilePath);
   }
   return ULTRAWORK_DIRECTIVE;
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/ultrawork-directive.ts
+// components/ulw-loop/src/ultrawork-directive.ts
 var ULTRAWORK_CURRENT_PROMPT_PATTERN = /(?:ultrawork|ulw)/i;
 var ULTRAWORK_DIRECTIVE_MARKER = "<ultrawork-mode>";
 var TRANSCRIPT_SEARCH_BYTES = 512000;
@@ -2885,7 +4154,7 @@ function hasUltraworkDirectiveAlreadyInTranscript(transcriptPath) {
   return false;
 }
 function readTranscriptTail(transcriptPath) {
-  const rawTranscript = readFileSync2(transcriptPath);
+  const rawTranscript = readFileSync5(transcriptPath);
   return rawTranscript.subarray(Math.max(0, rawTranscript.byteLength - TRANSCRIPT_SEARCH_BYTES)).toString("utf8");
 }
 function isUltraworkPrompt(prompt) {
@@ -2940,7 +4209,7 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/codex-hook.ts
+// components/ulw-loop/src/codex-hook.ts
 var CREATE_GOAL_TOOL_NAME = "create_goal";
 var CREATE_GOAL_PAYLOAD_WARNING = "Use create_goal with objective only. Omit token_budget so the goal stays unlimited, and put lifecycle status changes on update_goal.";
 function parseUserPromptSubmitPayload(raw) {
@@ -3066,97 +4335,304 @@ function optionalString(value) {
   return value === undefined || typeof value === "string";
 }
 function readAll(stdin) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve, reject) => {
     let data = "";
     stdin.setEncoding("utf8");
     stdin.on("data", (chunk) => {
       data += chunk instanceof Buffer ? chunk.toString() : String(chunk);
     });
     stdin.once("error", reject);
-    stdin.once("end", () => resolve4(data));
+    stdin.once("end", () => resolve(data));
   });
 }
 
-// packages/omo-codex/plugin/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) {
+// components/ulw-loop/src/spawn-guard.ts
+import { mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join7 } from "node:path";
+
+// components/ulw-loop/src/spawn-budget-io.ts
+import { randomBytes } from "node:crypto";
+import { existsSync as existsSync7, readFileSync as readFileSync6, renameSync as renameSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join6 } from "node:path";
+function readAdmissionBreaker(sessionId) {
+  const dataDir = process.env["PLUGIN_DATA"];
+  if (typeof dataDir !== "string")
+    return null;
+  try {
+    const value = JSON.parse(readFileSync6(join6(dataDir, "spawn-breaker", `${sessionId}.json`), "utf8"));
+    return typeof value === "object" && value !== null && "reason" in value && typeof value.reason === "string" ? value.reason : "capacity limit";
+  } catch {
+    return null;
+  }
+}
+function atomicWriteJson(targetPath, data) {
+  const tmp = join6(dirname3(targetPath), `.tmp-${randomBytes(6).toString("hex")}`);
+  writeFileSync2(tmp, JSON.stringify(data));
+  renameSync2(tmp, targetPath);
+}
+function isNonEmptyFile(path) {
+  try {
+    return existsSync7(path) && statSync3(path).size > 0;
+  } catch (error) {
+    if (error instanceof Error)
+      return false;
+    throw error;
+  }
+}
+function readCount(counterPath) {
+  try {
+    const parsed = JSON.parse(readFileSync6(counterPath, "utf8"));
+    return typeof parsed === "object" && parsed !== null && "count" in parsed && typeof parsed.count === "number" && parsed.count >= 0 ? parsed.count : 0;
+  } catch (error) {
+    if (error instanceof Error)
+      return 0;
+    throw error;
+  }
+}
+function readCounts(counterPath) {
+  try {
+    const parsed = JSON.parse(readFileSync6(counterPath, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return {};
+    const counts = {};
+    for (const [key, value] of Object.entries(parsed))
+      if (typeof value === "number" && value >= 0)
+        counts[key] = value;
+    return counts;
+  } catch (error) {
+    if (error instanceof Error)
+      return {};
+    throw error;
+  }
+}
+
+// components/ulw-loop/src/spawn-role-guard.ts
+var LAZYCODEX_SPAWN_ROLES = new Set([
+  "explorer",
+  "lazycodex-clone-fidelity-reviewer",
+  "lazycodex-code-reviewer",
+  "lazycodex-gate-reviewer",
+  "lazycodex-qa-executor",
+  "lazycodex-worker-high",
+  "lazycodex-worker-low",
+  "lazycodex-worker-medium",
+  "librarian",
+  "metis",
+  "momus",
+  "plan"
+]);
+function spawnRoleDenial(input) {
+  const role = typeof input === "object" && input !== null && "agent_type" in input ? input.agent_type : undefined;
+  if (typeof role === "string" && LAZYCODEX_SPAWN_ROLES.has(role))
+    return null;
+  return `LazyCodex requires an explicit registered agent_type: ${[...LAZYCODEX_SPAWN_ROLES].join(", ")}. Received ${JSON.stringify(role) ?? "no agent_type"}. Use the matching role and fork_turns: "none" (V2) or fork_context: false (V1), unless full history is deliberately required. The hook cannot see the tool schema; if agent_type is unavailable, stop and report incompatible role routing rather than spawning a generic agent. Describing a role in message does not select its TOML.`;
+}
+
+// components/ulw-loop/src/spawn-guard.ts
+var SPAWN_TOOL_TOKENS = new Set([
+  "spawn_agent",
+  "multi_agent_v1.spawn_agent",
+  "collaborationspawn_agent",
+  "collaboration.spawn_agent"
+]);
+var DEFAULT_FANOUT_LIMIT = 24;
+var DEFAULT_REVIEW_SPAWN_LIMIT = 3;
+var GATE_MESSAGE_PATTERN = /lazycodex-gate-reviewer|omo-senpi-gate-reviewer|final gate review/i;
+var REVIEW_AGENT_TYPES = [
+  ...Object.values(REVIEWER_ROLES_BY_SURFACE).map((roles) => roles.gateReview),
+  ...Object.values(REVIEWER_ROLES_BY_SURFACE).map((roles) => roles.codeReview),
+  ...Object.values(REVIEWER_ROLES_BY_SURFACE).map((roles) => roles.manualQa)
+];
+var REVIEW_AGENT_TYPE_SET = new Set(REVIEW_AGENT_TYPES);
+function applySpawnGuards(payload, options = {}) {
+  if (payload.hook_event_name !== "PreToolUse" || !SPAWN_TOOL_TOKENS.has(payload.tool_name))
+    return "";
+  if (resolveToolkitSurface() === "lazycodex") {
+    const reason = spawnRoleDenial(payload.tool_input);
+    if (reason !== null)
+      return deny(reason);
+  }
+  return applySpawnBudgetGuards(payload, options);
+}
+function applySpawnBudgetGuards(payload, options = {}) {
   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"));
+  const breaker = readAdmissionBreaker(payload.session_id);
+  if (breaker !== null)
+    return deny(`Subagent admission failed earlier in this session (${breaker}). Do not spawn more workers or reviewers; report the capacity block and wait for the user.`);
+  const scope = { sessionId: payload.session_id };
+  const stateDir = ulwLoopDir(payload.cwd, scope);
+  const plan = readPlan(payload.cwd, payload.session_id);
   if (plan === null)
     return "";
+  const lockOptions = options.lockTimeoutMs === undefined ? {} : { timeoutMs: options.lockTimeoutMs };
+  try {
+    return withStateLockSync(ulwLoopStateLockPath(payload.cwd, scope), () => evaluateGuards(payload, plan, stateDir), lockOptions);
+  } catch (error) {
+    if (isStateLockTimeout(error))
+      return deny(`ulw-loop spawn guard could not take the session state lock: ${error.message}`);
+    throw error;
+  }
+}
+function evaluateGuards(payload, plan, stateDir) {
+  const fanOutPeek = peekFanOutBudget(stateDir);
+  if (fanOutPeek !== null)
+    return deny(fanOutPeek);
+  const missingArtifact = missingGateArtifact(payload, plan);
+  if (missingArtifact !== null)
+    return deny(`record manual QA first; gate audits its artifacts: missing ${missingArtifact}`);
+  const reviewDenial = consumeReviewSpawnBudget(payload, plan, stateDir);
+  if (reviewDenial !== null)
+    return deny(reviewDenial);
   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 runSpawnAdmissionRecorderCli(stdin, stdout) {
+  const chunks = [];
+  for await (const chunk of stdin)
+    chunks.push(Buffer.from(chunk));
+  try {
+    const payload = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    const response = typeof payload["tool_response"] === "string" ? payload["tool_response"] : JSON.stringify(payload["tool_response"] ?? "");
+    if (!/too many active cells|AgentLimitReached|max_threads|max_concurrent_threads_per_session/i.test(response))
+      return;
+    const dataDir = process.env["PLUGIN_DATA"];
+    if (typeof dataDir !== "string" || typeof payload["session_id"] !== "string")
+      return;
+    const markerDir = join7(dataDir, "spawn-breaker");
+    try {
+      mkdirSync3(markerDir, { recursive: true });
+      atomicWriteJson(join7(markerDir, `${payload["session_id"]}.json`), {
+        reason: response,
+        at: new Date().toISOString()
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[ulw-loop] spawn-guard: could not persist admission failure: ${message}
+`);
+    }
+  } catch {}
+}
 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)
+    if (payload === null) {
+      stdout.write(deny("LazyCodex spawn guard received an invalid hook payload; role routing was not verified."));
       return;
+    }
     const output = applySpawnGuards(payload);
     if (output.length > 0)
       stdout.write(output);
   } catch (error) {
-    if (error instanceof Error)
-      return;
+    stdout.write(deny(`LazyCodex spawn guard failed: ${error instanceof Error ? error.message : String(error)}`));
   }
 }
+function peekFanOutBudget(stateDir) {
+  const counterPath = join7(stateDir, "spawn-count.json");
+  const count = readCount(counterPath) + 1;
+  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 consumeFanOutBudget(stateDir) {
-  const counterPath = join2(stateDir, "spawn-count.json");
+  const counterPath = join7(stateDir, "spawn-count.json");
   const count = readCount(counterPath) + 1;
-  writeFileSync(counterPath, JSON.stringify({ count }));
+  atomicWriteJson(counterPath, { 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 consumeReviewSpawnBudget(payload, plan, stateDir) {
+  const agentType = reviewAgentType(payload.tool_input);
+  if (agentType === null)
+    return null;
+  const goal = plan.goals.find((candidate) => candidate.id === plan.activeGoalId) ?? plan.goals.find((candidate) => isFinalRunCompletionCandidate(plan, candidate));
+  if (goal === undefined)
+    return null;
+  const counterPath = join7(stateDir, "review-spawn-counts.json");
+  const limit = reviewSpawnLimit();
+  const counts = readCounts(counterPath);
+  const key = `${agentType}:${goal.id}:a${goal.attempt}`;
+  const count = (counts[key] ?? 0) + 1;
+  if (count > limit)
+    return `ulw-loop reviewer no-progress cap reached (${agentType} ${count}/${limit}) for ${goal.id} attempt ${goal.attempt}. Consolidate existing review findings, or checkpoint and start a new attempt after concrete progress.`;
+  counts[key] = count;
+  atomicWriteJson(counterPath, counts);
+  return null;
+}
 function missingGateArtifact(payload, plan) {
   if (!isGateReviewerSpawn(payload.tool_input))
     return null;
-  const goal3 = plan.goals.find((candidate) => isFinalRunCompletionCandidate(plan, candidate));
-  if (goal3 === undefined || goal3.status === "complete")
+  const goal = plan.goals.find((candidate) => isFinalRunCompletionCandidate(plan, candidate));
+  if (goal === undefined || goal.status === "complete")
     return null;
-  if (!goal3.successCriteria.every((criterion) => criterion.status === "pass"))
+  if (!goal.successCriteria.every((criterion) => criterion.status === "pass"))
     return null;
   const scope = { sessionId: payload.session_id };
+  const requiredArtifacts = [`${goal.id}-manual-qa.md`];
   if (plan.evidenceLayoutVersion === 2) {
-    const attemptDir = ulwLoopAttemptEvidenceDir(goal3.id, goal3.attempt, scope);
-    for (const name of [`${goal3.id}-code-review.md`, `${goal3.id}-manual-qa.md`]) {
-      const relative2 = `${attemptDir}/${name}`;
-      if (!isNonEmptyFile(join2(payload.cwd, relative2)))
-        return relative2;
+    const attemptDir = ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope);
+    for (const name of requiredArtifacts) {
+      const relative = `${attemptDir}/${name}`;
+      if (!isNonEmptyFile(join7(payload.cwd, relative)))
+        return relative;
     }
     return null;
   }
-  const flatReport = `.omo/evidence/${goal3.id}-code-review.md`;
-  if (!isNonEmptyFile(join2(payload.cwd, flatReport)))
-    return flatReport;
-  if (!hasOtherEvidenceFile(join2(payload.cwd, ".omo", "evidence"), `${goal3.id}-code-review.md`))
-    return `.omo/evidence/<any manual-QA artifact besides ${goal3.id}-code-review.md>`;
-  return null;
+  const manualQa = `.omo/evidence/${goal.id}-manual-qa.md`;
+  return isNonEmptyFile(join7(payload.cwd, manualQa)) ? null : manualQa;
 }
 function isGateReviewerSpawn(toolInput) {
+  const agentType = reviewAgentType(toolInput);
+  return agentType !== null && GATE_REVIEWER_AGENT_NAMES.has(agentType);
+}
+function reviewAgentType(toolInput) {
   if (typeof toolInput !== "object" || toolInput === null)
-    return false;
+    return null;
   const record = toolInput;
   const agentType = record["agent_type"];
-  if (typeof agentType === "string")
-    return agentType === "lazycodex-gate-reviewer";
+  if (typeof agentType === "string") {
+    if (!REVIEW_AGENT_TYPE_SET.has(agentType))
+      return null;
+    return activeSurfaceReviewerAlias(agentType);
+  }
   const message = record["message"];
-  return typeof message === "string" && GATE_MESSAGE_PATTERN.test(message);
+  if (typeof message !== "string")
+    return null;
+  const normalizedMessage = message.toLowerCase();
+  const allRoleNames = [...REVIEW_AGENT_TYPES];
+  const explicitAssignment = allRoleNames.map((name) => ({
+    name,
+    index: normalizedMessage.search(new RegExp(`\\bact as (?:an? )?${name}\\b`))
+  })).filter(({ index }) => index >= 0).sort((left, right) => left.index - right.index)[0];
+  if (explicitAssignment !== undefined)
+    return activeSurfaceReviewerAlias(explicitAssignment.name);
+  const nonReviewerActAs = /\bact as (?:an? )?\S+/.test(normalizedMessage);
+  if (nonReviewerActAs)
+    return null;
+  const namedReviewer = REVIEW_AGENT_TYPES.find((name) => normalizedMessage.includes(name));
+  if (namedReviewer !== undefined)
+    return activeSurfaceReviewerAlias(namedReviewer);
+  return GATE_MESSAGE_PATTERN.test(message) ? reviewerRolesFor(resolveToolkitSurface()).gateReview : null;
+}
+function activeSurfaceReviewerAlias(reviewer) {
+  const activeRoles = reviewerRolesFor(resolveToolkitSurface());
+  for (const roles of Object.values(REVIEWER_ROLES_BY_SURFACE)) {
+    if (reviewer === roles.codeReview)
+      return activeRoles.codeReview;
+    if (reviewer === roles.manualQa)
+      return activeRoles.manualQa;
+    if (reviewer === roles.gateReview)
+      return activeRoles.gateReview;
+  }
+  return reviewer;
 }
 function deny(reason) {
   return `${JSON.stringify({
@@ -3176,37 +4652,16 @@ function fanOutLimit() {
   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 reviewSpawnLimit() {
+  const raw = process.env["OMO_ULW_LOOP_REVIEW_SPAWN_LIMIT"];
+  if (raw === undefined)
+    return DEFAULT_REVIEW_SPAWN_LIMIT;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_REVIEW_SPAWN_LIMIT;
 }
-function readPlan(goalsPath) {
+function readPlan(repoRoot, sessionId) {
   try {
-    return JSON.parse(readFileSync3(goalsPath, "utf8"));
+    return readUlwLoopPlanSync(repoRoot, { sessionId });
   } catch (error) {
     if (error instanceof Error)
       return null;
@@ -3214,9 +4669,9 @@ function readPlan(goalsPath) {
   }
 }
 
-// packages/omo-codex/plugin/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, resolve as resolve4, sep as sep2 } from "node:path";
+// components/ulw-loop/src/stop-resume-hook.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
+import { isAbsolute as isAbsolute3, join as join8, resolve as resolve5, sep as sep3 } from "node:path";
 var RESUME_CAP = 2;
 var CONTEXT_PRESSURE_MARKERS2 = [
   "context compacted",
@@ -3235,18 +4690,19 @@ function runStopResumeHook(input) {
     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"));
+  const scope = { sessionId: payload.session_id };
+  const stateDir = ulwLoopDir(payload.cwd, scope);
+  const plan = readPlan2(payload.cwd, payload.session_id);
   if (plan === null || plan.aggregateCompletion?.status === "complete")
     return "";
-  const goal3 = resumableGoal(plan);
-  if (goal3 === undefined)
+  const goal = resumableGoal(plan);
+  if (goal === undefined)
     return "";
-  if (!consumeResumeBudget(stateDir, goal3.id))
+  if (!consumeResumeBudgetLocked(ulwLoopStateLockPath(payload.cwd, scope), stateDir, goal.id))
     return "";
   const output = {
     decision: "block",
-    reason: renderResumeDirective(plan, goal3, payload.session_id)
+    reason: renderResumeDirective(plan, goal, payload.session_id)
   };
   return JSON.stringify(output);
 }
@@ -3264,38 +4720,47 @@ async function runStopResumeHookCli(stdin, stdout) {
   }
 }
 function resumableGoal(plan) {
-  const active = plan.goals.find((goal3) => goal3.id === plan.activeGoalId);
+  const active = plan.goals.find((goal) => goal.id === plan.activeGoalId);
   if (active !== undefined && isResumableStatus(active.status))
     return active;
-  return plan.goals.find((goal3) => isResumableStatus(goal3.status));
+  return plan.goals.find((goal) => isResumableStatus(goal.status));
+}
+function isResumableStatus(status) {
+  return status === "pending" || status === "in_progress";
 }
-function isResumableStatus(status2) {
-  return status2 === "pending" || status2 === "in_progress";
+function consumeResumeBudgetLocked(lockPath, stateDir, goalId) {
+  try {
+    return withStateLockSync(lockPath, () => consumeResumeBudget(stateDir, goalId));
+  } catch (error) {
+    if (isStateLockTimeout(error))
+      return false;
+    throw error;
+  }
 }
 function consumeResumeBudget(stateDir, goalId) {
-  const ledgerLineCount = countLedgerLines(join3(stateDir, "ledger.jsonl"));
-  const counterPath = resolve4(stateDir, `auto-resume-${goalId}.json`);
-  const stuckPath = resolve4(stateDir, `auto-resume-${goalId}.stuck`);
+  const ledgerLineCount = readLedgerAt(stateDir).length;
+  const counterPath = resolve5(stateDir, `auto-resume-${goalId}.json`);
+  const stuckPath = resolve5(stateDir, `auto-resume-${goalId}.stuck`);
   if (!isInsideDir(stateDir, counterPath) || !isInsideDir(stateDir, stuckPath))
     return false;
   const previous = readCounter(counterPath);
   const count = previous !== null && previous.ledgerLineCount === ledgerLineCount ? previous.count : 0;
   if (count >= RESUME_CAP) {
-    writeFileSync2(stuckPath, `no ledger progress after ${count} resumes
+    writeFileSync3(stuckPath, `no ledger progress after ${count} resumes
 `);
     return false;
   }
-  writeFileSync2(counterPath, JSON.stringify({ count: count + 1, ledgerLineCount }));
+  writeFileSync3(counterPath, JSON.stringify({ count: count + 1, ledgerLineCount }));
   return true;
 }
 function isInsideDir(dir, candidate) {
-  return candidate.startsWith(resolve4(dir) + sep2);
+  return candidate.startsWith(resolve5(dir) + sep3);
 }
-function renderResumeDirective(plan, goal3, sessionId) {
+function renderResumeDirective(plan, goal, 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: ${goal3.id} — ${goal3.title}).`,
+    `The ulw-loop run in this session still has unfinished goals (next: ${goal.id} — ${goal.title}).`,
     "The turn ended before the loop completed. Resume it now:",
     `1. Run \`omo-agent-toolkit 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.",
@@ -3304,30 +4769,20 @@ function renderResumeDirective(plan, goal3, sessionId) {
   ].join(`
 `);
 }
-function readPlan2(goalsPath) {
+function readPlan2(repoRoot, sessionId) {
   try {
-    return JSON.parse(readFileSync4(goalsPath, "utf8"));
+    return readUlwLoopPlanSync(repoRoot, { sessionId });
   } 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))
+    if (!existsSync8(counterPath))
       return null;
-    const parsed = JSON.parse(readFileSync4(counterPath, "utf8"));
+    const parsed = JSON.parse(readFileSync7(counterPath, "utf8"));
     if (typeof parsed["count"] !== "number" || typeof parsed["ledgerLineCount"] !== "number")
       return null;
     return { count: parsed["count"], ledgerLineCount: parsed["ledgerLineCount"] };
@@ -3339,7 +4794,7 @@ function readCounter(counterPath) {
 }
 function boulderContinuationWillFire(cwd, sessionId) {
   try {
-    const raw = JSON.parse(readFileSync4(join3(cwd, ".omo", "boulder.json"), "utf8"));
+    const raw = JSON.parse(readFileSync7(join8(cwd, ".omo", "boulder.json"), "utf8"));
     const works = raw["works"];
     const entries = typeof works === "object" && works !== null ? Object.values(works) : [raw];
     return entries.some((work) => {
@@ -3358,7 +4813,7 @@ function boulderContinuationWillFire(cwd, sessionId) {
 }
 function transcriptShowsContextPressure(transcriptPath) {
   try {
-    const transcript = readFileSync4(transcriptPath, "utf8").toLowerCase();
+    const transcript = readFileSync7(transcriptPath, "utf8").toLowerCase();
     return CONTEXT_PRESSURE_MARKERS2.some((marker) => transcript.includes(marker));
   } catch (error) {
     if (error instanceof Error)
@@ -3370,12 +4825,12 @@ function boulderPlanHasChecklist(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 planPath = isAbsolute3(activePlan) ? activePlan : join8(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];
+  const candidates = typeof worktree === "string" && worktree.trim().length > 0 && !isAbsolute3(activePlan) ? [join8(isAbsolute3(worktree) ? worktree : join8(cwd, worktree), activePlan), planPath] : [planPath];
   for (const candidate of candidates) {
     try {
-      return readFileSync4(candidate, "utf8").split(/\r?\n/).some((line) => line.startsWith("- [ ] ") || line.startsWith("- [x] ") || line.startsWith("- [X] "));
+      return readFileSync7(candidate, "utf8").split(/\r?\n/).some((line) => line.startsWith("- [ ] ") || line.startsWith("- [x] ") || line.startsWith("- [X] "));
     } catch (error) {
       if (!(error instanceof Error))
         throw error;
@@ -3399,19 +4854,13 @@ function parseStopPayload(value) {
   };
 }
 
-// packages/omo-codex/plugin/components/ulw-loop/src/cli.ts
-var TOP_LEVEL_HELP = `Usage:
-  omo-agent-toolkit ulw-loop <subcommand> [args]
-  omo-agent-toolkit hook user-prompt-submit [--with-ultrawork]  (Codex UserPromptSubmit hook)
-  omo-agent-toolkit help | --help | -h                          (this message)
-
-Run \`omo-agent-toolkit ulw-loop help\` for ulw-loop subcommands.
-`;
+// components/ulw-loop/src/cli.ts
 async function main() {
   const argv = process.argv.slice(2);
   const command = argv[0];
   if (command === undefined || command === "help" || command === "--help" || command === "-h") {
-    process.stdout.write(TOP_LEVEL_HELP);
+    process.stdout.write(`${ULW_LOOP_HELP}
+`);
     return 0;
   }
   if (command === "ulw-loop")
@@ -3432,6 +4881,10 @@ async function main() {
       await runStopResumeHookCli(process.stdin, process.stdout);
       return 0;
     }
+    if (sub === "post-tool-use-spawn") {
+      await runSpawnAdmissionRecorderCli(process.stdin, process.stdout);
+      return 0;
+    }
     if (sub === "pre-tool-use-spawn") {
       await runSpawnGuardCli(process.stdin, process.stdout);
       return 0;
@@ -3443,7 +4896,8 @@ async function main() {
   if (isUlwLoopSubcommand(command))
     return ulwLoopCommand(argv);
   process.stderr.write(`[omo] unknown command: ${command}
-${TOP_LEVEL_HELP}`);
+${ULW_LOOP_HELP}
+`);
   return 1;
 }
 main().then((code) => {