@abelxiaoxing/cadence 1.2.1 → 1.2.3

package/src/submit-tool.ts

@@ -9,7 +9,9 @@ import {
   type CandidateFailure,
   type DiffResult,
   type EvidenceResult,
+  isAgentsPath,
   isValidRelativePath,
+  LIMITS,
   type SubmitFinalCategory,
   type SubmitSchemaState,
   validateDiffResult,
@@ -144,15 +146,57 @@ function candidateArtifactSchema(candidateId: string) {
         code: Type.Union([
           Type.Literal("approved-context-needed"),
           Type.Literal("task-split-needed"),
-          Type.Literal("boundary-review-needed"),
         ]),
-        refs: Type.Array(Type.String(), { maxItems: 32 }),
+        refs: Type.Array(
+          Type.Union([
+            Type.String(),
+            Type.Object(
+              {
+                kind: Type.Literal("requested-path"),
+                path: Type.String(),
+                access: Type.Union([
+                  Type.Literal("read"),
+                  Type.Literal("write"),
+                ]),
+              },
+              { additionalProperties: false },
+            ),
+            Type.Object(
+              {
+                kind: Type.Literal("source-citation"),
+                path: Type.String(),
+                line: Type.Integer({ minimum: 1 }),
+              },
+              { additionalProperties: false },
+            ),
+            Type.Object(
+              {
+                kind: Type.Literal("contract-diagnostic"),
+                ref: Type.String(),
+              },
+              { additionalProperties: false },
+            ),
+          ]),
+          { minItems: 1, maxItems: 32 },
+        ),
       },
       { additionalProperties: false },
     ),
   ]);
 }
 
