@abelxiaoxing/cadence 1.0.10 → 1.0.12

package/src/parent-payload-bridge.ts

@@ -46,6 +46,7 @@ export class ParentPayloadBridgeError extends Error {
 
 export interface ParentProviderRegistry {
   getProvider(provider: string): Provider | undefined;
+  getRegisteredNativeProvider?(provider: string): Provider | undefined;
   registerProvider(provider: Provider): void;
 }
 
@@ -198,9 +199,12 @@ export class ParentPayloadBridge {
     model: Model<string>,
     registry: ParentProviderRegistry,
   ): Provider | undefined {
-    const current = registry.getProvider(model.provider);
+    const current = this.nativeCarrier(model.provider, registry);
     if (!current) return undefined;
     const delegate = this.unwrapProvider(current);
+    const wrapped = this.isWrappedProvider(current)
+      ? current
+      : this.wrapProvider(delegate);
     const state = this.state;
     if (state?.active) {
       const key = modelKeyId(modelKeyFor(model));
@@ -210,14 +214,18 @@ export class ParentPayloadBridge {
         state.ready.delete(key);
       }
     }
-    const wrapped = this.wrapProvider(delegate);
-    registry.registerProvider(wrapped);
+    if (wrapped !== current) {
+      registry.registerProvider(wrapped);
+    }
     return wrapped;
   }
 
   capture(
     modelKey: ParentModelKey,
-    registry?: Pick<ParentProviderRegistry, "getProvider">,
+    registry?: Pick<
+      ParentProviderRegistry,
+      "getProvider" | "getRegisteredNativeProvider"
+    >,
   ): ParentPayloadCapture | undefined {
     const state = this.state;
     if (!state?.active) return undefined;
@@ -226,7 +234,7 @@ export class ParentPayloadBridge {
       return undefined;
     }
     if (registry) {
-      const current = registry.getProvider(modelKey.provider);
+      const current = this.nativeCarrier(modelKey.provider, registry);
       if (!current || this.unwrapProvider(current) !== capture.delegate) {
         return undefined;
       }
@@ -236,11 +244,14 @@ export class ParentPayloadBridge {
 
   diagnoseCapture(
     modelKey: ParentModelKey,
-    registry: Pick<ParentProviderRegistry, "getProvider">,
+    registry: Pick<
+      ParentProviderRegistry,
+      "getProvider" | "getRegisteredNativeProvider"
+    >,
   ): ParentBridgeFailureCode | undefined {
     const state = this.state;
     if (!state?.active) return "parent-bridge-session-unavailable";
-    const current = registry.getProvider(modelKey.provider);
+    const current = this.nativeCarrier(modelKey.provider, registry);
     if (!current || !this.isWrappedProvider(current)) {
       return "parent-bridge-provider-not-installed";
     }
@@ -468,6 +479,19 @@ export class ParentPayloadBridge {
     return state;
   }
 
+  private nativeCarrier(
+    providerId: string,
+    registry: Pick<
+      ParentProviderRegistry,
+      "getProvider" | "getRegisteredNativeProvider"
+    >,
+  ): Provider | undefined {
+    const registered = registry.getRegisteredNativeProvider?.(providerId);
+    return registered && this.isWrappedProvider(registered)
+      ? registered
+      : registry.getProvider(providerId);
+  }
+
   private isWrappedProvider(provider: Provider): boolean {
     return Reflect.get(provider, PROVIDER_WRAPPER) !== undefined;
   }

package/src/patch.ts

@@ -48,6 +48,11 @@ async function git(
       settled = true;
       resolve(result);
     };
+    const fail = (error: Error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
     child.stdout.on("data", (b: Buffer) => stdout.push(b));
     child.stderr.on("data", (b: Buffer) => stderr.push(b));
     child.on("error", (error) => {
@@ -59,7 +64,7 @@ async function git(
           cancelled: true,
         });
       } else {
-        reject(error);
+        fail(error);
       }
     });
     child.on("close", (code) =>
@@ -70,6 +75,11 @@ async function git(
         cancelled: signal?.aborted ?? false,
       }),
     );
+    child.stdin.on("error", (error: NodeJS.ErrnoException) => {
+      // A command may reject its input and exit before Node finishes writing it.
+      // Its exit status remains the authoritative command result.
+      if (error.code !== "EPIPE") fail(error);
+    });
     child.stdin.end(input);
   });
 }
