oh-my-opencode 5.0.0-beta.62 → 5.0.0-beta.64

package/packages/omo-codex/plugin/components/ulw-loop/src/ledger.ts

@@ -0,0 +1,33 @@
+import { join } from "node:path";
+import { type UlwLoopScope, ulwLoopDir } from "./paths.js";
+import { readOptional, readRecords, reconcilePlan } from "./plan-log.js";
+import type { UlwLoopLedgerEntry } from "./types.js";
+
+export function readLedgerAt(dir: string): UlwLoopLedgerEntry[] {
+	const entries = new Map<string, UlwLoopLedgerEntry>();
+	const lines = (readOptional(join(dir, "ledger.jsonl")) ?? "").split(/\r?\n/);
+	for (const [index, line] of lines.entries()) {
+		if (line.trim().length === 0) continue;
+		try {
+			const entry: UlwLoopLedgerEntry = JSON.parse(line);
+			entry.revision ??= 0;
+			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: UlwLoopLedgerEntry) => 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));
+}
+export function readLedger(repoRoot: string, scope?: UlwLoopScope): UlwLoopLedgerEntry[] {
+	return readLedgerAt(ulwLoopDir(repoRoot, scope));
+}

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

@@ -85,6 +85,13 @@ export function repoRelative(absolutePath: string, repoRoot: string): string {
 	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?: UlwLoopScope): string {
+	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/src/plan-commit.ts

@@ -0,0 +1,124 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { linkSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { readLedgerAt } from "./ledger.js";
+import { type UlwLoopScope, ulwLoopDir, ulwLoopStateLockPath } from "./paths.js";
+import { assertStateLockOwned, migrationEntries } from "./plan-io.js";
+import { hasCode, type PlanCommitRecord, readOptional, readRecords, reconcilePlan } from "./plan-log.js";
+import { UlwLoopError, type UlwLoopLedgerEntry, type UlwLoopPlan } from "./types.js";
+
+interface CommitHooks {
+	readonly beforeMutation?: () => void | Promise<void>;
+	readonly beforeCommit?: () => void | Promise<void>;
+	readonly afterCommit?: () => void | Promise<void>;
+	readonly link?: (source: string, destination: string) => void;
+	readonly writeView?: (path: string, content: string) => Promise<void>;
+}
+const hooks = new AsyncLocalStorage<CommitHooks>();
+export function withCommitHooks<T>(value: CommitHooks, fn: () => Promise<T>): Promise<T> {
+	return hooks.run(value, fn);
+}
+
+export async function beforePlanMutation(): Promise<void> {
+	await hooks.getStore()?.beforeMutation?.();
+}
+export async function writeViewFile(path: string, content: string): Promise<void> {
+	await (hooks.getStore()?.writeView ?? writeFile)(path, content);
+}
+
+// link is the sole commit point; no copy fallback (Node copyFile is not atomic).
+// A resumed zombie can publish first, but never overwrite an existing revision.
+// Logical audit order is (revision, sequence), not materialization completion time.
+export async function commit(
+	repoRoot: string,
+	scope: UlwLoopScope | undefined,
+	mutation: {
+		readonly plan: UlwLoopPlan;
+		readonly entries: readonly UlwLoopLedgerEntry[];
+	},
+): Promise<void> {
+	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(join(dir, "brief.md")) ?? "";
+	const entries = [...migrationEntries(plan), ...mutation.entries].map((entry, seq) => ({
+		...entry,
+		revision: next,
+		id: `${next}-${seq}`,
+	}));
+	const record: PlanCommitRecord = {
+		version: 1,
+		revision: next,
+		plan: { ...plan, revision: next, brief },
+		ledger: entries,
+	};
+	mkdirSync(join(dir, "revisions"), { recursive: true });
+	mkdirSync(join(dir, "tmp"), { recursive: true });
+	const temp = join(dir, "tmp", `${process.pid}-${randomUUID()}.json`);
+	try {
+		writeFileSync(temp, `${JSON.stringify(record)}\n`, { flag: "wx" });
+		try {
+			(hooks.getStore()?.link ?? linkSync)(temp, join(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 {
+		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: string): [string, string][] {
+	const plan = reconcilePlan(dir);
+	if (plan === undefined || readRecords(dir).length === 0) return [];
+	const ledger = readLedgerAt(dir);
+	const views: [string, string][] = [
+		["goals.json", `${JSON.stringify(plan, null, 2)}\n`],
+		["ledger.jsonl", ledger.length === 0 ? "" : `${ledger.map((entry) => JSON.stringify(entry)).join("\n")}\n`],
+		["brief.md", plan.brief ?? readOptional(join(dir, "brief.md")) ?? ""],
+	];
+	return views.filter(([name, content]) => readOptional(join(dir, name)) !== content);
+}
+export function materializeSync(dir: string): void {
+	for (const [name, content] of viewContents(dir)) {
+		mkdirSync(join(dir, "tmp"), { recursive: true });
+		const temp = join(dir, "tmp", `${process.pid}-${randomUUID()}-${name}`);
+		try {
+			writeFileSync(temp, content, { flag: "wx" });
+			renameSync(temp, join(dir, name));
+		} finally {
+			rmSync(temp, { force: true });
+		}
+	}
+}
+export async function materialize(dir: string): Promise<void> {
+	for (const [name, content] of viewContents(dir)) {
+		mkdirSync(join(dir, "tmp"), { recursive: true });
+		const temp = join(dir, "tmp", `${process.pid}-${randomUUID()}-${name}`);
+		try {
+			await writeViewFile(temp, content);
+			await rename(temp, join(dir, name));
+		} finally {
+			rmSync(temp, { force: true });
+		}
+	}
+}

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

@@ -1,24 +1,27 @@
-import { existsSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-
 import { aggregateCodexObjectiveForScope, isUlwLoopDone } from "./goal-status.js";
 import {
 	type UlwLoopScope,
-	ulwLoopBriefPath,
 	ulwLoopBriefRelativePath,
-	ulwLoopDir,
-	ulwLoopGoalsPath,
 	ulwLoopGoalsRelativePath,
-	ulwLoopLedgerPath,
 	ulwLoopLedgerRelativePath,
 } from "./paths.js";
+import { beforePlanMutation, commit } from "./plan-commit.js";
 import { appendGoalToPlan, deriveGoalCandidates, makeGoal } from "./plan-goal-factory.js";
-import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
-import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
+import { planExists, readUlwLoopPlan, withUlwLoopMutationLock } from "./plan-io.js";
+import type { SuccessCriterionInput } from "./success-criteria-input.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
+import type {
+	UlwLoopCodexGoalMode,
+	UlwLoopItem,
+	UlwLoopLedgerEntry,
+	UlwLoopPlan,
+	UlwLoopSuccessCriterion,
+} from "./types.js";
 import { iso, UlwLoopError } from "./types.js";
 import { parseValidationBatches } from "./validation-batch.js";
 
 export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
+export type { SuccessCriterionInput } from "./success-criteria-input.js";
 
 export type UlwLoopPlanSummary = {
 	readonly total: number;
@@ -60,11 +63,19 @@ export async function createUlwLoopPlan(
 	repoRoot: string,
 	args: { brief: string; codexGoalMode?: UlwLoopCodexGoalMode; force?: boolean; validationBatchesJson?: string },
 	scope?: UlwLoopScope,
+	surface: UlwLoopToolkitSurface = "lazycodex",
 ): Promise<UlwLoopPlan> {
 	return withUlwLoopMutationLock(repoRoot, scope, async () => {
-		if (!args.force && existsSync(ulwLoopGoalsPath(repoRoot, scope))) {
-			const existing = await readUlwLoopPlan(repoRoot, scope);
-			if (isUlwLoopDone(existing)) throw completedPlanExistsError(scope);
+		let existing: UlwLoopPlan | undefined;
+		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, surface);
 			throw new UlwLoopError(
 				`Refusing to overwrite existing ${ulwLoopGoalsRelativePath(scope)}; pass --force to recreate it.`,
 				"ULW_LOOP_PLAN_EXISTS",
@@ -72,10 +83,13 @@ export async function createUlwLoopPlan(
 		}
 		const now = iso();
 		const goals = deriveGoalCandidates(args.brief).map((goal, index) =>
-			makeGoal(goal.title, goal.objective, index, now),
+			makeGoal(goal.title, goal.objective, index, now, { surface }),
 		);
 		const plan: UlwLoopPlan = {
 			version: 1,
+			revision: existing?.revision ?? 0,
+			ledgerResetRevision: (existing?.revision ?? 0) + 1,
+			brief: args.brief.endsWith("\n") ? args.brief : `${args.brief}\n`,
 			evidenceLayoutVersion: 2,
 			createdAt: now,
 			updatedAt: now,
@@ -88,29 +102,27 @@ export async function createUlwLoopPlan(
 		const validationBatches = await parseValidationBatches(args.validationBatchesJson, goals);
 		if (validationBatches !== undefined) plan.validationBatches = validationBatches;
 		if (plan.codexGoalMode === "aggregate") plan.codexObjective = aggregateCodexObjectiveForScope(scope);
-		await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
-		await writeFile(
-			ulwLoopBriefPath(repoRoot, scope),
-			args.brief.endsWith("\n") ? args.brief : `${args.brief}\n`,
-			"utf8",
-		);
-		await writePlan(repoRoot, plan, scope);
-		await writeFile(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?: UlwLoopScope): UlwLoopError {
+function completedPlanExistsError(scope: UlwLoopScope | undefined, surface: UlwLoopToolkitSurface): UlwLoopError {
 	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",
 	);
@@ -118,19 +130,21 @@ function completedPlanExistsError(scope?: UlwLoopScope): UlwLoopError {
 
 export async function addUlwLoopGoal(
 	repoRoot: string,
-	args: { title: string; objective: string },
+	args: { title: string; objective: string; successCriteria?: readonly SuccessCriterionInput[] },
 	scope?: UlwLoopScope,
+	surface: UlwLoopToolkitSurface = "lazycodex",
 ): Promise<{ plan: UlwLoopPlan; goal: UlwLoopItem }> {
 	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 };
 	});
 }
@@ -146,21 +160,18 @@ export async function startNextUlwLoop(
 		if (plan.aggregateCompletion?.status === "complete") return { done: true, plan };
 		const existing = plan.goals.find((goal) => goal.status === "in_progress" && isScheduleEligible(goal));
 		if (existing) return { plan, goal: existing, resumed: true };
+		const entries: UlwLoopLedgerEntry[] = [];
 		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,
-					{
-						at: now,
-						kind: "goal_retried",
-						goalId: next.id,
-						status: "pending",
-						...(next.failureReason ? { message: next.failureReason } : {}),
-					},
-					scope,
-				);
+				entries.push({
+					at: now,
+					kind: "goal_retried",
+					goalId: next.id,
+					status: "pending",
+					...(next.failureReason ? { message: next.failureReason } : {}),
+				});
 		}
 		if (!next) return { done: true, plan };
 		next.status = "in_progress";
@@ -170,12 +181,14 @@ export async function startNextUlwLoop(
 		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 };
 	});
 }

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

@@ -1,6 +1,14 @@
+import { criteriaFromInput, criterionId, type SuccessCriterionInput } from "./success-criteria-input.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
 import { UlwLoopError } from "./types.js";
 
+export interface GoalSeedOptions {
+	readonly goalId?: string;
+	readonly surface?: UlwLoopToolkitSurface;
+	readonly successCriteria?: readonly SuccessCriterionInput[];
+}
+
 function cleanLine(line: string): string {
 	return line.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "").trim();
 }
@@ -38,40 +46,44 @@ function truncateObjective(objective: string): string {
 	return objective.length > 80 ? `${objective.slice(0, 77).trimEnd()}...` : objective;
 }
 
-export function seedDefaultSuccessCriteria(goalIndex: number, objective: string): UlwLoopSuccessCriterion[] {
+// 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: string, id: string, surface: UlwLoopToolkitSurface): string {
+	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: number,
+	objective: string,
+	options: Pick<GoalSeedOptions, "goalId" | "surface"> = {},
+): UlwLoopSuccessCriterion[] {
 	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,
 		],
 	] as const;
-	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: string): Array<{ title: string; objective: string }> {
@@ -101,23 +113,43 @@ export function deriveGoalCandidates(brief: string): Array<{ title: string; obje
 	}));
 }
 
-export function makeGoal(title: string, objective: string, index: number, now: string): UlwLoopItem {
+export function makeGoal(
+	title: string,
+	objective: string,
+	index: number,
+	now: string,
+	options: GoalSeedOptions = {},
+): UlwLoopItem {
 	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: UlwLoopPlan, title: string, objective: string, now: string): UlwLoopItem {
-	const goal = makeGoal(title, objective, plan.goals.length, now);
+export function appendGoalToPlan(
+	plan: UlwLoopPlan,
+	title: string,
+	objective: string,
+	now: string,
+	options: GoalSeedOptions = {},
+): UlwLoopItem {
+	const goal = makeGoal(title, objective, plan.goals.length, now, options);
 	plan.goals.push(goal);
 	plan.updatedAt = now;
 	return goal;