+export type CandidateContextRequestCode =
+  | "approved-context-needed"
+  | "task-split-needed"
+  | "boundary-review-needed";
+
+export type CandidateContextRef =
+  | { kind: "requested-path"; path: string; access: "read" | "write" }
+  | { kind: "source-citation"; path: string; line: number }
+  | { kind: "contract-diagnostic"; ref: string };
+
+export type CandidateContextRefInput = string | CandidateContextRef;
+
 export type CandidateArtifactSubmissionResult =
   | {
       kind: "sealed-candidate";
@@ -166,11 +210,8 @@ export type CandidateArtifactSubmissionResult =
   | {
       kind: "context-request";
       candidateId: string;
-      code:
-        | "approved-context-needed"
-        | "task-split-needed"
-        | "boundary-review-needed";
-      refs: string[];
+      code: CandidateContextRequestCode;
+      refs: CandidateContextRef[];
     };
 
 export type CandidateContextRequest = Extract<
@@ -178,18 +219,114 @@ export type CandidateContextRequest = Extract<
   { kind: "context-request" }
 >;
 
+export interface CandidateContextBoundary {
+  phase: "red" | "green" | "refactor";
+  readPaths: readonly string[];
+  writePaths: readonly string[];
+  deletePaths?: readonly string[];
+  taskPaths: readonly string[];
+  redWritePaths: readonly string[];
+  agents: {
+    impact: "none" | "update-existing" | "create-index" | "remove-index";
+    target?: string;
+  };
+}
+
 export interface ClassifiedCandidateContextRequest {
-  kind: "paused" | "approval-needed";
+  kind: "paused" | "retryable" | "approval-needed";
   code:
     | "approved-context-needed"
     | "task-split-needed"
-    | "boundary-review-needed";
+    | "boundary-review-needed"
+    | "red-artifact-constraint"
+    | "agents-context-needed"
+    | "agents-write-parent-owned"
+    | "agents-contract-insufficient";
   contextRequest: {
-    code: CandidateContextRequest["code"];
-    refs: string[];
+    code: CandidateContextRequestCode;
+    refs: CandidateContextRef[];
   };
 }
 
+const LEGACY_CITATION = /^(.*):(\d+)$/u;
+const LEGACY_DIAGNOSTIC =
+  /^(?:phase-contract|task-contract|sealed-contract|workflow-contract)\.[a-z0-9._-]+$/iu;
+
+function validDiagnosticRef(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length > 0 &&
+    value.length <= 512 &&
+    value.trim() === value &&
+    !/[\r\n\0]/u.test(value)
+  );
+}
+
+function normalizeCandidateContextRef(
+  input: CandidateContextRefInput,
+): CandidateContextRef {
+  if (typeof input === "string") {
+    const citation = LEGACY_CITATION.exec(input);
+    if (citation && isValidRelativePath(citation[1])) {
+      const line = Number(citation[2]);
+      if (Number.isSafeInteger(line) && line >= 1) {
+        return { kind: "source-citation", path: citation[1], line };
+      }
+    }
+    if (LEGACY_DIAGNOSTIC.test(input)) {
+      return { kind: "contract-diagnostic", ref: input };
+    }
+    if (!isValidRelativePath(input)) {
+      throw new Error("context request refs are invalid");
+    }
+    return { kind: "requested-path", path: input, access: "read" };
+  }
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("context request refs are invalid");
+  }
+  if (
+    input.kind === "requested-path" &&
+    Object.keys(input).length === 3 &&
+    isValidRelativePath(input.path) &&
+    (input.access === "read" || input.access === "write")
+  ) {
+    return { ...input };
+  }
+  if (
+    input.kind === "source-citation" &&
+    Object.keys(input).length === 3 &&
+    isValidRelativePath(input.path) &&
+    Number.isSafeInteger(input.line) &&
+    input.line >= 1
+  ) {
+    return { ...input };
+  }
+  if (
+    input.kind === "contract-diagnostic" &&
+    Object.keys(input).length === 2 &&
+    validDiagnosticRef(input.ref)
+  ) {
+    return { ...input };
+  }
+  throw new Error("context request refs are invalid");
+}
+
+export function normalizeCandidateContextRefs(
+  value: unknown,
+): CandidateContextRef[] {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 32) {
+    throw new Error("context request refs are invalid");
+  }
+  const refs = value.map((entry) =>
+    normalizeCandidateContextRef(entry as CandidateContextRefInput),
+  );
+  const identities = refs.map((ref) => JSON.stringify(ref));
+  if (new Set(identities).size !== refs.length) {
+    throw new Error("context request refs are invalid");
+  }
+  return refs;
+}
+
 function contextRefWithinBoundary(relative: string, approved: string): boolean {
   return (
     approved === "." ||
@@ -198,23 +335,108 @@ function contextRefWithinBoundary(relative: string, approved: string): boolean {
   );
 }
 
+function normalizedBoundary(
+  boundary: readonly string[] | CandidateContextBoundary,
+): CandidateContextBoundary {
+  if (!Array.isArray(boundary)) return boundary as CandidateContextBoundary;
+  return {
+    phase: "green",
+    readPaths: boundary,
+    writePaths: [],
+    deletePaths: [],
+    taskPaths: boundary,
+    redWritePaths: [],
+    agents: { impact: "none" },
+  };
+}
+
+function pathWithinAny(relative: string, approved: readonly string[]): boolean {
+  return approved.some((path) => contextRefWithinBoundary(relative, path));
+}
+
 export function classifyCandidateContextRequest(
-  request: CandidateContextRequest,
-  approvedPaths: readonly string[],
+  request: {
+    kind: "context-request";
+    candidateId: string;
+    code: CandidateContextRequestCode;
+    refs: readonly CandidateContextRefInput[];
+  },
+  inputBoundary: readonly string[] | CandidateContextBoundary,
 ): ClassifiedCandidateContextRequest {
-  const refs = [...request.refs];
-  const inBoundary =
-    refs.length > 0 &&
-    refs.every((relative) =>
-      approvedPaths.some((approved) =>
-        contextRefWithinBoundary(relative, approved),
+  const refs = normalizeCandidateContextRefs(request.refs);
+  const boundary = normalizedBoundary(inputBoundary);
+  const phasePaths = [
+    ...boundary.readPaths,
+    ...boundary.writePaths,
+    ...(boundary.deletePaths ?? []),
+  ];
+  const requested = refs.filter(
+    (ref): ref is Extract<CandidateContextRef, { kind: "requested-path" }> =>
+      ref.kind === "requested-path",
+  );
+  const ordinaryRequested = requested.filter((ref) => !isAgentsPath(ref.path));
+  const outsideOrdinary = ordinaryRequested.filter(
+    (ref) =>
+      !pathWithinAny(
+        ref.path,
+        ref.access === "write"
+          ? [...boundary.writePaths, ...(boundary.deletePaths ?? [])]
+          : phasePaths,
       ),
+  );
+  const agentsRequested = requested.filter((ref) => isAgentsPath(ref.path));
+  const agentsWrites = agentsRequested.filter((ref) => ref.access === "write");
+  const citedRedArtifacts = refs.filter(
+    (ref): ref is Extract<CandidateContextRef, { kind: "source-citation" }> =>
+      ref.kind === "source-citation" &&
+      pathWithinAny(ref.path, boundary.redWritePaths) &&
+      !pathWithinAny(ref.path, [
+        ...boundary.writePaths,
+        ...(boundary.deletePaths ?? []),
+      ]),
+  );
+  const requestedRedArtifacts = outsideOrdinary.filter(
+    (ref) =>
+      pathWithinAny(ref.path, boundary.redWritePaths) &&
+      pathWithinAny(ref.path, boundary.taskPaths),
+  );
+  const redArtifactConstraint =
+    boundary.phase === "green" &&
+    (citedRedArtifacts.length > 0 || requestedRedArtifacts.length > 0) &&
+    outsideOrdinary.every((ref) => requestedRedArtifacts.includes(ref)) &&
+    agentsRequested.every((ref) => ref.access === "read");
+
+  let classification: Pick<ClassifiedCandidateContextRequest, "kind" | "code">;
+  if (outsideOrdinary.length > 0 && !redArtifactConstraint) {
+    classification = {
+      kind: "approval-needed",
+      code: "boundary-review-needed",
+    };
+  } else if (agentsWrites.length > 0) {
+    const targetMismatch = agentsWrites.some(
+      (ref) =>
+        boundary.agents.impact === "none" ||
+        boundary.agents.target === undefined ||
+        ref.path !== boundary.agents.target,
     );
-  const approvalNeeded =
-    !inBoundary || request.code === "boundary-review-needed";
+    classification = targetMismatch
+      ? { kind: "approval-needed", code: "agents-contract-insufficient" }
+      : { kind: "paused", code: "agents-write-parent-owned" };
+  } else if (redArtifactConstraint) {
+    classification = { kind: "retryable", code: "red-artifact-constraint" };
+  } else if (agentsRequested.length > 0) {
+    classification = { kind: "paused", code: "agents-context-needed" };
+  } else {
+    classification = {
+      kind: request.code === "approved-context-needed" ? "retryable" : "paused",
+      code:
+        request.code === "task-split-needed"
+          ? "task-split-needed"
+          : "approved-context-needed",
+    };
+  }
   return {
-    kind: approvalNeeded ? "approval-needed" : "paused",
-    code: inBoundary ? request.code : "boundary-review-needed",
+    ...classification,
     contextRequest: {
       code: request.code,
       refs,
@@ -256,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 = {
@@ -391,18 +619,17 @@ export function createCandidateArtifactTool(
           terminate: true,
         };
       }
-      const refs = value.refs as string[];
-      if (
-        refs.some((relative) => !isValidRelativePath(relative)) ||
-        new Set(refs).size !== refs.length
-      ) {
+      let refs: CandidateContextRef[];
+      try {
+        refs = normalizeCandidateContextRefs(value.refs);
+      } catch (error) {
         schema = "invalid";
         failure = {
           kind: "artifact",
           code: "invalid-structural-result",
           stage: "structural-submit",
         };
-        throw new Error("context request refs are invalid");
+        throw error;
       }
       result = {
         kind: "context-request",
@@ -411,7 +638,7 @@ export function createCandidateArtifactTool(
           CandidateArtifactSubmissionResult,
           { kind: "context-request" }
         >["code"],
-        refs: [...refs],
+        refs,
       };
       return {
         content: [
@@ -434,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 {
@@ -482,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 = {
@@ -548,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,