lazycodex-ai 5.0.0-beta.63 → 5.0.0-beta.65

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

@@ -2,7 +2,12 @@ export declare const ULW_LOOP_OPERATIONS: readonly ["help", "create-goals", "sta
 export type UlwLoopOperation = (typeof ULW_LOOP_OPERATIONS)[number];
 export interface ToolkitOperationManifest {
     readonly name: UlwLoopOperation;
+    /** The camelCase method that runs this operation on every SDK surface. */
+    readonly method: string;
     readonly mutating: boolean;
+    readonly description: string;
+    /** Argument field -> type notation; a trailing `?` marks an optional field. */
+    readonly args: Readonly<Record<string, string>>;
 }
 export interface ToolkitManifest {
     readonly version: 1;
@@ -14,33 +19,363 @@ export declare const ULW_LOOP_MANIFEST: {
     name: "ulw-loop";
     operations: ({
         name: "help";
+        method: string;
         mutating: false;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "create-goals";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief: string;
+            codexGoalMode: string;
+            force: string;
+            validationBatchesJson: string;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "status";
+        method: string;
         mutating: false;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "complete-goals";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed: string;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "checkpoint";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            goalId: string;
+            status: string;
+            evidence: string;
+            codexGoalJson: string;
+            qualityGateJson: string;
+            printTemplate: string;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            notes?: never;
+            artifacts?: never;
+            title?: never;
+            objective?: never;
+        };
     } | {
         name: "steer";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind: string;
+            source: string;
+            evidence: string;
+            rationale: string;
+            goalId: string;
+            criterionId: string;
+            scenario: string;
+            expectedEvidence: string;
+            userModel: string;
+            title: string;
+            objective: string;
+            childGoals: string;
+            revisedTitle: string;
+            revisedObjective: string;
+            pendingOrder: string;
+            blockedReason: string;
+            idempotencyKey: string;
+            successCriteria?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "add-goal";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            title: string;
+            objective: string;
+            successCriteria: string;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "criteria";
+        method: string;
         mutating: false;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            goalId: string;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            title?: never;
+            objective?: never;
+            evidence?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "record-evidence";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            goalId: string;
+            criterionId: string;
+            status: string;
+            evidence: string;
+            notes: string;
+            artifacts: string;
+            title?: never;
+            objective?: never;
+            codexGoalJson?: never;
+        };
     } | {
         name: "record-review-blockers";
+        method: string;
         mutating: true;
+        description: string;
+        args: {
+            brief?: never;
+            codexGoalMode?: never;
+            force?: never;
+            validationBatchesJson?: never;
+            retryFailed?: never;
+            qualityGateJson?: never;
+            printTemplate?: never;
+            kind?: never;
+            source?: never;
+            rationale?: never;
+            scenario?: never;
+            expectedEvidence?: never;
+            userModel?: never;
+            childGoals?: never;
+            revisedTitle?: never;
+            revisedObjective?: never;
+            pendingOrder?: never;
+            blockedReason?: never;
+            idempotencyKey?: never;
+            successCriteria?: never;
+            criterionId?: never;
+            status?: never;
+            notes?: never;
+            artifacts?: never;
+            goalId: string;
+            title: string;
+            objective: string;
+            evidence: string;
+            codexGoalJson: string;
+        };
     })[];
 };

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

@@ -10,19 +10,118 @@ export const ULW_LOOP_OPERATIONS = [
     "record-evidence",
     "record-review-blockers",
 ];
+const CRITERION_INPUT = '{ scenario: string, expectedEvidence: string, userModel?: "happy" | "edge" | "regression" | "adversarial", essential?: boolean }';
+const STEER_KINDS = '"add_subgoal" | "split_subgoal" | "reorder_pending" | "revise_pending_wording" | "revise_criterion" | "annotate_ledger" | "mark_blocked_superseded"';
 export const ULW_LOOP_MANIFEST = {
     version: 1,
     name: "ulw-loop",
     operations: [
-        { name: "help", mutating: false },
-        { name: "create-goals", mutating: true },
-        { name: "status", mutating: false },
-        { name: "complete-goals", mutating: true },
-        { name: "checkpoint", mutating: true },
-        { name: "steer", mutating: true },
-        { name: "add-goal", mutating: true },
-        { name: "criteria", mutating: false },
-        { name: "record-evidence", mutating: true },
-        { name: "record-review-blockers", mutating: true },
+        {
+            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?" },
+        },
     ],
 };

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

