@abelxiaoxing/cadence 1.2.2 → 1.2.4

package/src/submit-tool.ts

@@ -11,6 +11,7 @@ import {
   type EvidenceResult,
   isAgentsPath,
   isValidRelativePath,
+  LIMITS,
   type SubmitFinalCategory,
   type SubmitSchemaState,
   validateDiffResult,
@@ -427,7 +428,7 @@ export function classifyCandidateContextRequest(
     classification = { kind: "paused", code: "agents-context-needed" };
   } else {
     classification = {
-      kind: "paused",
+      kind: request.code === "approved-context-needed" ? "retryable" : "paused",
       code:
         request.code === "task-split-needed"
           ? "task-split-needed"
@@ -477,10 +478,16 @@ export function createCandidateArtifactTool(
     executionMode: "sequential",
     parameters,
     async execute(_toolCallId, params) {
+      attempts++;
       if (result !== undefined) {
+        schema = "invalid";
+        failure = {
+          kind: "artifact",
+          code: "invalid-structural-result",
+          stage: "structural-submit",
+        };
         throw new Error("candidate terminal result already submitted");
       }
-      attempts++;
       if (attempts > 2) {
         schema = "invalid";
         failure = {
@@ -654,6 +661,170 @@ export function createCandidateArtifactTool(
   };
 }
 
+export function createStructuredPatchTool(input: {
+  requestId: string;
+  taskId?: string;
+  role: string;
+  phase: string;
+  workspaceRoot: string;
+  writePaths: string[];
+  deletePaths: string[];
+}) {
+  let submitted: DiffResult | CandidateContextRequest | undefined;
+  let failure: CandidateFailure | undefined;
+  let attempts = 0;
+  let schema: SubmitSchemaState = "not-submitted";
+  let identity: IdentityOutcome = {
+    request: true,
+    role: true,
+    task: true,
+    phase: true,
+  };
+  const candidateId = input.requestId;
+  const tool = defineTool({
+    name: "abel_submit_result",
+    label: "Submit Abel Structured Patch",
+    description:
+      "Submit one complete structured patch. Unified-diff headers and hunks are generated by the trusted control plane.",
+    executionMode: "sequential",
+    parameters: candidateArtifactSchema(candidateId),
+    async execute(_toolCallId, params) {
+      attempts += 1;
+      if (submitted !== undefined) {
+        schema = "invalid";
+        failure = {
+          kind: "artifact",
+          code: "invalid-structural-result",
+          stage: "structural-submit",
+        };
+        throw new Error("structured patch terminal result already submitted");
+      }
+      if (attempts > 2) {
+        schema = "invalid";
+        failure = {
+          kind: "artifact",
+          code: "invalid-structural-result",
+          stage: "structural-submit",
+        };
+        throw new Error("structural submission correction limit exceeded");
+      }
+      identity = {
+        request: true,
+        role: true,
+        task: true,
+        phase: true,
+      };
+      failure = undefined;
+      const value = params as unknown as Record<string, unknown>;
+      if (value.candidateId !== candidateId) {
+        identity.request = false;
+        schema = "invalid";
+        failure = {
+          kind: "artifact",
+          code: "structural-identity-mismatch",
+          stage: "structural-submit",
+        };
+        throw new Error("diagnosis candidate identity mismatch");
+      }
+      if (value.kind === "context-request") {
+        let refs: CandidateContextRef[];
+        try {
+          refs = normalizeCandidateContextRefs(value.refs);
+        } catch (error) {
+          schema = "invalid";
+          failure = {
+            kind: "artifact",
+            code: "invalid-structural-result",
+            stage: "structural-submit",
+          };
+          throw error;
+        }
+        submitted = {
+          kind: "context-request",
+          candidateId,
+          code: value.code as CandidateContextRequest["code"],
+          refs,
+        };
+        schema = "valid";
+        return {
+          content: [
+            { type: "text" as const, text: "Context request accepted." },
+          ],
+          details: { accepted: true },
+          terminate: true,
+        };
+      }
+      if (value.kind !== "candidate-patch") {
+        schema = "invalid";
+        failure = {
+          kind: "artifact",
+          code: "invalid-structural-result",
+          stage: "structural-submit",
+        };
+        throw new Error("diagnosis result must be a patch or context request");
+      }
+      let compiled: ReturnType<typeof compileCandidatePatch>;
+      try {
+        compiled = compileCandidatePatch({
+          root: input.workspaceRoot,
+          operations: value.operations as CandidatePatchOperation[],
+          writePaths: input.writePaths,
+          deletePaths: input.deletePaths,
+          maxBytes: LIMITS.maxCompleteResultBytes,
+        });
+      } catch (error) {
+        schema = "invalid";
+        failure = {
+          kind: "artifact",
+          code: "invalid-diff",
+          stage: "candidate-diff",
+        };
+        throw error;
+      }
+      const result: DiffResult = {
+        id: input.requestId,
+        role: input.role,
+        kind: "diff",
+        taskId: input.taskId ?? input.requestId,
+        phase: input.phase,
+        summary:
+          "Trusted control plane generated this diff from structured operations.",
+        diff: compiled,
+        expectedVerification: "parent-owned verification contract",
+        risks: [],
+        contractCompliant: true,
+      };
+      const validation = validateDiffResult(result);
+      if (!validation.ok) {
+        schema = "invalid";
+        failure = validation.failure ?? {
+          kind: "artifact",
+          code: "invalid-structural-result",
+          stage: "structural-submit",
+        };
+        throw new Error(validation.reason ?? "structured patch is invalid");
+      }
+      submitted = result;
+      schema = "valid";
+      return {
+        content: [{ type: "text" as const, text: "Abel patch accepted." }],
+        details: { accepted: true },
+        terminate: true,
+      };
+    },
+  });
+  return {
+    tool,
+    getResult: () =>
+      submitted === undefined ? undefined : structuredClone(submitted),
+    getAttempts: () => attempts,
+    getSchema: () => schema,
+    getIdentity: () => ({ ...identity }),
+    getFailure: () =>
+      failure === undefined ? undefined : structuredClone(failure),
+  };
+}
+
 export type FinalCategory = SubmitFinalCategory;
 
 export interface IdentityOutcome {
@@ -702,6 +873,15 @@ export function createSubmitTool(input: {
         : diffSchema,
     async execute(_toolCallId, params) {
       attempts++;
+      if (submitted !== undefined) {
+        schema = "invalid";
+        failure = {
+          kind: "artifact",
+          code: "invalid-structural-result",
+          stage: "structural-submit",
+        };
+        throw new Error("duplicate structural submission");
+      }
       if (attempts > 2) {
         schema = "invalid";
         failure = {
@@ -768,14 +948,6 @@ export function createSubmitTool(input: {
           validation.reason ?? "submitted result identity does not match",
         );
       }
-      if (submitted) {
-        failure = {
-          kind: "artifact",
-          code: "invalid-structural-result",
-          stage: "structural-submit",
-        };
-        throw new Error("duplicate structural submission");
-      }
       submitted = structuredClone(value) as unknown as
         | EvidenceResult
         | DiffResult;

package/src/task-ledger.ts

@@ -230,7 +230,7 @@ function hashEvent(
   eventJson: string,
 ): string {
   return createHash("sha256")
-    .update("cadence-task-ledger-event-v2\0")
+    .update("cadence-task-ledger-event\0")
     .update(priorHash)
     .update("\0")
     .update(String(ordinal))
@@ -1354,7 +1354,6 @@ export class TaskLedger {
       return { ordinal: row.ordinal, ...fact };
     });
     const projection = {
-      version: 2,
       runId: input.runId,
       taskId: input.taskId,
       deliveryRevision: task.delivery_revision,

package/src/worker-broker.ts

@@ -7,12 +7,12 @@ import {
 } from "./route-policy.ts";
 
 export const ROUTE_ATTEMPT_BOUNDS = Object.freeze({
-  connectMs: 5_000,
-  firstResponseMs: 30_000,
-  idleMs: 60_000,
-  totalMs: 10 * 60_000,
+  connectMs: 10_000,
+  firstResponseMs: 90_000,
+  idleMs: 3 * 60_000,
+  totalMs: 20 * 60_000,
   cooldownMs: 30_000,
-  attemptsPerRoute: 1,
+  attemptsPerRoute: 2,
 });
 
 export type RouteHealthState = "healthy" | "open" | "half-open";
@@ -61,6 +61,7 @@ export interface RunWorkerAttemptInput<T> {
   requirements?: RouteRequirements;
   signal?: AbortSignal;
   onActivity?: (event: BrokerActivityUpdate) => void;
+  classifyResult?: (value: T) => string | undefined;
   execute(context: RouteAttemptContext): Promise<T>;
 }
 
@@ -218,6 +219,16 @@ export class WorkerBroker {
     this.#setRouteHealth(routeId, { state: "healthy" });
   }
 
+  #releaseHalfOpenProbeForRetry(routeId: string, code: string): void {
+    const health = this.#routeHealth(routeId);
+    if (health.state !== "half-open" || !health.probeInFlight) return;
+    this.#setRouteHealth(routeId, {
+      state: "open",
+      retryAt: this.#now(),
+      lastCode: code,
+    });
+  }
+
   select(input: {
     role: WorkerRole;
     dialects?: RouteDialect[];
@@ -372,6 +383,7 @@ export class WorkerBroker {
     requirements?: RouteRequirements;
     signal?: AbortSignal;
     onActivity?: (event: BrokerActivityUpdate) => void;
+    classifyResult?: (value: T) => string | undefined;
     execute: (context: RouteAttemptContext) => Promise<T>;
   }): Promise<
     | { ok: true; routeId: string; value: T; attempts: BrokerAttemptEvidence[] }
@@ -397,12 +409,20 @@ export class WorkerBroker {
     }
     const attempted = new Set<string>();
     const evidence: BrokerAttemptEvidence[] = [];
-    const maxAttempts = this.#policy.roles[input.role].filter((routeId) => {
-      const route = this.#policy.routes[routeId];
-      return route
-        ? capable(route, input.role, input.requirements ?? {})
-        : false;
-    }).length;
+    const capableRouteCount = this.#policy.roles[input.role].filter(
+      (routeId) => {
+        const route = this.#policy.routes[routeId];
+        return route
+          ? capable(route, input.role, input.requirements ?? {})
+          : false;
+      },
+    ).length;
+    const maxAttempts = Math.max(
+      1,
+      capableRouteCount > 1
+        ? capableRouteCount
+        : ROUTE_ATTEMPT_BOUNDS.attemptsPerRoute,
+    );
     for (;;) {
       const selection = this.select({
         role: input.role,
@@ -427,6 +447,9 @@ export class WorkerBroker {
           probeExpiresAt: this.#now() + ROUTE_ATTEMPT_BOUNDS.totalMs,
         });
       }
+      const routeAttempt = evidence.filter(
+        (item) => item.routeId === routeId,
+      ).length;
       const attempt = evidence.length + 1;
       emitBrokerActivity(input.onActivity, {
         state: "connecting",
@@ -450,6 +473,31 @@ export class WorkerBroker {
                   : "worker-progress",
             }),
         );
+        const semanticCode = input.classifyResult?.(value);
+        if (semanticCode) {
+          evidence.push({ routeId, code: semanticCode });
+          const routeHasRetry =
+            capableRouteCount === 1 &&
+            routeAttempt + 1 < ROUTE_ATTEMPT_BOUNDS.attemptsPerRoute;
+          if (routeHasRetry) {
+            this.#releaseHalfOpenProbeForRetry(routeId, semanticCode);
+            attempted.delete(routeId);
+          } else {
+            this.markFailure(routeId, semanticCode);
+          }
+          if (attempt < maxAttempts) {
+            emitBrokerActivity(input.onActivity, {
+              state: "retrying",
+              attempt,
+              maxAttempts,
+              code: semanticCode,
+              wait: "bounded-policy",
+            });
+            continue;
+          }
+          if (routeHasRetry) this.markFailure(routeId, semanticCode);
+          return { ok: true, routeId, value, attempts: evidence };
+        }
         this.markSuccess(routeId);
         return { ok: true, routeId, value, attempts: evidence };
       } catch (error) {
@@ -466,8 +514,16 @@ export class WorkerBroker {
           }
           return { ok: false, state: "cancelled", code, attempts: evidence };
         }
-        this.markFailure(routeId, code);
-        if (attempted.size < maxAttempts) {
+        const routeHasRetry =
+          capableRouteCount === 1 &&
+          routeAttempt + 1 < ROUTE_ATTEMPT_BOUNDS.attemptsPerRoute;
+        if (routeHasRetry) {
+          this.#releaseHalfOpenProbeForRetry(routeId, code);
+          attempted.delete(routeId);
+        } else {
+          this.markFailure(routeId, code);
+        }
+        if (attempt < maxAttempts) {
           emitBrokerActivity(input.onActivity, {
             state: "retrying",
             attempt,
@@ -475,6 +531,8 @@ export class WorkerBroker {
             code,
             wait: "bounded-policy",
           });
+        } else if (routeHasRetry) {
+          this.markFailure(routeId, code);
         }
       }
     }
@@ -615,6 +673,7 @@ export class RunWorkerBroker {
       ...(input.requirements ? { requirements: input.requirements } : {}),
       ...(input.signal ? { signal: input.signal } : {}),
       ...(input.onActivity ? { onActivity: input.onActivity } : {}),
+      ...(input.classifyResult ? { classifyResult: input.classifyResult } : {}),
       execute: input.execute,
     });
     if (result.ok) {