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

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

@@ -8,12 +8,18 @@ export interface CodexGoalSnapshot {
 export interface CodexGoalReconciliation {
     ok: boolean;
     snapshot: CodexGoalSnapshot;
+    /** Facts to know (a differing driver objective); never something to do. */
     warnings: string[];
+    /** Things to do next (create, re-create, or resume the driver goal). */
+    nextActions: string[];
     errors: string[];
+    /** The differing objective this reconciliation reported for the first time, for the caller to acknowledge. */
+    unacknowledgedObjective?: string;
 }
 export interface ReconcileCodexGoalOptions {
     expectedObjective: string;
     readonly acceptedObjectives?: readonly string[];
+    readonly acknowledgedObjectives?: readonly string[];
 }
 export declare class CodexGoalSnapshotError extends Error {
 }

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

@@ -73,29 +73,37 @@ export function reconcileCodexGoalSnapshot(snapshot, options) {
     const effectiveSnapshot = snapshot ?? { available: false, raw: null };
     const errors = [];
     const warnings = [];
+    const nextActions = [];
     const expected = options.expectedObjective;
-    const normalizedExpected = normalizeObjective(expected);
     if (!effectiveSnapshot.available) {
-        warnings.push(`call get_goal; if none, create_goal with codexObjective "${expected}" verbatim`);
-        return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
+        nextActions.push(`call get_goal; if none, create_goal with codexObjective "${expected}" verbatim`);
+        return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, nextActions, errors };
     }
-    const accepted = new Set([
-        normalizedExpected,
-        ...(options.acceptedObjectives ?? []).map((objective) => normalizeObjective(objective)),
-    ].filter(Boolean));
+    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 ?? "");
-    if (actual && !accepted.has(normalizeObjective(actual))) {
+    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") {
-        warnings.push("/goal resume or raise the budget");
+        nextActions.push("/goal resume or raise the budget");
     }
     if (actualStatus === "complete")
-        warnings.push(`driver closed early: call create_goal with codexObjective "${expected}" verbatim`);
-    return { ok: errors.length === 0, snapshot: effectiveSnapshot, warnings, errors };
+        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 }),
+    };
 }
 export function formatCodexGoalReconciliation(reconciliation) {
-    const parts = [...reconciliation.errors, ...reconciliation.warnings];
+    const parts = [...reconciliation.errors, ...reconciliation.nextActions, ...reconciliation.warnings];
     return parts.join(" ");
 }

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