@@ -349,6 +359,8 @@ export async function applyRetainedPatch(input: {
           return failure({ kind: preflight.kind, code: preflight.code });
         case "environment":
           return failure({ kind: preflight.kind, code: preflight.code });
+        case "verification-adapter":
+          return failure({ kind: preflight.kind, code: preflight.code });
         case "approval-boundary":
           return failure({ kind: preflight.kind, code: preflight.code });
         case "cancelled":

package/src/result-store.ts

@@ -4,7 +4,10 @@ import type {
   BaselineEntry,
   VerificationContract,
 } from "./candidate-preflight.ts";
-import type { ImplementationPhase } from "./contracts.ts";
+import {
+  cloneVerificationContract,
+  type ImplementationPhase,
+} from "./contracts.ts";
 import type { Bound, DirBound, FileBound } from "./file-snapshot.ts";
 import { snapshotFiles } from "./file-snapshot.ts";
 
@@ -105,10 +108,7 @@ function cloneRetained(retained: RetainedResult): RetainedResult {
     baseline: retained.baseline.map((entry) => ({ ...entry })),
   };
   if (retained.verification) {
-    clone.verification = {
-      ...retained.verification,
-      argv: [...retained.verification.argv],
-    };
+    clone.verification = cloneVerificationContract(retained.verification);
   }
   if (retained.packageManifest) {
     clone.packageManifest = { ...retained.packageManifest };
@@ -147,10 +147,7 @@ export class ResultStore {
       ...(input.verification === undefined
         ? {}
         : {
-            verification: {
-              ...input.verification,
-              argv: [...input.verification.argv],
-            },
+            verification: cloneVerificationContract(input.verification),
           }),
       ...(input.packageManifest === undefined
         ? {}

package/src/runtime.ts

@@ -12,6 +12,7 @@ import {
   type AgentsCheckpointRequest,
   type CandidateFailure,
   type ChildFailure,
+  cloneVerificationContract,
   type DiffResult,
   type ImplementApplyOperation,
   type ImplementationPhase,
@@ -29,6 +30,7 @@ import {
   validateImplementDiscardOperation,
   validatePhaseAttemptAgainstBoundary,
   validateRequestEnvelope,
+  verificationInputPaths,
 } from "./contracts.ts";
 import { drainStage } from "./drain.ts";
 import {
@@ -56,6 +58,7 @@ import {
   resolveSubagentEndpoint,
   type SubagentEndpoint,
 } from "./subagent-endpoint.ts";
+import { assessVerificationReadiness } from "./verification-capability.ts";
 import {
   type TaskRecord,
   taskConflictOf,
@@ -119,10 +122,7 @@ function cloneLegacyEnvelope(request: RequestEnvelope): RequestEnvelope {
     ...(request.verification === undefined
       ? {}
       : {
-          verification: {
-            ...request.verification,
-            argv: [...request.verification.argv],
-          },
+          verification: cloneVerificationContract(request.verification),
         }),
     ...(request.snapshot === undefined
       ? {}
@@ -163,10 +163,7 @@ function deriveImplementEnvelope(
     agentsManagedOnly: true,
     approvedDependencies: [...boundary.approvedDependencies],
     impactClosure: structuredClone(boundary.impactClosure),
-    verification: {
-      ...phase.verification,
-      argv: [...phase.verification.argv],
-    },
+    verification: cloneVerificationContract(phase.verification),
     snapshot: structuredClone(attempt.snapshot),
   };
 }
@@ -318,7 +315,7 @@ function preparePreflight(
     ...envelope.declared.write,
     "package.json",
     lockPath,
-    ...envelope.verification.argv.slice(3),
+    ...verificationInputPaths(envelope.verification),
   ]);
   const entries = new Map<string, BaselineEntry>();
   const observed: Bound = {};
@@ -446,6 +443,7 @@ function failureClassOf(failure: ChildFailure): FailureClass | undefined {
       return "transport";
     case "stale":
     case "approval-boundary":
+    case "verification-adapter":
     case "cancelled":
     case "result-limit":
       return undefined;
@@ -465,6 +463,7 @@ function childFailureOf(result: InternalFailureResult): ChildFailure {
       case "stale":
       case "environment":
       case "approval-boundary":
+      case "verification-adapter":
       case "cancelled":
       case "result-limit":
       case "transport":
@@ -495,6 +494,7 @@ function terminalTaskFailure(failure: ChildFailure): TaskFailure | undefined {
   switch (failure.kind) {
     case "approval-boundary":
     case "environment":
+    case "verification-adapter":
     case "result-limit":
       return failure;
     case "artifact":
@@ -515,6 +515,7 @@ function attemptFailureCause(
       return failure.kind;
     case "approval-boundary":
     case "environment":
+    case "verification-adapter":
     case "result-limit":
     case "cancelled":
       throw new Error("non-retryable failure reached the launch budget");
@@ -992,6 +993,15 @@ export class Runtime {
         };
         return blockedOutcome(identity, taskFailure);
       }
+      case "verification-adapter": {
+        const taskFailure: TaskFailure = failure;
+        worker.state = {
+          kind: "blocked",
+          phase,
+          failure: structuredClone(taskFailure),
+        };
+        return blockedOutcome(identity, taskFailure);
+      }
       case "cancelled":
         return cancelledOutcome(identity);
       case "result-limit": {
@@ -1260,6 +1270,15 @@ export class Runtime {
         };
         return blockedOutcome(outcomeIdentity, failure);
       }
+      case "verification-adapter": {
+        this.results.discard(resultId);
+        worker.state = {
+          kind: "blocked",
+          phase: identity.phase,
+          failure: structuredClone(failure),
+        };
+        return blockedOutcome(outcomeIdentity, failure);
+      }
       case "stale": {
         this.results.discard(resultId);
         if (identity.launchIndex === 0) {
@@ -1562,6 +1581,42 @@ export class Runtime {
         attempt.changeId,
         attempt.taskId,
       );
+      if (runRequest.kind === "open-task") {
+        const phases = runRequest.boundary.phases;
+        const readiness = assessVerificationReadiness(
+          workspaceRoot,
+          [
+            phases.red.verification,
+            phases.green.verification,
+            ...(phases.refactor ? [phases.refactor.verification] : []),
+          ],
+          {
+            allowedMissingInputs: [
+              ...new Set([
+                ...phases.red.write,
+                ...phases.green.write,
+                ...(phases.refactor?.write ?? []),
+              ]),
+            ],
+          },
+        );
+        const diagnostic = readiness.diagnostics[0];
+        if (diagnostic) {
+          if (diagnostic.kind === "design-readiness") {
+            throw new Error(
+              `Implement protocol error: ${diagnostic.code}: ${diagnostic.message}`,
+            );
+          }
+          return {
+            ok: false,
+            error: `${diagnostic.kind}/${diagnostic.code}: ${diagnostic.message}`,
+            failure: {
+              kind: diagnostic.kind,
+              code: diagnostic.code,
+            },
+          };
+        }
+      }
       if (
         runRequest.kind === "open-task" &&
         this.registry