@abelxiaoxing/cadence 1.1.1 → 1.2.1

package/src/submit-tool.ts

@@ -1,6 +1,10 @@
 import { createHash } from "node:crypto";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import {
+  type CandidatePatchOperation,
+  compileCandidatePatch,
+} from "./candidate-patch.ts";
 import {
   type CandidateFailure,
   type DiffResult,
@@ -11,7 +15,11 @@ import {
   validateDiffResult,
   validateEvidenceResult,
 } from "./contracts.ts";
-import type { BeginCandidateInput, TaskLedger } from "./task-ledger.ts";
+import {
+  type BeginCandidateInput,
+  TASK_LEDGER_LIMITS,
+  type TaskLedger,
+} from "./task-ledger.ts";
 
 const compactEvidenceSchema = Type.Object({
   id: Type.String(),
@@ -83,17 +91,49 @@ function candidateArtifactSchema(candidateId: string) {
   return Type.Union([
     Type.Object(
       {
-        kind: Type.Literal("candidate-segment"),
-        candidateId: Type.Literal(candidateId),
-        sequence: Type.Integer({ minimum: 0 }),
-        text: Type.String({ minLength: 1 }),
-      },
-      { additionalProperties: false },
-    ),
-    Type.Object(
-      {
-        kind: Type.Literal("candidate-seal"),
+        kind: Type.Literal("candidate-patch"),
         candidateId: Type.Literal(candidateId),
+        operations: Type.Array(
+          Type.Union([
+            Type.Object(
+              {
+                kind: Type.Literal("replace"),
+                path: Type.String(),
+                oldText: Type.String({ minLength: 1 }),
+                newText: Type.String(),
+              },
+              { additionalProperties: false },
+            ),
+            Type.Object(
+              {
+                kind: Type.Literal("rewrite"),
+                path: Type.String(),
+                content: Type.String(),
+              },
+              { additionalProperties: false },
+            ),
+            Type.Object(
+              {
+                kind: Type.Literal("create"),
+                path: Type.String(),
+                content: Type.String({ minLength: 1 }),
+                mode: Type.Union([
+                  Type.Literal("regular"),
+                  Type.Literal("executable"),
+                ]),
+              },
+              { additionalProperties: false },
+            ),
+            Type.Object(
+              {
+                kind: Type.Literal("delete"),
+                path: Type.String(),
+              },
+              { additionalProperties: false },
+            ),
+          ]),
+          { minItems: 1, maxItems: 128 },
+        ),
       },
       { additionalProperties: false },
     ),
@@ -188,6 +228,9 @@ export interface CandidateArtifactSubmission {
     "beginCandidate" | "appendCandidateSegment" | "sealCandidate"
   >;
   identity: BeginCandidateInput;
+  workspaceRoot: string;
+  writePaths: readonly string[];
+  deletePaths: readonly string[];
 }
 
 export function createCandidateArtifactTool(
@@ -199,10 +242,7 @@ export function createCandidateArtifactTool(
   let failure: CandidateFailure | undefined;
   let attempts = 0;
   let schema: SubmitSchemaState = "not-submitted";
-  let segmentCount = 0;
-  let totalBytes = 0;
-  const candidateHash = createHash("sha256");
-  const identity: IdentityOutcome = {
+  let identity: IdentityOutcome = {
     request: true,
     role: true,
     task: true,
@@ -212,7 +252,7 @@ export function createCandidateArtifactTool(
     name: "abel_submit_result",
     label: "Submit Abel Candidate Artifact",
     description:
-      "Submit ordered raw-text candidate segments, atomically seal the complete candidate, or request bounded approved context. Encoding and hashes are computed by this trusted tool.",
+      "Submit one complete structured candidate patch or request bounded approved context. Diff generation, chunking, encoding, hashes, and atomic sealing are owned by this trusted tool.",
     executionMode: "sequential",
     parameters,
     async execute(_toolCallId, params) {
@@ -220,6 +260,22 @@ export function createCandidateArtifactTool(
         throw new Error("candidate terminal result already submitted");
       }
       attempts++;
+      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 !== input.identity.candidateId) {
         identity.request = false;
@@ -232,18 +288,15 @@ export function createCandidateArtifactTool(
         throw new Error("candidate identity mismatch");
       }
       schema = "valid";
-      if (value.kind === "candidate-segment") {
-        const bytes = Buffer.from(value.text as string, "utf8");
-        const segmentHash = createHash("sha256").update(bytes).digest("hex");
-        let accepted: ReturnType<
-          CandidateArtifactSubmission["ledger"]["appendCandidateSegment"]
-        >;
+      if (value.kind === "candidate-patch") {
+        let diff: string;
         try {
-          accepted = input.ledger.appendCandidateSegment({
-            ...input.identity,
-            sequence: value.sequence as number,
-            bytes,
-            segmentHash,
+          diff = compileCandidatePatch({
+            root: input.workspaceRoot,
+            writePaths: input.writePaths,
+            deletePaths: input.deletePaths,
+            operations: value.operations as CandidatePatchOperation[],
+            maxBytes: TASK_LEDGER_LIMITS.maxCandidateBytes,
           });
         } catch (error) {
           schema = "invalid";
@@ -254,34 +307,59 @@ export function createCandidateArtifactTool(
           };
           throw error;
         }
-        if (!accepted.ok) {
-          failure = {
-            kind: "result-limit",
-            limitBytes: accepted.limitBytes,
-          };
-        } else {
-          candidateHash.update(bytes);
-          segmentCount = accepted.nextSequence;
-          totalBytes = accepted.totalBytes;
+        const bytes = Buffer.from(diff, "utf8");
+        const candidateHash = createHash("sha256").update(bytes).digest("hex");
+        let sequence = 0;
+        for (
+          let offset = 0;
+          offset < bytes.length;
+          offset += TASK_LEDGER_LIMITS.maxSegmentBytes
+        ) {
+          const segment = bytes.subarray(
+            offset,
+            Math.min(offset + TASK_LEDGER_LIMITS.maxSegmentBytes, bytes.length),
+          );
+          let accepted: ReturnType<
+            CandidateArtifactSubmission["ledger"]["appendCandidateSegment"]
+          >;
+          try {
+            accepted = input.ledger.appendCandidateSegment({
+              ...input.identity,
+              sequence,
+              bytes: segment,
+              segmentHash: createHash("sha256").update(segment).digest("hex"),
+            });
+          } catch (error) {
+            schema = "invalid";
+            failure = {
+              kind: "artifact",
+              code: "invalid-diff",
+              stage: "candidate-diff",
+            };
+            throw error;
+          }
+          if (!accepted.ok) {
+            failure = {
+              kind: "result-limit",
+              limitBytes: accepted.limitBytes,
+            };
+            return {
+              content: [],
+              details: accepted,
+              terminate: true,
+            };
+          }
+          sequence = accepted.nextSequence;
         }
-        return {
-          content: [
-            { type: "text" as const, text: "Candidate segment accepted." },
-          ],
-          details: accepted,
-          ...(!accepted.ok ? { terminate: true } : {}),
-        };
-      }
-      if (value.kind === "candidate-seal") {
         let sealed: ReturnType<
           CandidateArtifactSubmission["ledger"]["sealCandidate"]
         >;
         try {
           sealed = input.ledger.sealCandidate({
             ...input.identity,
-            segmentCount,
-            totalBytes,
-            candidateHash: candidateHash.digest("hex"),
+            segmentCount: sequence,
+            totalBytes: bytes.length,
+            candidateHash,
           });
         } catch (error) {
           schema = "invalid";
@@ -318,6 +396,12 @@ export function createCandidateArtifactTool(
         refs.some((relative) => !isValidRelativePath(relative)) ||
         new Set(refs).size !== refs.length
       ) {
+        schema = "invalid";
+        failure = {
+          kind: "artifact",
+          code: "invalid-structural-result",
+          stage: "structural-submit",
+        };
         throw new Error("context request refs are invalid");
       }
       result = {
@@ -377,7 +461,7 @@ export function createSubmitTool(input: {
   let failure: CandidateFailure | undefined;
   let attempts = 0;
   let schema: SubmitSchemaState = "not-submitted";
-  const identity: IdentityOutcome = {
+  let identity: IdentityOutcome = {
     request: true,
     role: true,
     task: true,
@@ -398,6 +482,22 @@ export function createSubmitTool(input: {
         : diffSchema,
     async execute(_toolCallId, params) {
       attempts++;
+      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 === null || typeof value !== "object") {
         identity.request = false;

package/src/worker-broker.ts

@@ -113,7 +113,6 @@ class RouteAttemptStop extends Error {
 function isRole(value: unknown): value is WorkerRole {
   return [
     "design-explorer",
-    "contract-reviewer",
     "implementation-worker",
     "diagnosis-worker",
   ].includes(String(value));

package/src/workflow-engine.ts

@@ -2833,13 +2833,14 @@ class DurableWorkflowComposition
     const phase = request.task.phases[request.phase];
     if (!phase) throw new Error("workflow-task-phase-invalid");
     const allPhases = Object.values(request.task.phases);
+    const approvedWritePaths = [
+      ...new Set(allPhases.flatMap((boundary) => boundary.write)),
+    ].sort();
+    const approvedDeletePaths = [
+      ...new Set(allPhases.flatMap((boundary) => boundary.delete)),
+    ].sort();
     const approvedPaths = [
-      ...new Set(
-        allPhases.flatMap((boundary) => [
-          ...boundary.write,
-          ...boundary.delete,
-        ]),
-      ),
+      ...new Set([...approvedWritePaths, ...approvedDeletePaths]),
     ].sort();
     const boundPaths = [
       ...new Set(
@@ -2915,7 +2916,13 @@ class DurableWorkflowComposition
             task: structuredClone(request.task),
             workspaceRoot: proposalRoot,
             ledgerProjection,
-            candidateArtifact: { ledger, identity },
+            candidateArtifact: {
+              ledger,
+              identity,
+              workspaceRoot: proposalRoot,
+              writePaths: approvedWritePaths,
+              deletePaths: approvedDeletePaths,
+            },
             route: attempt.route,
             repair,
             signal: attempt.signal,
@@ -3684,7 +3691,13 @@ class DurableWorkflowComposition
             task: structuredClone(input.task),
             workspaceRoot: proposalRoot,
             ledgerProjection,
-            candidateArtifact: { ledger, identity },
+            candidateArtifact: {
+              ledger,
+              identity,
+              workspaceRoot: proposalRoot,
+              writePaths: phase.write,
+              deletePaths: phase.delete,
+            },
             route: attempt.route,
             signal: attempt.signal,
             onHeaders: attempt.onHeaders,
@@ -4811,21 +4824,6 @@ export class WorkflowEngine {
     )?.run_id;
   }
 
-  #lookupProvisionalRun(provisionalKey: string): string | undefined {
-    return (
-      this.#database
-        .prepare(
-          `SELECT run_id FROM runs
-           WHERE root_hash = ? AND stage = 'abel-design'
-             AND lookup_key = ?`,
-        )
-        .get(
-          this.#stateRoot.consumerRootHash,
-          `provisional:${provisionalKey}`,
-        ) as { run_id: string } | undefined
-    )?.run_id;
-  }
-
   #ensureEngineRun(runId: string): void {
     this.#database
       .prepare(
@@ -6846,118 +6844,7 @@ export class WorkflowEngine {
     signal?: AbortSignal,
     onActivity?: (event: WorkflowActivityUpdate) => void,
   ) {
-    if (!("change" in command)) {
-      const existingRun = this.#lookupProvisionalRun(command.provisionalKey);
-      if (existingRun) {
-        this.#ensureEngineRun(existingRun);
-        const replay = this.#operationReplay(
-          existingRun,
-          command.operationId,
-          command.command,
-        );
-        if (replay) return replay;
-        const restarted = this.#runStore.startRun({
-          stage: "abel-design",
-          provisionalKey: command.provisionalKey,
-          operationId: command.operationId,
-        });
-        const begun = this.#beginOperation(
-          existingRun,
-          command.operationId,
-          command.command,
-        );
-        if (begun) return begun;
-        if (restarted.state === "created") {
-          const lease = this.#operationLease(existingRun, command.operationId);
-          this.#transition(
-            existingRun,
-            "paused",
-            `${command.operationId}:awaiting-gate-a`,
-            "design-awaiting-gate-a",
-            lease,
-          );
-        }
-        return this.#commitOperation(
-          existingRun,
-          command.operationId,
-          this.#statusByRun(existingRun),
-        );
-      }
-      const created = this.#runStore.startRun({
-        stage: "abel-design",
-        provisionalKey: command.provisionalKey,
-        operationId: command.operationId,
-      });
-      this.#ensureEngineRun(created.runId);
-      const begun = this.#beginOperation(
-        created.runId,
-        command.operationId,
-        command.command,
-      );
-      if (begun) return begun;
-      const lease = this.#operationLease(created.runId, command.operationId);
-      this.#transition(
-        created.runId,
-        "paused",
-        `${command.operationId}:awaiting-gate-a`,
-        "design-awaiting-gate-a",
-        lease,
-      );
-      return this.#commitOperation(
-        created.runId,
-        command.operationId,
-        this.#statusByRun(created.runId),
-      );
-    }
-    let existingRun = this.#lookupRun(command.stage, command.change);
-    const requestedProvisionalRun =
-      command.stage === "abel-design" && command.provisionalKey
-        ? this.#lookupProvisionalRun(command.provisionalKey)
-        : undefined;
-    if (command.provisionalKey && !requestedProvisionalRun) {
-      throw new Error("provisional-design-run-not-found");
-    }
-    if (
-      existingRun &&
-      requestedProvisionalRun &&
-      existingRun !== requestedProvisionalRun
-    ) {
-      throw new Error("provisional-design-run-conflict");
-    }
-    if (
-      existingRun &&
-      command.stage === "abel-design" &&
-      ["completed", "discarded", "rejected"].includes(
-        this.#runStore.status(existingRun).state,
-      )
-    ) {
-      const restarted = this.#runStore.startRun({
-        stage: command.stage,
-        change: command.change,
-        operationId: command.operationId,
-      });
-      existingRun = restarted.runId;
-      this.#ensureEngineRun(existingRun);
-      const begun = this.#beginOperation(
-        existingRun,
-        command.operationId,
-        command.command,
-      );
-      if (begun) return begun;
-      const lease = this.#operationLease(existingRun, command.operationId);
-      this.#transition(
-        existingRun,
-        "paused",
-        `${command.operationId}:awaiting-design-evidence`,
-        "design-awaiting-evidence",
-        lease,
-      );
-      return this.#commitOperation(
-        existingRun,
-        command.operationId,
-        this.#statusByRun(existingRun),
-      );
-    }
+    const existingRun = this.#lookupRun(command.stage, command.change);
     if (existingRun) {
       this.#ensureEngineRun(existingRun);
       const replay = this.#operationReplay(
@@ -6986,17 +6873,6 @@ export class WorkflowEngine {
       }
     }
 
-    if (requestedProvisionalRun) {
-      this.#runStore.bindChange({
-        runId: requestedProvisionalRun,
-        change: command.change,
-        operationId: `bind-change-${hash(
-          requestedProvisionalRun,
-          command.change,
-        ).slice(0, 40)}`,
-      });
-      existingRun = requestedProvisionalRun;
-    }
     const runId =
       existingRun ??
       this.#runStore.startRun({
@@ -7012,20 +6888,6 @@ export class WorkflowEngine {
     );
     if (begun) return begun;
     const lease = this.#operationLease(runId, command.operationId);
-    if (command.stage === "abel-design") {
-      this.#transition(
-        runId,
-        "paused",
-        `${command.operationId}:awaiting-design-evidence`,
-        "design-awaiting-evidence",
-        lease,
-      );
-      return this.#commitOperation(
-        runId,
-        command.operationId,
-        this.#statusByRun(runId),
-      );
-    }
     this.#transition(
       runId,
       "validating-delivery",
@@ -7087,17 +6949,6 @@ export class WorkflowEngine {
     if (replay) return replay;
     const lease = this.#operationLease(runId, command.operationId);
     const current = this.#runStore.status(runId);
-    if (current.stage === "abel-design") {
-      if (current.state !== "paused") {
-        this.#interruptOperation(runId, command.operationId);
-        throw new Error("resume-not-allowed");
-      }
-      return this.#commitOperation(
-        runId,
-        command.operationId,
-        this.#statusByRun(runId),
-      );
-    }
     if (current.state === "recovering") {
       emitWorkflowActivity(onActivity, {
         state: "recovering",

package/agents/contract-reviewer.md

@@ -1,11 +0,0 @@
-# Role: contract-reviewer
-
-You are a package-owned read-only professional Agent for terminal and checkpoint review of approved design delivery.
-
-You inspect the approved contracts, canonical `ImplementPlan`, receipts, raw and canonical hashes, verification closure, traceability, and task DAG ONLY through the scoped `read`, `grep`, `find`, and `ls` tools.
-You never write, mutate, or run validation.
-
-Your output is a compact structured evidence object returned through `abel_submit_result`, containing the review identity, the exact artifact hashes you verified, suite-evidence status, and typed `delivery-invalid` or `approval-boundary` facts (empty when the delivery is sound).
-
-You never patch product code, AGENTS files, or task state.
-Review evidence is read-only; the parent resolves it without a stage selection, Gate decision, or recovery recommendation from you.