@@ -10,6 +10,7 @@ export interface UlwLoopSuccessCriterion {
     status: UlwLoopCriterionStatus;
     capturedAt?: string;
     notes?: string;
+    artifacts?: string[];
 }
 export interface UlwLoopItem {
     id: string;
@@ -62,6 +63,7 @@ export interface UlwLoopPlan {
     codexGoalMode?: UlwLoopCodexGoalMode;
     codexObjective?: string;
     codexObjectiveAliases?: string[];
+    acknowledgedDriverObjectives?: string[];
     aggregateCompletion?: UlwLoopAggregateCompletion;
     activeGoalId?: string;
     validationBatches?: readonly UlwLoopValidationBatch[];
@@ -151,6 +153,7 @@ export interface UlwLoopLedgerEntry {
     codexGoal?: unknown;
     evidence?: string;
     capturedEvidence?: string;
+    artifacts?: string[];
     qualityGate?: unknown;
     steering?: UlwLoopSteeringAudit;
     before?: unknown;

package/packages/omo-codex/plugin/components/ulw-loop/dist/driver-objective-ack.d.ts

@@ -0,0 +1,4 @@
+import type { UlwLoopPlan } from "./types.js";
+export declare function normalizeDriverObjective(value: string): string;
+export declare function acknowledgedDriverObjectives(plan: UlwLoopPlan): readonly string[];
+export declare function acknowledgeDriverObjective(plan: UlwLoopPlan, objective: string | undefined): boolean;

package/packages/omo-codex/plugin/components/ulw-loop/dist/driver-objective-ack.js

@@ -0,0 +1,18 @@
+export function normalizeDriverObjective(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function acknowledgedDriverObjectives(plan) {
+    return plan.acknowledgedDriverObjectives ?? [];
+}
+// A differing driver objective is reported once; the plan remembers the exact text so every later
+// checkpoint under the same driver stays quiet, while a driver rewritten to a third objective is
+// reported again.
+export 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;
+}

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

@@ -0,0 +1 @@
+export declare function resolveEvidenceArtifacts(repoRoot: string, artifacts: readonly unknown[] | undefined): string[] | undefined;

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

@@ -0,0 +1,37 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { UlwLoopError } from "./types.js";
+function fail(message, code, details) {
+    throw new UlwLoopError(message, code, { details });
+}
+function stored(repoRoot, absolute) {
+    const rel = relative(repoRoot, absolute);
+    const inside = rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+    return inside ? rel.split(sep).join("/") : absolute;
+}
+// Artifacts are bound at record time: a cited path that does not exist is a claim without a file,
+// so the whole record is refused before any state changes. Paths inside the session cwd persist
+// repo-relative (portable across machines); paths outside persist absolute.
+export function resolveEvidenceArtifacts(repoRoot, artifacts) {
+    if (artifacts === undefined)
+        return undefined;
+    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 = resolve(repoRoot, path);
+        if (!existsSync(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;
+}

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

@@ -7,6 +7,7 @@ type RecordEvidenceArgs = {
     readonly status: EvidenceStatus;
     readonly evidence: string;
     readonly notes?: string;
+    readonly artifacts?: readonly string[];
 };
 export declare function recordEvidence(repoRoot: string, args: RecordEvidenceArgs, scope?: UlwLoopScope): Promise<{
     plan: UlwLoopPlan;

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

@@ -1,3 +1,4 @@
+import { resolveEvidenceArtifacts } from "./evidence-artifacts.js";
 import { essentialCriteriaOf, hasAllCriteriaPass, hasEssentialCriteriaPass } from "./goal-status.js";
 import { commit } from "./plan-commit.js";
 import { readUlwLoopPlan, withUlwLoopMutationLock } from "./plan-io.js";
@@ -39,6 +40,7 @@ export 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();
@@ -47,6 +49,10 @@ export 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;
         const ledgerEntry = {
@@ -57,6 +63,7 @@ export 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 },
         };
@@ -80,6 +87,7 @@ export async function markCriteriaPendingResetForGoal(repoRoot, goalId, scope) {
             criterion.capturedEvidence = null;
             delete criterion.capturedAt;
             delete criterion.notes;
+            delete criterion.artifacts;
         }
         goal.updatedAt = now;
         plan.updatedAt = now;

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

@@ -14,6 +14,7 @@ export declare function ulwLoopGoalsPath(repoRoot: string, scope?: UlwLoopScope)
 export declare function ulwLoopLedgerPath(repoRoot: string, scope?: UlwLoopScope): string;
 export declare function ulwLoopStateLockPath(repoRoot: string, scope?: UlwLoopScope): string;
 export declare function repoRelative(absolutePath: string, repoRoot: string): string;
+export declare function ulwLoopEvidenceRoot(scope?: UlwLoopScope): string;
 export declare function ulwLoopAttemptEvidenceDir(goalId: string, attempt: number, scope?: UlwLoopScope): string;
 interface AttemptPathApi {
     relative(from: string, to: string): string;

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

@@ -62,6 +62,12 @@ export function repoRelative(absolutePath, repoRoot) {
         return absolutePath.slice(backslashPrefix.length).split("\\").join("/");
     return absolutePath.split("\\").join("/");
 }
+// The plan-level evidence root stays fixed for the whole run, unlike the per-goal attempt dir, so
+// long lanes that span goals have one stable place to write artifacts.
+export function ulwLoopEvidenceRoot(scope) {
+    const sessionId = normalizeUlwLoopSessionId(scope?.sessionId);
+    return sessionId === null ? ".omo/evidence" : `.omo/evidence/ulw/${sessionId}`;
+}
 // Both the status --json emitter and the checkpoint enforcement resolve the attempt dir through
 // this function from the scope alone; a second resolution path (env, a literal placeholder)
 // would let the gate reject its own advertised directory.

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

@@ -1,7 +1,9 @@
 import { type UlwLoopScope } from "./paths.js";
+import type { SuccessCriterionInput } from "./success-criteria-input.js";
 import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan } from "./types.js";
 export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
+export type { SuccessCriterionInput } from "./success-criteria-input.js";
 export type UlwLoopPlanSummary = {
     readonly total: number;
     readonly pending: number;
@@ -29,7 +31,8 @@ export declare function createUlwLoopPlan(repoRoot: string, args: {
 export declare function addUlwLoopGoal(repoRoot: string, args: {
     title: string;
     objective: string;
-}, scope?: UlwLoopScope): Promise<{
+    successCriteria?: readonly SuccessCriterionInput[];
+}, scope?: UlwLoopScope, surface?: UlwLoopToolkitSurface): Promise<{
     plan: UlwLoopPlan;
     goal: UlwLoopItem;
 }>;

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

@@ -39,7 +39,7 @@ export async function createUlwLoopPlan(repoRoot, args, scope, surface = "lazyco
             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,
@@ -80,11 +80,14 @@ function completedPlanExistsError(scope, surface) {
             ]),
     ].join(" "), "ULW_LOOP_PLAN_EXISTS_COMPLETE");
 }
-export async function addUlwLoopGoal(repoRoot, args, scope) {
+export 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);
+        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 }],

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

@@ -1,8 +1,15 @@
+import { type SuccessCriterionInput } from "./success-criteria-input.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
-export declare function seedDefaultSuccessCriteria(goalIndex: number, objective: string): UlwLoopSuccessCriterion[];
+export interface GoalSeedOptions {
+    readonly goalId?: string;
+    readonly surface?: UlwLoopToolkitSurface;
+    readonly successCriteria?: readonly SuccessCriterionInput[];
+}
+export declare function seedDefaultSuccessCriteria(goalIndex: number, objective: string, options?: Pick<GoalSeedOptions, "goalId" | "surface">): UlwLoopSuccessCriterion[];
 export declare function deriveGoalCandidates(brief: string): Array<{
     title: string;
     objective: string;
 }>;
-export declare function makeGoal(title: string, objective: string, index: number, now: string): UlwLoopItem;
-export declare function appendGoalToPlan(plan: UlwLoopPlan, title: string, objective: string, now: string): UlwLoopItem;
+export declare function makeGoal(title: string, objective: string, index: number, now: string, options?: GoalSeedOptions): UlwLoopItem;
+export declare function appendGoalToPlan(plan: UlwLoopPlan, title: string, objective: string, now: string, options?: GoalSeedOptions): UlwLoopItem;

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

@@ -1,3 +1,4 @@
+import { criteriaFromInput, criterionId } from "./success-criteria-input.js";
 import { UlwLoopError } from "./types.js";
 function cleanLine(line) {
     return line.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "").trim();
@@ -30,40 +31,39 @@ function assertNonEmpty(value, label) {
 function truncateObjective(objective) {
     return objective.length > 80 ? `${objective.slice(0, 77).trimEnd()}...` : objective;
 }
-export function seedDefaultSuccessCriteria(goalIndex, objective) {
+// The placeholder must name the exact call that replaces it on the surface the plan is driven from,
+// so a goal seeded without criteria costs one documented call per criterion instead of a doc hunt.
+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>"`;
+}
+export function seedDefaultSuccessCriteria(goalIndex, objective, options = {}) {
     const subject = truncateObjective(normalizeObjective(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",
+        };
+    });
 }
 export function deriveGoalCandidates(brief) {
     const bulletGoals = brief
@@ -87,22 +87,29 @@ export function deriveGoalCandidates(brief) {
         objective,
     }));
 }
