@abelxiaoxing/cadence 1.2.2 → 1.2.3

package/src/subagent-activity.ts

@@ -87,7 +87,6 @@ export type ActivitySummary = EvidenceActivitySummary | DiffActivitySummary;
 export type ActivityTone = "accent" | "success" | "warning" | "muted" | "error";
 
 export interface ActivityDisplay {
-  version: 1;
   kind: "activityDisplay";
   requestId: string;
   role: string;
@@ -188,6 +187,7 @@ export function sanitizeDisplayText(value: unknown, maxLength = 240): string {
 }
 
 const SAFE_WORKFLOW_CODE = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
+const SAFE_DESIGN_DETAIL_VALUE = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
 const SAFE_CONTROL_ACTIONS = new Set([
   "start",
   "status",
@@ -221,6 +221,82 @@ export function sanitizeFailureReason(value: unknown, maxLength = 240): string {
   return safe.slice(0, Math.max(0, maxLength));
 }
 
+function safeDesignFailure(value: unknown): {
+  operation: string;
+  code: string;
+  diagnostics: Array<Record<string, string>>;
+} | null {
+  const failure = asRecord(value);
+  if (
+    failure?.kind !== "design-control-failure" ||
+    typeof failure.operation !== "string" ||
+    !SAFE_DESIGN_DETAIL_VALUE.test(failure.operation) ||
+    typeof failure.code !== "string" ||
+    !SAFE_DESIGN_DETAIL_VALUE.test(failure.code) ||
+    !Array.isArray(failure.diagnostics)
+  ) {
+    return null;
+  }
+  const diagnostics = failure.diagnostics.flatMap((candidate) => {
+    const record = asRecord(candidate);
+    if (
+      !record ||
+      typeof record.code !== "string" ||
+      !SAFE_DESIGN_DETAIL_VALUE.test(record.code)
+    ) {
+      return [];
+    }
+    return [
+      Object.fromEntries(
+        Object.entries(record).filter(
+          ([, entry]) =>
+            typeof entry === "string" && SAFE_DESIGN_DETAIL_VALUE.test(entry),
+        ),
+      ) as Record<string, string>,
+    ];
+  });
+  return {
+    operation: failure.operation,
+    code: failure.code,
+    diagnostics,
+  };
+}
+
+function renderDesignFailure(
+  failure: ReturnType<typeof safeDesignFailure> & object,
+  expanded: boolean,
+  theme?: ActivityTheme,
+): Component {
+  const title = styled(
+    theme,
+    "error",
+    `${dispatchLabel("design")} ${failure.operation} failed: ${failure.code}`,
+  );
+  if (!expanded || failure.diagnostics.length === 0) {
+    const suffix =
+      failure.diagnostics.length > 0
+        ? styled(
+            theme,
+            "muted",
+            ` (${failure.diagnostics.length} diagnostic${failure.diagnostics.length === 1 ? "" : "s"})`,
+          )
+        : "";
+    return new Text(`${title}${suffix}`, 0, 0);
+  }
+  const lines = failure.diagnostics.map((diagnostic) => {
+    const details = Object.entries(diagnostic)
+      .filter(([key]) => key !== "code")
+      .map(([key, value]) => `${key}=${value}`)
+      .join(" · ");
+    return `  - ${diagnostic.code}${details ? ` · ${details}` : ""}`;
+  });
+  return new Text(
+    [title, ...lines.map((entry) => styled(theme, "muted", entry))].join("\n"),
+    0,
+    0,
+  );
+}
+
 export function formatElapsed(milliseconds: number): string {
   const value = Math.max(
     0,
@@ -470,6 +546,7 @@ function workflowStateOf(
   }
   const state = result.state;
   switch (state) {
+    case "not-started":
     case "created":
     case "ready":
     case "queued":
@@ -659,7 +736,6 @@ export function projectWorkflowActivity(
       ? "completion-state-inconsistent"
       : workflowCode(payload);
   return {
-    version: 1,
     kind: "activityDisplay",
     requestId: sanitizeDisplayText(
       runId ?? taskId ?? change ?? command.operationId ?? "pending",
@@ -792,7 +868,6 @@ function displayFromEvent(
 ): ActivityDisplay {
   const reason = event.failureReason;
   return {
-    version: 1,
     kind: "activityDisplay",
     requestId: entry.requestId,
     role: entry.role,
@@ -989,7 +1064,6 @@ export class ActivityController {
     const entry = this.entries.get(toolCallId);
     if (!entry) return;
     const display: ActivityDisplay = {
-      version: 1,
       kind: "activityDisplay",
       requestId: entry.requestId,
       role: entry.role,
@@ -1230,7 +1304,6 @@ export function renderActivityResult(
   if (failedRun) {
     const snapshot = identityFromDispatchArgs(asRecord(context?.args)?.request);
     const display: ActivityDisplay = {
-      version: 1,
       kind: "activityDisplay",
       requestId: isActivityDisplay(activity)
         ? activity.requestId
@@ -1250,6 +1323,10 @@ export function renderActivityResult(
     return new ActivityInlineComponent(display, theme);
   }
   if (failed) {
+    const designFailure = safeDesignFailure(details?.designFailure);
+    if (args?.action === "design" && designFailure) {
+      return renderDesignFailure(designFailure, options.expanded, theme);
+    }
     return new Text(
       `${dispatchLabel(args?.action ?? args?.command)} failed`,
       0,
@@ -1275,7 +1352,6 @@ function isActivityDisplay(value: unknown): value is ActivityDisplay {
   const record = asRecord(value);
   return (
     record?.kind === "activityDisplay" &&
-    record.version === 1 &&
     typeof record.requestId === "string" &&
     typeof record.role === "string" &&
     typeof record.phase === "string" &&

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) {