@abelxiaoxing/cadence 1.1.0 → 1.2.0

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/verification-capability.ts

@@ -166,17 +166,39 @@ function localExecutable(
   }
 }
 
+function pathApi(
+  platform: NodeJS.Platform,
+  ...values: readonly string[]
+): typeof path.posix {
+  if (platform !== "win32") return path.posix;
+  if (
+    process.platform === "win32" ||
+    values.some(
+      (value) => /^[a-z]:[\\/]/iu.test(value) || value.startsWith("\\\\"),
+    )
+  ) {
+    return path.win32;
+  }
+  // Tests may model Windows executable semantics over a POSIX fixture tree.
+  return path.posix;
+}
+
 function pathWithin(
   root: string,
   candidate: string,
   platform: NodeJS.Platform,
 ): boolean {
-  const normalizedRoot = platform === "win32" ? root.toLowerCase() : root;
-  const normalizedCandidate =
-    platform === "win32" ? candidate.toLowerCase() : candidate;
+  const platformPath = pathApi(platform, root, candidate);
+  const normalizedRoot = platformPath.resolve(root);
+  const relative = platformPath.relative(
+    normalizedRoot,
+    platformPath.resolve(candidate),
+  );
   return (
-    normalizedCandidate === normalizedRoot ||
-    normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`)
+    relative === "" ||
+    (relative !== ".." &&
+      !relative.startsWith(`..${platformPath.sep}`) &&
+      !platformPath.isAbsolute(relative))
   );
 }
 
@@ -261,13 +283,24 @@ function within(root: string, candidate: string): boolean {
   return candidate === root || candidate.startsWith(`${root}${path.sep}`);
 }
 
-function commonDirectory(
+export function commonDirectory(
   left: string,
   right: string,
   platform: NodeJS.Platform = process.platform,
 ): string {
-  const leftParts = path.resolve(left).split(path.sep).filter(Boolean);
-  const rightParts = path.resolve(right).split(path.sep).filter(Boolean);
+  const platformPath = pathApi(platform, left, right);
+  const leftResolved = platformPath.resolve(left);
+  const rightResolved = platformPath.resolve(right);
+  const leftRoot = platformPath.parse(leftResolved).root;
+  const rightRoot = platformPath.parse(rightResolved).root;
+  const comparable = (value: string) =>
+    platform === "win32" ? value.toLowerCase() : value;
+  if (comparable(leftRoot) !== comparable(rightRoot)) return leftRoot;
+
+  const parts = (value: string, root: string) =>
+    platformPath.relative(root, value).split(platformPath.sep).filter(Boolean);
+  const leftParts = parts(leftResolved, leftRoot);
+  const rightParts = parts(rightResolved, rightRoot);
   const common: string[] = [];
   for (
     let index = 0;
@@ -276,15 +309,10 @@ function commonDirectory(
   ) {
     const leftPart = leftParts[index] as string;
     const rightPart = rightParts[index] as string;
-    if (
-      (platform === "win32" ? leftPart.toLowerCase() : leftPart) !==
-      (platform === "win32" ? rightPart.toLowerCase() : rightPart)
-    ) {
-      break;
-    }
+    if (comparable(leftPart) !== comparable(rightPart)) break;
     common.push(leftPart);
   }
-  return path.join(path.parse(path.resolve(left)).root, ...common);
+  return platformPath.join(leftRoot, ...common);
 }
 
 function unsafeMountSource(source: string): boolean {

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