-export function makeGoal(title, objective, index, now) {
+export 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,
     };
 }
-export function appendGoalToPlan(plan, title, objective, now) {
-    const goal = makeGoal(title, objective, plan.goals.length, now);
+export 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;

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

@@ -1,5 +1,6 @@
 // biome-ignore-all format: compact port must stay within the requested pure LOC budget.
 import { CodexGoalSnapshotError, formatCodexGoalReconciliation, readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot, } from "./codex-goal-snapshot.js";
+import { acknowledgeDriverObjective, acknowledgedDriverObjectives } from "./driver-objective-ack.js";
 import { compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate } from "./goal-status.js";
 import { commit } from "./plan-commit.js";
 import { seedDefaultSuccessCriteria } from "./plan-crud.js";
@@ -18,12 +19,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,
@@ -45,9 +47,11 @@ export async function recordFinalReviewBlockers(repoRoot, args, scope) {
         const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
             expectedObjective: expectedCodexObjective(plan, goal),
             acceptedObjectives: compatibleCodexObjectives(plan),
+            acknowledgedObjectives: acknowledgedDriverObjectives(plan),
         });
         if (!reconciliation.ok)
             throw new CodexGoalSnapshotError(formatCodexGoalReconciliation(reconciliation));
+        acknowledgeDriverObjective(plan, reconciliation.unacknowledgedObjective);
         const now = iso();
         for (const field of BLOCKER_FIELDS)
             Reflect.deleteProperty(goal, field);