@@ -82,11 +82,14 @@ export interface ToolkitFailure<Operation extends string = string> {
     readonly ok: false;
     readonly operation: Operation;
     readonly error: ToolkitError;
+    readonly warnings?: readonly string[];
 }
 type StatusResult = {
     readonly plan: UlwLoopPlan;
     readonly summary: ReturnType<typeof summarizeUlwLoopPlan>;
     readonly nextActions: readonly string[];
+    /** Plan-level evidence directory, stable for the whole run (relative to the session cwd). */
+    readonly evidenceRoot: string;
     readonly currentAttemptDir?: string;
 };
 type ResultFor<Operation extends UlwLoopOperation> = Operation extends "help" ? typeof ULW_LOOP_MANIFEST : Operation extends "create-goals" ? Awaited<ReturnType<typeof createUlwLoopPlan>> : Operation extends "status" ? StatusResult : Operation extends "complete-goals" ? Awaited<ReturnType<typeof startNextUlwLoop>> : Operation extends "checkpoint" ? CheckpointUlwLoopResult | CheckpointTemplate : Operation extends "steer" ? Awaited<ReturnType<typeof steerUlwLoop>> : Operation extends "add-goal" ? Awaited<ReturnType<typeof addUlwLoopGoal>> : Operation extends "criteria" ? {

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

@@ -1,5 +1,6 @@
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopItem, UlwLoopPlan, UlwLoopSteeringChildGoal, UlwLoopSteeringProposal } from "./types.js";
-export declare function makeGoal(plan: UlwLoopPlan, childGoal: UlwLoopSteeringChildGoal, evidence: string, now: string, offset: number): UlwLoopItem;
+export declare function makeGoal(plan: UlwLoopPlan, childGoal: UlwLoopSteeringChildGoal, evidence: string, now: string, offset: number, surface?: UlwLoopToolkitSurface): UlwLoopItem;
 export declare function reviseWording(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void;
-export declare function splitOrBlock(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void;
+export declare function splitOrBlock(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string, surface?: UlwLoopToolkitSurface): void;
 export declare function reviseCriterion(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void;

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

@@ -29,11 +29,11 @@ function nextId(plan, offset) {
     const max = plan.goals.reduce((current, item) => { const digits = /^G(\d+)(?:-|$)/u.exec(item.id)?.[1]; return digits === undefined ? current : Math.max(current, Number(digits)); }, 0);
     return `G${String(max + offset).padStart(3, "0")}`;
 }
-export function makeGoal(plan, childGoal, evidence, now, offset) {
+export function makeGoal(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 };
 }
 export function reviseWording(plan, proposal, now) {
     const target = goal(plan, targets(proposal)[0]);
@@ -45,11 +45,11 @@ export function reviseWording(plan, proposal, now) {
     target.steeringRationale = proposal.rationale;
     target.updatedAt = now;
 }
-export function splitOrBlock(plan, proposal, now) {
+export function splitOrBlock(plan, proposal, now, surface = "lazycodex") {
     const target = goal(plan, targets(proposal)[0]);
     if (target === undefined)
         return;
-    const replacements = children(proposal).map((item, index) => makeGoal(plan, item, proposal.evidence, now, index + 1));
+    const replacements = children(proposal).map((item, index) => makeGoal(plan, item, proposal.evidence, now, index + 1, surface));
     target.steeringEvidence = proposal.evidence;
     target.steeringRationale = proposal.rationale;
     target.updatedAt = now;

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

@@ -1,4 +1,4 @@
-import type { UlwLoopSteeringMutationKind, UlwLoopSteeringSource } from "./constants.js";
+import type { UlwLoopSteeringMutationKind, UlwLoopSteeringSource, UlwLoopSuccessCriterionUserModel } from "./constants.js";
 import type { UlwLoopItem, UlwLoopPlan } from "./domain-types.js";
 export interface UlwLoopSteeringInvariantResult {
     accepted: boolean;
@@ -21,9 +21,17 @@ export interface UlwLoopSteeringAfterPayload {
 export interface UlwLoopSteeringProposal {
     kind: UlwLoopSteeringMutationKind;
     source: UlwLoopSteeringSource;
+    /** Alias of `targetGoalId`; the SDK documentation uses `goalId` like every other operation. */
+    goalId?: string;
     targetGoalId?: string;
     targetGoalIds?: string[];
     criterionId?: string;
+    /** `revise_criterion` payload: the replacement scenario text. */
+    scenario?: string;
+    /** `revise_criterion` payload: the replacement observable-proof text. */
+    expectedEvidence?: string;
+    /** `revise_criterion` payload: the replacement user model. */
+    userModel?: UlwLoopSuccessCriterionUserModel;
     evidence: string;
     rationale: string;
     title?: string;

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

@@ -1,6 +1,7 @@
 import type { UlwLoopScope } from "./paths.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { SteerUlwLoopResult, UlwLoopPlan, UlwLoopSteeringAudit, UlwLoopSteeringProposal } from "./types.js";
 export declare function validateUlwLoopSteeringProposal(plan: UlwLoopPlan, proposal: unknown): UlwLoopSteeringAudit;
-export declare function applySteeringMutation(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, audit: UlwLoopSteeringAudit): UlwLoopPlan;
+export declare function applySteeringMutation(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, audit: UlwLoopSteeringAudit, surface?: UlwLoopToolkitSurface): UlwLoopPlan;
 export declare function parseUlwLoopSteeringDirective(text: string): UlwLoopSteeringProposal | null;
-export declare function steerUlwLoop(repoRoot: string, proposal: UlwLoopSteeringProposal, scope?: UlwLoopScope): Promise<SteerUlwLoopResult>;
+export declare function steerUlwLoop(repoRoot: string, proposal: UlwLoopSteeringProposal, scope?: UlwLoopScope, surface?: UlwLoopToolkitSurface): Promise<SteerUlwLoopResult>;

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

@@ -7,7 +7,7 @@ import { buildSteeringPlanSnapshot, changedGoalIdsBetween } from "./steering-sna
 import { iso, ULW_LOOP_STEERING_MUTATION_KINDS, ULW_LOOP_SUCCESS_CRITERION_USER_MODELS } from "./types.js";
 import { batchUpdateLedgerEntry } from "./validation-batch.js";
 const SOURCES = ["user_prompt_submit", "finding", "cli"];
-const PROTECTED = new Set(["aggregateCompletion", "codexObjective", "codexObjectiveAliases", "originalConstraints", "qualityGate", "status", "completedAt", "completionStatus"]);
+const PROTECTED = new Set(["aggregateCompletion", "codexObjective", "codexObjectiveAliases", "acknowledgedDriverObjectives", "originalConstraints", "qualityGate", "status", "completedAt", "completionStatus"]);
 const isObject = (value) => typeof value === "object" && value !== null;
 const isPlain = (value) => isObject(value) && !Array.isArray(value);
 const read = (value, key) => Object.entries(value).find(([name]) => name === key)?.[1];
@@ -164,13 +164,13 @@ function validateCriterion(plan, proposal, reasons) {
     if (model !== undefined && !isModel(model))
         reasons.push("invalid userModel");
 }
-export function applySteeringMutation(plan, proposal, audit) {
+export 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(makeGoal(next, { title: proposal.title ?? "", objective: proposal.objective ?? "" }, proposal.evidence, now, 1));
+        next.goals.push(makeGoal(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) => goal(next, id)).filter((item) => item !== undefined), ...next.goals.filter((item) => !order.includes(item.id))];
@@ -178,7 +178,7 @@ export 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")
@@ -202,7 +202,7 @@ export function parseUlwLoopSteeringDirective(text) {
         throw error;
     }
 }
-export async function steerUlwLoop(repoRoot, proposal, scope) {
+export 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;
@@ -215,7 +215,7 @@ export 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);

package/packages/omo-codex/plugin/components/ulw-loop/dist/success-criteria-input.d.ts

@@ -0,0 +1,9 @@
+import type { UlwLoopSuccessCriterion, UlwLoopSuccessCriterionUserModel } from "./types.js";
+export interface SuccessCriterionInput {
+    readonly scenario: string;
+    readonly expectedEvidence: string;
+    readonly userModel?: UlwLoopSuccessCriterionUserModel;
+    readonly essential?: boolean;
+}
+export declare function criterionId(index: number): string;
+export declare function criteriaFromInput(input: readonly unknown[]): UlwLoopSuccessCriterion[];