lazycodex-ai 5.0.0-beta.9 → 5.0.0

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

@@ -0,0 +1,381 @@
+export declare const ULW_LOOP_OPERATIONS: readonly ["help", "create-goals", "status", "complete-goals", "checkpoint", "steer", "add-goal", "criteria", "record-evidence", "record-review-blockers"];
+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;
+    readonly name: "ulw-loop";
+    readonly operations: readonly ToolkitOperationManifest[];
+}
+export declare const ULW_LOOP_MANIFEST: {
+    version: 1;
+    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

@@ -0,0 +1,127 @@
+export const ULW_LOOP_OPERATIONS = [
+    "help",
+    "create-goals",
+    "status",
+    "complete-goals",
+    "checkpoint",
+    "steer",
+    "add-goal",
+    "criteria",
+    "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",
+            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

@@ -0,0 +1,130 @@
+import type { CheckpointUlwLoopArgs, CheckpointUlwLoopResult } from "../checkpoint.js";
+import type { CheckpointTemplate } from "../checkpoint-template.js";
+import type { recordEvidence } from "../evidence.js";
+import type { addUlwLoopGoal, createUlwLoopPlan, startNextUlwLoop, summarizeUlwLoopPlan } from "../plan-crud.js";
+import type { recordFinalReviewBlockers } from "../review-blockers.js";
+import type { steerUlwLoop } from "../steering.js";
+import type { UlwLoopSteeringProposal } from "../steering-types.js";
+import type { UlwLoopToolkitSurface } from "../surface.js";
+import type { UlwLoopPlan } from "../types.js";
+import type { ULW_LOOP_MANIFEST, UlwLoopOperation } from "./manifest.js";
+export type ToolkitSurface = UlwLoopToolkitSurface;
+export interface ToolkitContext {
+    readonly cwd: string;
+    readonly sessionId: string;
+    readonly surface: ToolkitSurface;
+}
+export type CreateGoalsArgs = Parameters<typeof createUlwLoopPlan>[1];
+export type CompleteGoalsArgs = NonNullable<Parameters<typeof startNextUlwLoop>[1]>;
+export type SteerArgs = UlwLoopSteeringProposal;
+export type AddGoalArgs = Parameters<typeof addUlwLoopGoal>[1];
+export type RecordEvidenceArgs = Parameters<typeof recordEvidence>[1];
+export type CriteriaArgs = {
+    readonly goalId: string;
+};
+export type CheckpointMutationArgs = CheckpointUlwLoopArgs & {
+    readonly printTemplate?: false;
+};
+export type CheckpointTemplateArgs = {
+    readonly printTemplate: true;
+    readonly goalId?: string;
+};
+export type CheckpointArgs = CheckpointMutationArgs | CheckpointTemplateArgs;
+export type RecordReviewBlockersArgs = Parameters<typeof recordFinalReviewBlockers>[1];
+export type ToolkitDispatchRequest = {
+    readonly operation: "help";
+    readonly args?: Record<never, never>;
+} | {
+    readonly operation: "create-goals";
+    readonly args: CreateGoalsArgs;
+} | {
+    readonly operation: "status";
+    readonly args?: Record<never, never>;
+} | {
+    readonly operation: "complete-goals";
+    readonly args?: CompleteGoalsArgs;
+} | {
+    readonly operation: "checkpoint";
+    readonly args: CheckpointArgs;
+} | {
+    readonly operation: "steer";
+    readonly args: SteerArgs;
+} | {
+    readonly operation: "add-goal";
+    readonly args: AddGoalArgs;
+} | {
+    readonly operation: "criteria";
+    readonly args: CriteriaArgs;
+} | {
+    readonly operation: "record-evidence";
+    readonly args: RecordEvidenceArgs;
+} | {
+    readonly operation: "record-review-blockers";
+    readonly args: RecordReviewBlockersArgs;
+};
+export interface ToolkitUnknownRequest {
+    readonly operation: string;
+    readonly args?: Record<never, never>;
+}
+export interface ToolkitError {
+    readonly code: string;
+    readonly message: string;
+    readonly details?: Readonly<Record<string, string>>;
+}
+export interface ToolkitSuccess<Operation extends UlwLoopOperation, Result> {
+    readonly ok: true;
+    readonly operation: Operation;
+    readonly result: Result;
+    readonly nextActions: readonly string[];
+    readonly warnings?: readonly string[];
+}
+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" ? {
+    readonly goalId: string;
+    readonly criteria: UlwLoopPlan["goals"][number]["successCriteria"];
+} : Operation extends "record-evidence" ? Awaited<ReturnType<typeof recordEvidence>> : Operation extends "record-review-blockers" ? Awaited<ReturnType<typeof recordFinalReviewBlockers>> : never;
+export type ToolkitResultFor<Operation extends UlwLoopOperation> = ResultFor<Operation>;
+export type ToolkitResponseFor<Operation extends UlwLoopOperation> = ToolkitSuccess<Operation, ResultFor<Operation>> | ToolkitFailure<Operation>;
+export type ToolkitOperationResponse = {
+    [Operation in UlwLoopOperation]: ToolkitResponseFor<Operation>;
+}[UlwLoopOperation];
+export type ToolkitDispatchResponse = ToolkitOperationResponse | ToolkitFailure<string>;
+export type ToolkitResponse<Result> = ToolkitSuccess<UlwLoopOperation, Result> | ToolkitFailure<string>;
+export interface ToolkitOperationHookEvent<Operation extends UlwLoopOperation = UlwLoopOperation> {
+    readonly operation: Operation;
+    readonly context: ToolkitContext;
+    readonly response: ToolkitResponseFor<Operation>;
+}
+export interface ToolkitHostHooks {
+    readonly onOperation?: <Operation extends UlwLoopOperation>(event: ToolkitOperationHookEvent<Operation>) => void | Promise<void>;
+}
+export interface AgentToolkitDependencies {
+    readonly hooks?: ToolkitHostHooks;
+}
+export interface AgentToolkit {
+    readonly dispatch: (request: ToolkitDispatchRequest | ToolkitUnknownRequest) => Promise<ToolkitDispatchResponse>;
+    readonly help: () => Promise<ToolkitResponseFor<"help">>;
+    readonly createGoals: (args: CreateGoalsArgs) => Promise<ToolkitResponseFor<"create-goals">>;
+    readonly status: () => Promise<ToolkitResponseFor<"status">>;
+    readonly completeGoals: (args?: CompleteGoalsArgs) => Promise<ToolkitResponseFor<"complete-goals">>;
+    readonly checkpoint: (args: CheckpointArgs) => Promise<ToolkitResponseFor<"checkpoint">>;
+    readonly steer: (args: SteerArgs) => Promise<ToolkitResponseFor<"steer">>;
+    readonly addGoal: (args: AddGoalArgs) => Promise<ToolkitResponseFor<"add-goal">>;
+    readonly criteria: (args: CriteriaArgs) => Promise<ToolkitResponseFor<"criteria">>;
+    readonly recordEvidence: (args: RecordEvidenceArgs) => Promise<ToolkitResponseFor<"record-evidence">>;
+    readonly recordReviewBlockers: (args: RecordReviewBlockersArgs) => Promise<ToolkitResponseFor<"record-review-blockers">>;
+}
+export {};

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

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

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

@@ -0,0 +1,3 @@
+export { createAgentToolkit } from "./sdk/factory.js";
+export * from "./sdk/manifest.js";
+export * from "./sdk/types.js";

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

@@ -0,0 +1,3 @@
+export { createAgentToolkit } from "./sdk/factory.js";
+export * from "./sdk/manifest.js";
+export * from "./sdk/types.js";

package/packages/omo-codex/plugin/components/ulw-loop/dist/spawn-budget-io.d.ts

@@ -0,0 +1,5 @@
+export declare function readAdmissionBreaker(sessionId: string): string | null;
+export declare function atomicWriteJson(targetPath: string, data: unknown): void;
+export declare function isNonEmptyFile(path: string): boolean;
+export declare function readCount(counterPath: string): number;
+export declare function readCounts(counterPath: string): Record<string, number>;