oh-my-opencode 4.8.1 → 4.9.1

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

@@ -0,0 +1,97 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+export class CodexGoalSnapshotError extends Error {
+}
+function safeObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function safeString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+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 normalizeObjective(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export 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"] ?? root["objective"]);
+    const status = normalizeStatus(goal["status"] ?? root["status"]);
+    return {
+        available: Boolean(objective || status !== "unknown"),
+        ...(objective ? { objective } : {}),
+        status,
+        raw: value,
+    };
+}
+export 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})` : ""}`);
+        }
+    }
+}
+export 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 = normalizeObjective(options.expectedObjective);
+    const accepted = new Set([expected, ...(options.acceptedObjectives ?? []).map((objective) => normalizeObjective(objective))].filter(Boolean));
+    const actual = normalizeObjective(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}.`);
+    }
+    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.');
+    }
+    return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
+}
+export function formatCodexGoalReconciliation(reconciliation) {
+    const parts = [...reconciliation.errors, ...reconciliation.warnings];
+    return parts.join(" ");
+}

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

@@ -0,0 +1,28 @@
+export interface UserPromptSubmitPayload {
+    readonly cwd: string;
+    readonly hook_event_name: "UserPromptSubmit";
+    readonly model?: string;
+    readonly permission_mode?: string;
+    readonly prompt: string;
+    readonly session_id: string;
+    readonly transcript_path?: string;
+    readonly turn_id?: string;
+}
+export interface PreToolUsePayload {
+    readonly cwd: string;
+    readonly hook_event_name: "PreToolUse";
+    readonly model: string;
+    readonly permission_mode: string;
+    readonly session_id: string;
+    readonly tool_input: unknown;
+    readonly tool_name: string;
+    readonly tool_use_id: string;
+    readonly transcript_path: string | null;
+    readonly turn_id: string;
+}
+export declare function parseUserPromptSubmitPayload(raw: string): UserPromptSubmitPayload | null;
+export declare function parsePreToolUsePayload(raw: string): PreToolUsePayload | null;
+export declare function applyUserPromptUlwLoopSteering(payload: UserPromptSubmitPayload): Promise<string>;
+export declare function applyPreToolUseGoalBudgetGuard(payload: PreToolUsePayload): string;
+export declare function runUlwLoopHookCli(stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream): Promise<void>;
+export declare function runPreToolUseGoalBudgetGuardCli(stdin: NodeJS.ReadableStream, stdout: NodeJS.WritableStream): Promise<void>;

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

@@ -0,0 +1,145 @@
+import { parseUlwLoopSteeringDirective, steerUlwLoop } from "./steering.js";
+const CREATE_GOAL_TOOL_NAME = "create_goal";
+const 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.";
+export function parseUserPromptSubmitPayload(raw) {
+    if (raw.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return isUserPromptSubmitPayload(parsed) ? parsed : null;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return null;
+        return null;
+    }
+}
+export function parsePreToolUsePayload(raw) {
+    if (raw.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return isPreToolUsePayload(parsed) ? parsed : null;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return null;
+        return null;
+    }
+}
+export async function applyUserPromptUlwLoopSteering(payload) {
+    try {
+        if (payload.hook_event_name !== "UserPromptSubmit")
+            return "";
+        const proposal = parseUlwLoopSteeringDirective(payload.prompt);
+        if (proposal === null)
+            return "";
+        const result = await steerUlwLoop(payload.cwd, proposal, payloadScope(payload));
+        if (!result.accepted)
+            return "";
+        return JSON.stringify({
+            status: "accepted",
+            kind: result.audit.kind,
+            source: result.audit.source,
+            deduped: result.deduped,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return "";
+        return "";
+    }
+}
+function payloadScope(payload) {
+    return { sessionId: payload.session_id };
+}
+export function applyPreToolUseGoalBudgetGuard(payload) {
+    if (payload.hook_event_name !== "PreToolUse")
+        return "";
+    if (payload.tool_name !== CREATE_GOAL_TOOL_NAME)
+        return "";
+    if (!hasInvalidCreateGoalInput(payload.tool_input))
+        return "";
+    const output = {
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: CREATE_GOAL_PAYLOAD_WARNING,
+            additionalContext: CREATE_GOAL_PAYLOAD_WARNING,
+        },
+    };
+    return `${JSON.stringify(output)}\n`;
+}
+export async function runUlwLoopHookCli(stdin, stdout) {
+    try {
+        const payload = parseUserPromptSubmitPayload(await readAll(stdin));
+        if (payload === null)
+            return;
+        const output = await applyUserPromptUlwLoopSteering(payload);
+        if (output.length > 0)
+            stdout.write(output);
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return;
+        return;
+    }
+}
+export async function runPreToolUseGoalBudgetGuardCli(stdin, stdout) {
+    try {
+        const payload = parsePreToolUsePayload(await readAll(stdin));
+        if (payload === null)
+            return;
+        const output = applyPreToolUseGoalBudgetGuard(payload);
+        if (output.length > 0)
+            stdout.write(output);
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return;
+        return;
+    }
+}
+function isUserPromptSubmitPayload(value) {
+    if (!isRecord(value))
+        return false;
+    return (value["hook_event_name"] === "UserPromptSubmit" &&
+        typeof value["cwd"] === "string" &&
+        typeof value["prompt"] === "string" &&
+        typeof value["session_id"] === "string" &&
+        ["model", "permission_mode", "transcript_path", "turn_id"].every((key) => optionalString(value[key])));
+}
+function isPreToolUsePayload(value) {
+    if (!isRecord(value))
+        return false;
+    return (value["hook_event_name"] === "PreToolUse" &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["session_id"] === "string" &&
+        typeof value["tool_name"] === "string" &&
+        typeof value["tool_use_id"] === "string" &&
+        (value["transcript_path"] === null || typeof value["transcript_path"] === "string") &&
+        typeof value["turn_id"] === "string" &&
+        Object.hasOwn(value, "tool_input"));
+}
+function hasInvalidCreateGoalInput(value) {
+    return isRecord(value) && Object.keys(value).some((key) => key !== "objective");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+    return value === undefined || typeof value === "string";
+}
+function readAll(stdin) {
+    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", () => resolve(data));
+    });
+}

package/packages/omo-codex/plugin/components/ulw-loop/dist/command-types.d.ts

@@ -0,0 +1,34 @@
+import type { UlwLoopCodexGoalMode, UlwLoopStatus } from "./constants.js";
+export interface CreateUlwLoopOptions {
+    brief: string;
+    goals?: readonly {
+        readonly title?: string;
+        readonly objective: string;
+    }[];
+    codexGoalMode?: UlwLoopCodexGoalMode;
+    now?: Date;
+    force?: boolean;
+}
+export interface StartNextOptions {
+    now?: Date;
+    retryFailed?: boolean;
+}
+export interface CheckpointOptions {
+    goalId: string;
+    status: Extract<UlwLoopStatus, "complete" | "failed"> | "blocked";
+    evidence?: string;
+    codexGoal?: unknown;
+    qualityGate?: unknown;
+    allowActiveFinalCodexGoal?: boolean;
+    now?: Date;
+}
+export interface AddUlwLoopGoalOptions {
+    title: string;
+    objective: string;
+    evidence?: string;
+    now?: Date;
+}
+export interface RecordFinalReviewBlockersOptions extends AddUlwLoopGoalOptions {
+    goalId: string;
+    codexGoal?: unknown;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,16 @@
+export declare const ULW_LOOP_DIR = ".omo/ulw-loop";
+export declare const ULW_LOOP_BRIEF = "brief.md";
+export declare const ULW_LOOP_GOALS = "goals.json";
+export declare const ULW_LOOP_LEDGER = "ledger.jsonl";
+export type UlwLoopStatus = "pending" | "in_progress" | "complete" | "failed" | "blocked" | "review_blocked" | "needs_user_decision";
+export type UlwLoopCodexGoalMode = "aggregate" | "per_story";
+export type UlwLoopSteeringStatus = "superseded" | "blocked";
+export declare const ULW_LOOP_STEERING_MUTATION_KINDS: readonly ["add_subgoal", "split_subgoal", "reorder_pending", "revise_pending_wording", "revise_criterion", "annotate_ledger", "mark_blocked_superseded"];
+export type UlwLoopSteeringMutationKind = (typeof ULW_LOOP_STEERING_MUTATION_KINDS)[number];
+export type UlwLoopSteeringSource = "user_prompt_submit" | "finding" | "cli";
+export declare const ULW_LOOP_SUCCESS_CRITERION_USER_MODELS: readonly ["happy", "edge", "regression", "adversarial"];
+export type UlwLoopSuccessCriterionUserModel = (typeof ULW_LOOP_SUCCESS_CRITERION_USER_MODELS)[number];
+export declare const ULW_LOOP_CRITERION_STATUSES: readonly ["pending", "pass", "fail", "blocked"];
+export type UlwLoopCriterionStatus = (typeof ULW_LOOP_CRITERION_STATUSES)[number];
+export declare const ULW_LOOP_LEDGER_EVENT_KINDS: readonly ["plan_created", "goal_started", "goal_resumed", "goal_completed", "goal_blocked", "goal_failed", "goal_needs_user_decision", "goal_retried", "aggregate_completed", "aggregate_objective_migrated", "goal_added", "steering_accepted", "steering_rejected", "final_review_failed", "goal_review_blocked", "evidence_captured", "criterion_failed", "criterion_blocked", "criteria_revised"];
+export type UlwLoopLedgerEventKind = (typeof ULW_LOOP_LEDGER_EVENT_KINDS)[number];

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

@@ -0,0 +1,41 @@
+export const ULW_LOOP_DIR = ".omo/ulw-loop";
+export const ULW_LOOP_BRIEF = "brief.md";
+export const ULW_LOOP_GOALS = "goals.json";
+export const ULW_LOOP_LEDGER = "ledger.jsonl";
+export const ULW_LOOP_STEERING_MUTATION_KINDS = [
+    "add_subgoal",
+    "split_subgoal",
+    "reorder_pending",
+    "revise_pending_wording",
+    "revise_criterion",
+    "annotate_ledger",
+    "mark_blocked_superseded",
+];
+export const ULW_LOOP_SUCCESS_CRITERION_USER_MODELS = [
+    "happy",
+    "edge",
+    "regression",
+    "adversarial",
+];
+export const ULW_LOOP_CRITERION_STATUSES = ["pending", "pass", "fail", "blocked"];
+export const ULW_LOOP_LEDGER_EVENT_KINDS = [
+    "plan_created",
+    "goal_started",
+    "goal_resumed",
+    "goal_completed",
+    "goal_blocked",
+    "goal_failed",
+    "goal_needs_user_decision",
+    "goal_retried",
+    "aggregate_completed",
+    "aggregate_objective_migrated",
+    "goal_added",
+    "steering_accepted",
+    "steering_rejected",
+    "final_review_failed",
+    "goal_review_blocked",
+    "evidence_captured",
+    "criterion_failed",
+    "criterion_blocked",
+    "criteria_revised",
+];

package/packages/omo-codex/plugin/components/ulw-loop/dist/domain-types.d.ts

@@ -0,0 +1,95 @@
+import type { UlwLoopCodexGoalMode, UlwLoopCriterionStatus, UlwLoopLedgerEventKind, UlwLoopStatus, UlwLoopSteeringMutationKind, UlwLoopSteeringStatus, UlwLoopSuccessCriterionUserModel } from "./constants.js";
+import type { UlwLoopSteeringAudit } from "./steering-types.js";
+export interface UlwLoopSuccessCriterion {
+    readonly id: string;
+    readonly scenario: string;
+    readonly userModel: UlwLoopSuccessCriterionUserModel;
+    readonly expectedEvidence: string;
+    capturedEvidence: string | null;
+    status: UlwLoopCriterionStatus;
+    capturedAt?: string;
+    notes?: string;
+}
+export interface UlwLoopItem {
+    id: string;
+    title: string;
+    objective: string;
+    status: UlwLoopStatus;
+    successCriteria: UlwLoopSuccessCriterion[];
+    attempt: number;
+    createdAt: string;
+    updatedAt: string;
+    startedAt?: string;
+    completedAt?: string;
+    failedAt?: string;
+    reviewBlockedAt?: string;
+    evidence?: string;
+    failureReason?: string;
+    steeringStatus?: UlwLoopSteeringStatus;
+    supersededBy?: string[];
+    supersedes?: string[];
+    blockedReason?: string;
+    blockerSignature?: string;
+    blockerOccurrenceCount?: number;
+    requiredExternalDecision?: string;
+    nonRetriable?: boolean;
+    steeringEvidence?: string;
+    steeringRationale?: string;
+}
+export interface UlwLoopAggregateCompletion {
+    status: "complete";
+    completedAt: string;
+    evidence: string;
+    codexGoal?: unknown;
+}
+export interface UlwLoopPlan {
+    version: 1;
+    createdAt: string;
+    updatedAt: string;
+    briefPath: string;
+    goalsPath: string;
+    ledgerPath: string;
+    codexGoalMode?: UlwLoopCodexGoalMode;
+    codexObjective?: string;
+    codexObjectiveAliases?: string[];
+    aggregateCompletion?: UlwLoopAggregateCompletion;
+    activeGoalId?: string;
+    goals: UlwLoopItem[];
+}
+export interface UlwLoopQualityGate {
+    aiSlopCleaner: {
+        status: "passed";
+        evidence: string;
+    };
+    verification: {
+        status: "passed";
+        commands: string[];
+        evidence: string;
+    };
+    codeReview: {
+        recommendation: "APPROVE";
+        architectStatus: "CLEAR";
+        evidence: string;
+    };
+}
+export interface UlwLoopLedgerEntry {
+    at: string;
+    kind: UlwLoopLedgerEventKind;
+    goalId?: string;
+    criterionId?: string;
+    status?: UlwLoopStatus;
+    criterionStatus?: UlwLoopCriterionStatus;
+    message?: string;
+    codexGoal?: unknown;
+    evidence?: string;
+    capturedEvidence?: string;
+    qualityGate?: UlwLoopQualityGate;
+    steering?: UlwLoopSteeringAudit;
+    before?: unknown;
+    after?: unknown;
+    mutationKind?: UlwLoopSteeringMutationKind;
+    idempotencyKey?: string;
+    blockerSignature?: string;
+    blockerOccurrenceCount?: number;
+    requiredExternalDecision?: string;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,31 @@
+import type { UlwLoopScope } from "./paths.js";
+import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
+type EvidenceStatus = "pass" | "fail" | "blocked";
+type RecordEvidenceArgs = {
+    readonly goalId: string;
+    readonly criterionId: string;
+    readonly status: EvidenceStatus;
+    readonly evidence: string;
+    readonly notes?: string;
+};
+export declare function recordEvidence(repoRoot: string, args: RecordEvidenceArgs, scope?: UlwLoopScope): Promise<{
+    plan: UlwLoopPlan;
+    goal: UlwLoopItem;
+    criterion: UlwLoopSuccessCriterion;
+    ledgerEntry: UlwLoopLedgerEntry;
+}>;
+export declare function markCriteriaPendingResetForGoal(repoRoot: string, goalId: string, scope?: UlwLoopScope): Promise<{
+    plan: UlwLoopPlan;
+    resetCount: number;
+}>;
+export declare function criteriaSummary(plan: UlwLoopPlan): {
+    totalCriteria: number;
+    passCount: number;
+    pendingCount: number;
+    failCount: number;
+    blockedCount: number;
+    goalsWithUnresolvedCriteria: string[];
+};
+export declare function unresolvedCriteriaOf(goal: UlwLoopItem): UlwLoopSuccessCriterion[];
+export declare function requireAllCriteriaPass(goal: UlwLoopItem): void;
+export {};

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

@@ -0,0 +1,119 @@
+// biome-ignore-all format: keep this module under the mandated pure LOC budget.
+import { hasAllCriteriaPass } from "./goal-status.js";
+import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { iso, UlwLoopError } from "./types.js";
+function ulwLoopFail(message, code, details) { throw new UlwLoopError(message, code, { details }); }
+function ledgerKind(status) {
+    switch (status) {
+        case "pass":
+            return "evidence_captured";
+        case "fail":
+            return "criterion_failed";
+        case "blocked":
+            return "criterion_blocked";
+        default:
+            return ulwLoopFail("Invalid criterion status.", "ULW_LOOP_CRITERION_STATUS_INVALID", { status });
+    }
+}
+function findGoal(plan, goalId) {
+    const goal = plan.goals.find((candidate) => candidate.id === goalId);
+    return goal ?? ulwLoopFail(`UlwLoop goal not found: ${goalId}.`, "ULW_LOOP_GOAL_NOT_FOUND", { goalId });
+}
+function findCriterion(goal, criterionId) {
+    const criterion = goal.successCriteria.find((candidate) => candidate.id === criterionId);
+    return criterion ?? ulwLoopFail(`Success criterion not found: ${criterionId}.`, "ULW_LOOP_CRITERION_NOT_FOUND", { goalId: goal.id, criterionId });
+}
+function nonEmptyEvidence(evidence) { const trimmed = evidence.trim(); return trimmed || ulwLoopFail("Evidence must be a non-empty string.", "ULW_LOOP_EVIDENCE_REQUIRED", {}); }
+export async function recordEvidence(repoRoot, args, scope) {
+    return withUlwLoopMutationLock(repoRoot, scope, async () => {
+        const plan = await readUlwLoopPlan(repoRoot, scope);
+        const goal = findGoal(plan, args.goalId);
+        const criterion = findCriterion(goal, args.criterionId);
+        const evidence = nonEmptyEvidence(args.evidence);
+        const kind = ledgerKind(args.status);
+        const prevStatus = criterion.status;
+        const capturedAt = iso();
+        criterion.status = args.status;
+        criterion.capturedEvidence = evidence;
+        criterion.capturedAt = capturedAt;
+        if (args.notes !== undefined)
+            criterion.notes = args.notes;
+        goal.updatedAt = capturedAt;
+        plan.updatedAt = capturedAt;
+        await writePlan(repoRoot, plan, scope);
+        const ledgerEntry = {
+            at: capturedAt,
+            kind,
+            goalId: goal.id,
+            criterionId: criterion.id,
+            criterionStatus: args.status,
+            evidence,
+            capturedEvidence: evidence,
+            before: { status: prevStatus },
+            after: { goalId: goal.id, criterionId: criterion.id, status: args.status, evidence, capturedAt, prevStatus },
+        };
+        await appendLedger(repoRoot, ledgerEntry, scope);
+        return { plan, goal, criterion, ledgerEntry };
+    });
+}
+export async function markCriteriaPendingResetForGoal(repoRoot, goalId, scope) {
+    return withUlwLoopMutationLock(repoRoot, scope, async () => {
+        const plan = await readUlwLoopPlan(repoRoot, scope);
+        const goal = findGoal(plan, goalId);
+        const now = iso();
+        const before = goal.successCriteria.map((criterion) => ({ id: criterion.id, status: criterion.status, capturedEvidence: criterion.capturedEvidence, capturedAt: criterion.capturedAt ?? null }));
+        for (const criterion of goal.successCriteria) {
+            criterion.status = "pending";
+            criterion.capturedEvidence = null;
+            delete criterion.capturedAt;
+            delete criterion.notes;
+        }
+        goal.updatedAt = now;
+        plan.updatedAt = now;
+        await writePlan(repoRoot, plan, scope);
+        await appendLedger(repoRoot, { at: now, kind: "criteria_revised", goalId, message: `Reset ${goal.successCriteria.length} criteria to pending.`, before, after: { resetCount: goal.successCriteria.length } }, scope);
+        return { plan, resetCount: goal.successCriteria.length };
+    });
+}
+export function criteriaSummary(plan) {
+    let totalCriteria = 0;
+    let passCount = 0;
+    let pendingCount = 0;
+    let failCount = 0;
+    let blockedCount = 0;
+    const goalsWithUnresolvedCriteria = [];
+    for (const goal of plan.goals) {
+        let unresolved = false;
+        for (const criterion of goal.successCriteria) {
+            totalCriteria += 1;
+            if (criterion.status !== "pass")
+                unresolved = true;
+            switch (criterion.status) {
+                case "pass":
+                    passCount += 1;
+                    break;
+                case "pending":
+                    pendingCount += 1;
+                    break;
+                case "fail":
+                    failCount += 1;
+                    break;
+                case "blocked":
+                    blockedCount += 1;
+                    break;
+                default: ulwLoopFail("Invalid criterion status.", "ULW_LOOP_CRITERION_STATUS_INVALID", { status: criterion.status });
+            }
+        }
+        if (unresolved)
+            goalsWithUnresolvedCriteria.push(goal.id);
+    }
+    return { totalCriteria, passCount, pendingCount, failCount, blockedCount, goalsWithUnresolvedCriteria };
+}
+export function unresolvedCriteriaOf(goal) { return goal.successCriteria.filter((criterion) => criterion.status !== "pass"); }
+export function requireAllCriteriaPass(goal) {
+    if (hasAllCriteriaPass(goal))
+        return;
+    throw new UlwLoopError(`Goal ${goal.id} has unresolved success criteria.`, "ulw_loop_criteria_not_all_pass", {
+        details: { goalId: goal.id, unresolved: unresolvedCriteriaOf(goal).map((criterion) => ({ id: criterion.id, status: criterion.status })) },
+    });
+}

package/packages/omo-codex/plugin/components/ulw-loop/dist/goal-status.d.ts

@@ -0,0 +1,12 @@
+import { type UlwLoopScope } from "./paths.js";
+import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
+export declare const ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE: string;
+export declare function aggregateCodexObjectiveForScope(scope?: UlwLoopScope): string;
+export declare function codexGoalMode(plan: UlwLoopPlan): UlwLoopCodexGoalMode;
+export declare function isUlwLoopDone(plan: UlwLoopPlan): boolean;
+export declare function isFinalRunCompletionCandidate(plan: UlwLoopPlan, goal: UlwLoopItem): boolean;
+export declare function aggregateCodexObjective(plan: UlwLoopPlan): string;
+export declare function expectedCodexObjective(plan: UlwLoopPlan, goal: UlwLoopItem): string;
+export declare function compatibleCodexObjectives(plan: UlwLoopPlan): readonly string[];
+export declare function hasAllCriteriaPass(goal: UlwLoopItem): boolean;
+export declare function firstUnresolvedCriterion(goal: UlwLoopItem): UlwLoopSuccessCriterion | undefined;