@@ -71,8 +75,8 @@ export async function recordFinalReviewBlockers(repoRoot, args, scope) {
             blockedGoal: goal,
             newGoal,
             ledgerEntries,
-            nextActions: reconciliation.warnings,
-            warnings: reconciliation.warnings.filter((warning) => warning.startsWith("driver_objective_differs")),
+            nextActions: reconciliation.nextActions,
+            warnings: reconciliation.warnings,
         };
     });
 }

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

@@ -1,7 +1,7 @@
 import { checkpointUlwLoop } from "../checkpoint.js";
 import { checkpointTemplate } from "../checkpoint-template.js";
 import { recordEvidence } from "../evidence.js";
-import { normalizeUlwLoopSessionId, ulwLoopAttemptEvidenceDir, ulwLoopGoalsRelativePath, } from "../paths.js";
+import { normalizeUlwLoopSessionId, ulwLoopAttemptEvidenceDir, ulwLoopEvidenceRoot, ulwLoopGoalsRelativePath, } from "../paths.js";
 import { addUlwLoopGoal, createUlwLoopPlan, startNextUlwLoop, summarizeUlwLoopPlan } from "../plan-crud.js";
 import { listUlwLoopSessionIds, readUlwLoopPlan } from "../plan-io.js";
 import { planMissingError } from "../plan-missing-recovery.js";
@@ -54,10 +54,11 @@ function isKnownRequest(request) {
 function unreachable(value) {
     throw new UlwLoopError(`Unhandled operation: ${String(value)}`, "ULW_LOOP_OPERATION_UNHANDLED");
 }
-function nextActionsFrom(result) {
-    if (!("nextActions" in result) || !Array.isArray(result.nextActions))
+function stringsFrom(result, key) {
+    if (!(key in result))
         return [];
-    return result.nextActions.filter((action) => typeof action === "string").slice(0, 8);
+    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);
@@ -74,8 +75,15 @@ export function createAgentToolkit(context, deps = {}) {
     const invoke = async (operation, fn) => {
         try {
             const result = await fn();
-            const nextActions = typeof result === "object" && result !== null ? nextActionsFrom(result) : [];
-            return await notify(operation, { ok: true, operation, result, nextActions });
+            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")
@@ -122,6 +130,7 @@ export function createAgentToolkit(context, deps = {}) {
                 plan,
                 summary: summarizeUlwLoopPlan(plan),
                 nextActions: statusNextActions(plan, context.surface),
+                evidenceRoot: ulwLoopEvidenceRoot(scope),
                 // Attempt directories are an evidence-layout v2 concept; a v1 plan must not advertise one.
                 ...(active === undefined || plan.evidenceLayoutVersion !== 2
                     ? {}
@@ -132,8 +141,8 @@ export function createAgentToolkit(context, deps = {}) {
         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)),
-        addGoal: (args) => invoke("add-goal", () => addUlwLoopGoal(context.cwd, args, scope)),
+        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);