@otto-code/protocol 0.5.1 → 0.5.4

package/dist/judge-verdict.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const JUDGE_OUTCOMES: readonly ["pass", "fail"];
+export type JudgeOutcome = (typeof JUDGE_OUTCOMES)[number];
+export declare function isJudgeOutcome(value: string): value is JudgeOutcome;
+/**
+ * Coerce a raw verdict string to a known outcome. Anything that isn't an exact
+ * known outcome is treated as `"fail"` — an unparseable verdict must not be read
+ * as a pass, so a gate never advances on a value it doesn't understand.
+ */
+export declare function normalizeJudgeOutcome(value: string | undefined): JudgeOutcome;
+export declare const JudgeCriterionSchema: z.ZodObject<{
+    name: z.ZodString;
+    met: z.ZodBoolean;
+    evidence: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type JudgeCriterion = z.infer<typeof JudgeCriterionSchema>;
+export declare const JudgeVerdictSchema: z.ZodObject<{
+    verdict: z.ZodString;
+    score: z.ZodOptional<z.ZodNumber>;
+    criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        met: z.ZodBoolean;
+        evidence: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type JudgeVerdict = z.infer<typeof JudgeVerdictSchema>;
+/** True when the verdict's outcome normalizes to `"pass"`. */
+export declare function judgeVerdictPassed(verdict: Pick<JudgeVerdict, "verdict">): boolean;
+//# sourceMappingURL=judge-verdict.d.ts.map

package/dist/judge-verdict.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+// The structured verdict a `judger` returns when it evaluates work or a plan, so
+// an orchestrator can branch mechanically instead of parsing prose. This is the
+// canonical shape shared by the daemon and the app; the orchestration runtime
+// (see projects/agent-orchestration) enforces it at the worker tool boundary and
+// reads `verdict`/`score` directly to drive gates and the loop-until-N-good
+// pattern. Absorbs upstream Paseo's `verify·spec` auditor output ("YES/NO per
+// acceptance criterion, with evidence").
+//
+// Wire-forward-compat: kept a pure structural schema with plain leaves (no
+// transforms), so it can later ride a protocol message without breaking older
+// peers. The outcome rides as a plain string (like personality roles and effort
+// levels) rather than a z.enum, so the vocabulary can grow — consumers normalize
+// through `isJudgeOutcome` / `normalizeJudgeOutcome` instead of trusting the raw
+// value.
+// The pass/fail decision. Binary is enough for the signature loop-until-N-good
+// pattern (keep passers, replace failers); a richer vocabulary can be added
+// later without breaking peers because the field is a plain string on the wire.
+export const JUDGE_OUTCOMES = ["pass", "fail"];
+const OUTCOME_SET = new Set(JUDGE_OUTCOMES);
+export function isJudgeOutcome(value) {
+    return OUTCOME_SET.has(value);
+}
+/**
+ * Coerce a raw verdict string to a known outcome. Anything that isn't an exact
+ * known outcome is treated as `"fail"` — an unparseable verdict must not be read
+ * as a pass, so a gate never advances on a value it doesn't understand.
+ */
+export function normalizeJudgeOutcome(value) {
+    return value !== undefined && isJudgeOutcome(value) ? value : "fail";
+}
+// One acceptance criterion the judge checked, with the evidence that settles it
+// (a file/line, a test name, an observed behavior). `met` is the machine-readable
+// bit; `evidence` is the human-auditable why.
+export const JudgeCriterionSchema = z
+    .object({
+    name: z.string().min(1),
+    met: z.boolean(),
+    evidence: z.string().optional(),
+})
+    .passthrough();
+export const JudgeVerdictSchema = z
+    .object({
+    // "pass" | "fail" as a plain string (forward-compat); read through
+    // normalizeJudgeOutcome, never trusted raw.
+    verdict: z.string().min(1),
+    // 0..1 quality/confidence score, used to rank passers when the conductor
+    // wants the best N of several candidates.
+    score: z.number().min(0).max(1).optional(),
+    // Per-criterion breakdown. Optional (absent = none reported) rather than
+    // defaulted, per the protocol rule against array defaults on wire schemas.
+    criteria: z.array(JudgeCriterionSchema).optional(),
+    // One-line human summary of the call.
+    summary: z.string().optional(),
+})
+    .passthrough();
+/** True when the verdict's outcome normalizes to `"pass"`. */
+export function judgeVerdictPassed(verdict) {
+    return normalizeJudgeOutcome(verdict.verdict) === "pass";
+}
+//# sourceMappingURL=judge-verdict.js.map

package/dist/loop/rpc-schemas.d.ts

@@ -39,14 +39,14 @@ export declare const LoopIterationRecordSchema: z.ZodObject<{
     verifierAgentId: z.ZodNullable<z.ZodString>;
     status: z.ZodEnum<{
         running: "running";
-        succeeded: "succeeded";
         failed: "failed";
+        succeeded: "succeeded";
         stopped: "stopped";
     }>;
     workerOutcome: z.ZodNullable<z.ZodEnum<{
         failed: "failed";
-        completed: "completed";
         canceled: "canceled";
+        completed: "completed";
     }>>;
     failureReason: z.ZodNullable<z.ZodString>;
     verifyChecks: z.ZodArray<z.ZodObject<{
@@ -87,8 +87,8 @@ export declare const LoopRecordSchema: z.ZodObject<{
     maxTimeMs: z.ZodNullable<z.ZodNumber>;
     status: z.ZodEnum<{
         running: "running";
-        succeeded: "succeeded";
         failed: "failed";
+        succeeded: "succeeded";
         stopped: "stopped";
     }>;
     createdAt: z.ZodString;
@@ -104,14 +104,14 @@ export declare const LoopRecordSchema: z.ZodObject<{
         verifierAgentId: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<{
             running: "running";
-            succeeded: "succeeded";
             failed: "failed";
+            succeeded: "succeeded";
             stopped: "stopped";
         }>;
         workerOutcome: z.ZodNullable<z.ZodEnum<{
             failed: "failed";
-            completed: "completed";
             canceled: "canceled";
+            completed: "completed";
         }>>;
         failureReason: z.ZodNullable<z.ZodString>;
         verifyChecks: z.ZodArray<z.ZodObject<{
@@ -157,8 +157,8 @@ export declare const LoopListItemSchema: z.ZodObject<{
     name: z.ZodNullable<z.ZodString>;
     status: z.ZodEnum<{
         running: "running";
-        succeeded: "succeeded";
         failed: "failed";
+        succeeded: "succeeded";
         stopped: "stopped";
     }>;
     cwd: z.ZodString;
@@ -232,8 +232,8 @@ export declare const LoopRunResponseSchema: z.ZodObject<{
             maxTimeMs: z.ZodNullable<z.ZodNumber>;
             status: z.ZodEnum<{
                 running: "running";
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
                 stopped: "stopped";
             }>;
             createdAt: z.ZodString;
@@ -249,14 +249,14 @@ export declare const LoopRunResponseSchema: z.ZodObject<{
                 verifierAgentId: z.ZodNullable<z.ZodString>;
                 status: z.ZodEnum<{
                     running: "running";
-                    succeeded: "succeeded";
                     failed: "failed";
+                    succeeded: "succeeded";
                     stopped: "stopped";
                 }>;
                 workerOutcome: z.ZodNullable<z.ZodEnum<{
                     failed: "failed";
-                    completed: "completed";
                     canceled: "canceled";
+                    completed: "completed";
                 }>>;
                 failureReason: z.ZodNullable<z.ZodString>;
                 verifyChecks: z.ZodArray<z.ZodObject<{
@@ -309,8 +309,8 @@ export declare const LoopListResponseSchema: z.ZodObject<{
             name: z.ZodNullable<z.ZodString>;
             status: z.ZodEnum<{
                 running: "running";
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
                 stopped: "stopped";
             }>;
             cwd: z.ZodString;
@@ -346,8 +346,8 @@ export declare const LoopInspectResponseSchema: z.ZodObject<{
             maxTimeMs: z.ZodNullable<z.ZodNumber>;
             status: z.ZodEnum<{
                 running: "running";
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
                 stopped: "stopped";
             }>;
             createdAt: z.ZodString;
@@ -363,14 +363,14 @@ export declare const LoopInspectResponseSchema: z.ZodObject<{
                 verifierAgentId: z.ZodNullable<z.ZodString>;
                 status: z.ZodEnum<{
                     running: "running";
-                    succeeded: "succeeded";
                     failed: "failed";
+                    succeeded: "succeeded";
                     stopped: "stopped";
                 }>;
                 workerOutcome: z.ZodNullable<z.ZodEnum<{
                     failed: "failed";
-                    completed: "completed";
                     canceled: "canceled";
+                    completed: "completed";
                 }>>;
                 failureReason: z.ZodNullable<z.ZodString>;
                 verifyChecks: z.ZodArray<z.ZodObject<{
@@ -439,8 +439,8 @@ export declare const LoopLogsResponseSchema: z.ZodObject<{
             maxTimeMs: z.ZodNullable<z.ZodNumber>;
             status: z.ZodEnum<{
                 running: "running";
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
                 stopped: "stopped";
             }>;
             createdAt: z.ZodString;
@@ -456,14 +456,14 @@ export declare const LoopLogsResponseSchema: z.ZodObject<{
                 verifierAgentId: z.ZodNullable<z.ZodString>;
                 status: z.ZodEnum<{
                     running: "running";
-                    succeeded: "succeeded";
                     failed: "failed";
+                    succeeded: "succeeded";
                     stopped: "stopped";
                 }>;
                 workerOutcome: z.ZodNullable<z.ZodEnum<{
                     failed: "failed";
-                    completed: "completed";
                     canceled: "canceled";
+                    completed: "completed";
                 }>>;
                 failureReason: z.ZodNullable<z.ZodString>;
                 verifyChecks: z.ZodArray<z.ZodObject<{
@@ -549,8 +549,8 @@ export declare const LoopStopResponseSchema: z.ZodObject<{
             maxTimeMs: z.ZodNullable<z.ZodNumber>;
             status: z.ZodEnum<{
                 running: "running";
-                succeeded: "succeeded";
                 failed: "failed";
+                succeeded: "succeeded";
                 stopped: "stopped";
             }>;
             createdAt: z.ZodString;
@@ -566,14 +566,14 @@ export declare const LoopStopResponseSchema: z.ZodObject<{
                 verifierAgentId: z.ZodNullable<z.ZodString>;
                 status: z.ZodEnum<{
                     running: "running";
-                    succeeded: "succeeded";
                     failed: "failed";
+                    succeeded: "succeeded";
                     stopped: "stopped";
                 }>;
                 workerOutcome: z.ZodNullable<z.ZodEnum<{
                     failed: "failed";
-                    completed: "completed";
                     canceled: "canceled";
+                    completed: "completed";
                 }>>;
                 failureReason: z.ZodNullable<z.ZodString>;
                 verifyChecks: z.ZodArray<z.ZodObject<{