@abelxiaoxing/cadence 1.3.0 → 1.4.1

package/src/delivery-compiler.ts

@@ -1,9 +1,13 @@
 import { createHash } from "node:crypto";
+import { compareCanonicalStrings } from "./canonical.ts";
+import {
+  assertPlanWithinChangeContract,
+  normalizeChangeContract,
+} from "./change-contract.ts";
 import {
   type AgentsImpact,
   type ImplementGraphBoundary,
   type ImplementGraphOutput,
-  type ImplementTaskBoundary,
   isAgentsPath,
   isValidRelativePath,
   type PhaseBoundary,
@@ -11,13 +15,28 @@ import {
   validateImplementGraphBoundary,
   validateVerificationContract,
 } from "./contracts.ts";
+import {
+  type DesignPlanDiagnostic,
+  DesignPlanValidationError,
+} from "./design-diagnostics.ts";
 import {
   assessImplementGraphReadiness,
   canonicalJson,
   hashCanonicalValue,
   type ImplementGraphReadiness,
 } from "./implement-graph.ts";
-import { validateVerificationAdapterCapability } from "./verification-capability.ts";
+import type {
+  ImplementPlan,
+  PlanAgentsCheckpointOperation,
+  PlanTaskDraft,
+  PlanTracking,
+  PlanVerification,
+} from "./implement-plan.ts";
+import { expandPlanDraft, preparePlanDraft } from "./plan-draft.ts";
+import {
+  bindDraftVerificationInputs,
+  validateVerificationAdapterCapability,
+} from "./verification-capability.ts";
 
 export const IMPLEMENT_PLAN_PATH = "implement-plan.json" as const;
 export const GATE_A_RECEIPT_PATH = "gate-a.yaml" as const;
@@ -94,40 +113,6 @@ export class DeliveryValidationError extends Error {
   }
 }
 
-export interface DesignPlanDiagnostic {
-  code: string;
-  taskId?: string;
-  phase?: string;
-  field?: string;
-  category?: string;
-  owner?: string;
-  verificationId?: string;
-  outputId?: string;
-  dependencyTaskId?: string;
-  producerTaskId?: string;
-  producerPhase?: string;
-}
-
-export class DesignPlanValidationError extends Error {
-  readonly diagnostics: readonly DesignPlanDiagnostic[];
-
-  constructor(message: string, diagnostics: readonly DesignPlanDiagnostic[]) {
-    const normalized = [
-      ...new Map(
-        diagnostics
-          .map((diagnostic) => structuredClone(diagnostic))
-          .sort((left, right) =>
-            canonicalJson(left).localeCompare(canonicalJson(right)),
-          )
-          .map((diagnostic) => [canonicalJson(diagnostic), diagnostic]),
-      ).values(),
-    ];
-    super(message);
-    this.name = "DesignPlanValidationError";
-    this.diagnostics = Object.freeze(normalized);
-  }
-}
-
 const SAFE_PLAN_ERROR_CODE = /^[a-z0-9](?:[a-z0-9._-]{0,126}[a-z0-9])?$/u;
 
 function planErrorCode(error: unknown): string {
@@ -173,6 +158,22 @@ export function assessDeliveryTraceability(input: {
   plan: ImplementPlan;
 }): DeliveryTraceabilityAssessment {
   const diagnostics = new Set<string>();
+  let authorMarkdown = input.tasksMarkdown;
+  let bindings: string | undefined;
+  try {
+    const region = taskVerificationRegion(input.tasksMarkdown);
+    if (region) {
+      authorMarkdown =
+        input.tasksMarkdown.slice(0, region.start) +
+        input.tasksMarkdown.slice(region.end);
+      bindings = region.text;
+      if (bindings !== renderTasks(input.plan)) {
+        diagnostics.add("traceability-managed-region-stale");
+      }
+    }
+  } catch {
+    return { ok: false, diagnostics: ["traceability-managed-region-invalid"] };
+  }
   const headings = new Set<string>();
   for (const spec of input.specs) {
     if (!isValidRelativePath(spec.path) || !spec.path.endsWith("/spec.md")) {
@@ -197,7 +198,7 @@ export function assessDeliveryTraceability(input: {
     }
   }
   const references = [
-    ...input.tasksMarkdown.matchAll(/`(specs\/[^`\n]+\/spec\.md#[^`\n]+)`/gu),
+    ...authorMarkdown.matchAll(/`(specs\/[^`\n]+\/spec\.md#[^`\n]+)`/gu),
   ].flatMap((match) => (match[1] ? [match[1].trim()] : []));
   if (references.length === 0) diagnostics.add("traceability-reference-empty");
   const referenceSet = new Set(references);
@@ -211,21 +212,22 @@ export function assessDeliveryTraceability(input: {
     diagnostics.add("traceability-scenario-unowned");
   }
   const taskIds = input.plan.tasks.map((task) => task.taskId).sort();
-  if (
-    taskIds.some((taskId) => !input.tasksMarkdown.includes(`\`${taskId}\``))
-  ) {
+  if (taskIds.some((taskId) => !authorMarkdown.includes(`\`${taskId}\``))) {
     diagnostics.add("traceability-task-unmapped");
   }
   const verificationIds = input.plan.tasks
     .flatMap((task) => [
-      task.phases.red.verification.id,
+      ...(task.verificationMode && task.verificationMode !== "behavior"
+        ? []
+        : [task.phases.red.verification.id]),
       task.phases.green.verification.id,
       ...(task.phases.refactor ? [task.phases.refactor.verification.id] : []),
     ])
     .sort();
   if (
     verificationIds.some(
-      (verificationId) => !input.tasksMarkdown.includes(verificationId),
+      (verificationId) =>
+        !(bindings ?? authorMarkdown).includes(verificationId),
     )
   ) {
     diagnostics.add("traceability-verification-unmapped");
@@ -249,69 +251,16 @@ export function assessDeliveryTraceability(input: {
   };
 }
 
-export type PlanPhaseDraft = PhaseBoundary;
-
-export interface PlanTaskDraft extends Omit<ImplementTaskBoundary, "phases"> {
-  phases: {
-    red: PlanPhaseDraft;
-    green: PlanPhaseDraft;
-    refactor?: PlanPhaseDraft;
-  };
-  affectedVerification: StructuredVerificationContract;
-  repairVerification: StructuredVerificationContract;
-}
-
-export interface PlanVerification {
-  baseline: {
-    target: "task-red-contracts";
-    affected: "task-affected-contracts";
-    fullSuite: StructuredVerificationContract;
-    failureIdentity: "normalized";
-  };
-  change: {
-    affected: "task-affected-contracts";
-    fullSuite: StructuredVerificationContract;
-    postApply: StructuredVerificationContract;
-  };
-  artifactCorrection: {
-    maxAttempts: number;
-  };
-  repair: {
-    maxAttempts: number;
-    inBoundaryOnly: true;
-    approvalOnBoundaryExpansion: true;
-    attribution: ["pre-existing", "introduced", "unresolved", "environment"];
-  };
-  agentsCheckpoint: {
-    required: boolean;
-    verification: StructuredVerificationContract | null;
-    operations: PlanAgentsCheckpointOperation[];
-  };
-}
-
-export interface PlanAgentsCheckpointOperation {
-  target: string;
-  impact: Exclude<AgentsImpact, "none">;
-  taskIds: string[];
-  managedBlock: string | null;
-}
-
-export interface PlanTracking {
-  path: "tasks.md";
-  format: "markdown-checkbox";
-  taskIds: string[];
-  completionOwner: "parent";
-}
-
-export interface PlanDraft {
-  changeId: string;
-  tasks: PlanTaskDraft[];
-  outputs: ImplementGraphOutput[];
-  verification: PlanVerification;
-  tracking: PlanTracking;
-}
-
-export type ImplementPlan = PlanDraft;
+export type { DesignPlanDiagnostic } from "./design-diagnostics.ts";
+export { DesignPlanValidationError } from "./design-diagnostics.ts";
+export type {
+  ImplementPlan,
+  PlanAgentsCheckpointOperation,
+  PlanTaskDraft,
+  PlanTracking,
+  PlanVerification,
+} from "./implement-plan.ts";
+export type { PlanDraft, PlanPhaseDraft, PlanTaskInput } from "./plan-draft.ts";
 
 export interface CompiledDelivery {
   plan: ImplementPlan;
@@ -371,7 +320,9 @@ function normalizeArtifactBindings(
     paths.add(binding.path);
     return { path: binding.path, rawSha256: binding.rawSha256 };
   });
-  return normalized.sort((left, right) => left.path.localeCompare(right.path));
+  return normalized.sort((left, right) =>
+    compareCanonicalStrings(left.path, right.path),
+  );
 }
 
 function requireReceiptIdentity(
@@ -405,7 +356,41 @@ function normalizeGateProof(value: GateApprovalProof): GateApprovalProof {
   return structuredClone(value);
 }
 
-function parseCanonicalReceipt<T>(bytes: Uint8Array, code: string): T {
+export interface DeliveryReadOptions {
+  /** Only the proof-bound delivery loader may admit historical collection ordering. */
+  allowLegacyOrder?: boolean;
+}
+
+const legacyPlans = new WeakMap<object, string>();
+
+function unorderedIdentity(value: unknown): string {
+  if (Array.isArray(value))
+    return `[${value.map(unorderedIdentity).sort().join(",")}]`;
+  if (isRecord(value))
+    return `{${Object.entries(value)
+      .sort(([a], [b]) => compareCanonicalStrings(a, b))
+      .map(
+        ([key, entry]) => `${JSON.stringify(key)}:${unorderedIdentity(entry)}`,
+      )
+      .join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+}
+
+function sameNormalized(
+  left: unknown,
+  right: unknown,
+  options: DeliveryReadOptions,
+): boolean {
+  return options.allowLegacyOrder
+    ? unorderedIdentity(left) === unorderedIdentity(right)
+    : canonicalJson(left) === canonicalJson(right);
+}
+
+function parseCanonicalReceipt<T>(
+  bytes: Uint8Array,
+  code: string,
+  options: DeliveryReadOptions = {},
+): T {
   const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
   let parsed: unknown;
   try {
@@ -413,7 +398,11 @@ function parseCanonicalReceipt<T>(bytes: Uint8Array, code: string): T {
   } catch {
     throw new Error(code);
   }
-  if (`${canonicalJson(parsed)}\n` !== text) throw new Error(code);
+  if (
+    `${canonicalJson(parsed)}\n` !== text &&
+    (!options.allowLegacyOrder || `${JSON.stringify(parsed)}\n` !== text)
+  )
+    throw new Error(code);
   return parsed as T;
 }
 
@@ -438,10 +427,14 @@ export function compileGateAReceipt(input: {
   };
 }
 
-export function parseGateAReceipt(bytes: Uint8Array): GateAReceipt {
+export function parseGateAReceipt(
+  bytes: Uint8Array,
+  options: DeliveryReadOptions = {},
+): GateAReceipt {
   const receipt = parseCanonicalReceipt<GateAReceipt>(
     bytes,
     "gate-a-receipt-invalid",
+    options,
   );
   if (
     !isRecord(receipt) ||
@@ -455,8 +448,8 @@ export function parseGateAReceipt(bytes: Uint8Array): GateAReceipt {
   const approval = normalizeGateProof(receipt.approval);
   const artifacts = normalizeArtifactBindings(receipt.artifacts);
   if (
-    canonicalJson(approval) !== canonicalJson(receipt.approval) ||
-    canonicalJson(artifacts) !== canonicalJson(receipt.artifacts)
+    !sameNormalized(approval, receipt.approval, options) ||
+    !sameNormalized(artifacts, receipt.artifacts, options)
   ) {
     throw new Error("gate-a-receipt-invalid");
   }
@@ -537,10 +530,14 @@ export function compileReadyReceipt(input: {
   };
 }
 
-export function parseReadyReceipt(bytes: Uint8Array): ReadyReceipt {
+export function parseReadyReceipt(
+  bytes: Uint8Array,
+  options: DeliveryReadOptions = {},
+): ReadyReceipt {
   const receipt = parseCanonicalReceipt<ReadyReceipt>(
     bytes,
     "delivery-receipt-invalid",
+    options,
   );
   if (
     !isRecord(receipt) ||
@@ -592,9 +589,9 @@ export function parseReadyReceipt(bytes: Uint8Array): ReadyReceipt {
   const traceability = normalizeTraceability(receipt.traceability);
   if (
     gateB.contractHash !== receipt.plan.canonicalHash ||
-    canonicalJson(gateB) !== canonicalJson(receipt.approvals.gateB) ||
-    canonicalJson(artifacts) !== canonicalJson(receipt.artifacts) ||
-    canonicalJson(traceability) !== canonicalJson(receipt.traceability)
+    !sameNormalized(gateB, receipt.approvals.gateB, options) ||
+    !sameNormalized(artifacts, receipt.artifacts, options) ||
+    !sameNormalized(traceability, receipt.traceability, options)
   ) {
     throw new Error("delivery-receipt-invalid");
   }
@@ -602,12 +599,14 @@ export function parseReadyReceipt(bytes: Uint8Array): ReadyReceipt {
 }
 
 function sortStrings(values: readonly string[]): string[] {
-  return [...values].sort((left, right) => left.localeCompare(right));
+  return [...values].sort((left, right) =>
+    compareCanonicalStrings(left, right),
+  );
 }
 
 function sortCanonical<T>(values: readonly T[]): T[] {
   return [...values].sort((left, right) =>
-    canonicalJson(left).localeCompare(canonicalJson(right)),
+    compareCanonicalStrings(canonicalJson(left), canonicalJson(right)),
   );
 }
 
@@ -628,7 +627,7 @@ function normalizeVerification(
   return cloned;
 }
 
-function normalizePhase(value: unknown): PlanPhaseDraft {
+function normalizePhase(value: unknown, readOnly = false): PhaseBoundary {
   if (
     !isRecord(value) ||
     !exactKeys(value, [
@@ -651,7 +650,7 @@ function normalizePhase(value: unknown): PlanPhaseDraft {
   }
   const write = sortStrings(value.write as string[]);
   const deletions = sortStrings(value.delete as string[]);
-  if (write.length + deletions.length === 0) {
+  if (!readOnly && write.length + deletions.length === 0) {
     throw new Error("delivery-plan-empty-phase-boundary");
   }
   if (write.some((candidate) => deletions.includes(candidate))) {
@@ -724,7 +723,12 @@ function normalizeTask(value: unknown): PlanTaskDraft {
       candidate: unknown,
     ) => {
       try {
-        return normalizePhase(candidate);
+        return normalizePhase(
+          candidate,
+          phase === "red" &&
+            value.verificationMode !== undefined &&
+            value.verificationMode !== "behavior",
+        );
       } catch (error) {
         throw asPlanValidationError(error, {
           ...context,
@@ -758,8 +762,8 @@ function normalizeTask(value: unknown): PlanTaskDraft {
         searchEvidence: sortStrings(cloned.impactClosure.searchEvidence),
         relatedTests: [...cloned.impactClosure.relatedTests].sort(
           (left, right) =>
-            left.path.localeCompare(right.path) ||
-            left.disposition.localeCompare(right.disposition),
+            compareCanonicalStrings(left.path, right.path) ||
+            compareCanonicalStrings(left.disposition, right.disposition),
         ),
         affectedSuite: sortStrings(cloned.impactClosure.affectedSuite),
       },
@@ -770,7 +774,7 @@ function normalizeTask(value: unknown): PlanTaskDraft {
 }
 
 function graphFromPlan(plan: ImplementPlan): ImplementGraphBoundary {
-  const stripPhase = (phase: PlanPhaseDraft): PhaseBoundary => ({
+  const stripPhase = (phase: PhaseBoundary): PhaseBoundary => ({
     read: phase.read,
     write: phase.write,
     delete: phase.delete,
@@ -936,7 +940,7 @@ function normalizeAgentsCheckpointOperations(
             : normalizeAgentsManagedBlock(operation.managedBlock),
       };
     })
-    .sort((left, right) => left.target.localeCompare(right.target));
+    .sort((left, right) => compareCanonicalStrings(left.target, right.target));
 }
 
 function normalizeVerificationPlan(value: unknown): PlanVerification {
@@ -1059,6 +1063,7 @@ function normalizeTracking(value: unknown): PlanTracking {
 }
 
 function normalizeDraft(value: unknown): ImplementPlan {
+  value = structuredClone(value);
   if (
     !isRecord(value) ||
     !exactKeys(value, [
@@ -1067,6 +1072,7 @@ function normalizeDraft(value: unknown): ImplementPlan {
       "outputs",
       "verification",
       "tracking",
+      ...(value.changeContract === undefined ? [] : ["changeContract"]),
     ]) ||
     typeof value.changeId !== "string" ||
     !CHANGE_NAME.test(value.changeId) ||
@@ -1075,9 +1081,26 @@ function normalizeDraft(value: unknown): ImplementPlan {
   ) {
     throw new Error("delivery-plan-invalid");
   }
+  const source = value;
+  const taskDrafts = value.tasks.map((task: unknown) => {
+    if (
+      !isRecord(task) ||
+      !["mechanical", "refactor"].includes(String(task.verificationMode))
+    )
+      return task;
+    if (!isRecord(task.phases) || !isRecord(task.phases.green))
+      throw new Error("delivery-plan-invalid-task-phases");
+    if (!source.changeContract)
+      throw new Error("change-contract-verification-mode-required");
+    const green = task.phases.green;
+    return {
+      ...task,
+      phases: { ...task.phases, red: { ...green, write: [], delete: [] } },
+    };
+  });
   const draftGraph = validateImplementGraphBoundary({
     changeId: value.changeId,
-    tasks: value.tasks.map((candidate) => {
+    tasks: taskDrafts.map((candidate) => {
       if (!isRecord(candidate)) return candidate;
       const {
         affectedVerification: _affectedVerification,
@@ -1091,16 +1114,21 @@ function normalizeDraft(value: unknown): ImplementPlan {
   if (!draftGraph.ok) {
     throw new DesignPlanValidationError(
       `delivery-plan-invalid:${draftGraph.reason}`,
-      [draftGraph.diagnostic],
+      draftGraph.diagnostics ?? [draftGraph.diagnostic],
     );
   }
   const plan: ImplementPlan = {
+    ...(value.changeContract === undefined
+      ? {}
+      : { changeContract: normalizeChangeContract(value.changeContract) }),
     changeId: value.changeId,
-    tasks: value.tasks
+    tasks: taskDrafts
       .map(normalizeTask)
-      .sort((left, right) => left.taskId.localeCompare(right.taskId)),
+      .sort((left, right) =>
+        compareCanonicalStrings(left.taskId, right.taskId),
+      ),
     outputs: (structuredClone(value.outputs) as ImplementGraphOutput[]).sort(
-      (left, right) => left.id.localeCompare(right.id),
+      (left, right) => compareCanonicalStrings(left.id, right.id),
     ),
     verification: normalizeVerificationPlan(value.verification),
     tracking: normalizeTracking(value.tracking),
@@ -1141,6 +1169,11 @@ function normalizeDraft(value: unknown): ImplementPlan {
   ) {
     throw new Error("delivery-agents-checkpoint-mismatch");
   }
+  if (plan.changeContract)
+    assertPlanWithinChangeContract(plan.changeContract, plan.tasks, [
+      plan.verification.change.fullSuite,
+      plan.verification.change.postApply,
+    ]);
   const graphValidation = validateImplementGraphBoundary(graphFromPlan(plan));
   if (!graphValidation.ok) {
     throw new DesignPlanValidationError(
@@ -1151,26 +1184,83 @@ function normalizeDraft(value: unknown): ImplementPlan {
   return plan;
 }
 
+const TASK_BINDINGS_START = "<!-- ABEL:VERIFICATION-BINDINGS:START -->";
+const TASK_BINDINGS_END = "<!-- ABEL:VERIFICATION-BINDINGS:END -->";
+
+function taskVerificationRegion(markdown: string) {
+  const markers = markdown.match(/<!-- ABEL:VERIFICATION-BINDINGS/gu) ?? [];
+  if (markers.length === 0) return undefined;
+  const match =
+    /^<!-- ABEL:VERIFICATION-BINDINGS:START -->\r?\n[\s\S]*?^<!-- ABEL:VERIFICATION-BINDINGS:END -->(?=\r?$)/mu.exec(
+      markdown,
+    );
+  if (markers.length !== 2 || !match) {
+    throw new DesignPlanValidationError("traceability-managed-region-invalid", [
+      { code: "traceability-managed-region-invalid", path: "tasks.md" },
+    ]);
+  }
+  return {
+    start: match.index,
+    end: match.index + match[0].length,
+    text: match[0],
+  };
+}
+
+// Only identity bindings are generated. Author task checkboxes and Scenario
+// ownership remain outside this region and are validated independently.
 function renderTasks(plan: ImplementPlan): string {
-  const lines = ["# Implementation tasks", ""];
-  for (const task of plan.tasks) {
-    lines.push(`- [ ] ${task.taskId} — ${task.objective}`);
+  const lines = [TASK_BINDINGS_START, "## Compiled verification bindings", ""];
+  for (const task of [...plan.tasks].sort((a, b) =>
+    compareCanonicalStrings(a.taskId, b.taskId),
+  )) {
     lines.push(
-      `  - Depends on: ${task.dependsOn.length > 0 ? task.dependsOn.join(", ") : "[]"}`,
+      `- Task \`${task.taskId}\` (${task.verificationMode ?? "behavior"})`,
     );
-    lines.push(`  - Red verification: ${task.phases.red.verification.id}`);
-    lines.push(`  - Green verification: ${task.phases.green.verification.id}`);
+    if (!task.verificationMode || task.verificationMode === "behavior") {
+      lines.push(`  - Red: \`${task.phases.red.verification.id}\``);
+    }
+    lines.push(`  - Green: \`${task.phases.green.verification.id}\``);
+    if (task.phases.refactor) {
+      lines.push(`  - Refactor: \`${task.phases.refactor.verification.id}\``);
+    }
   }
-  lines.push("");
+  lines.push(TASK_BINDINGS_END);
   return lines.join("\n");
 }
 
+export function bindTaskVerifications(
+  markdown: string,
+  plan: ImplementPlan,
+): string {
+  const region = taskVerificationRegion(markdown);
+  const bindings = renderTasks(plan);
+  if (region) {
+    return (
+      markdown.slice(0, region.start) + bindings + markdown.slice(region.end)
+    );
+  }
+  return `${markdown}${markdown.endsWith("\n") ? "\n" : "\n\n"}${bindings}\n`;
+}
+
 export function compileImplementPlan(
   draft: unknown,
-  options: { consumerRoot: string },
+  options: { consumerRoot: string; bindExecutionInputs?: boolean },
 ): CompiledDelivery {
   try {
-    const plan = normalizeDraft(draft);
+    // Resolve omitted manifest command bytes before named definitions are
+    // validated and purpose identities are hashed. The second pass below
+    // binds execution inputs on the expanded contracts with their final IDs.
+    if (options.bindExecutionInputs)
+      draft = bindDraftVerificationInputs(options.consumerRoot, draft);
+    draft = expandPlanDraft(draft);
+    if (options.bindExecutionInputs)
+      draft = bindDraftVerificationInputs(options.consumerRoot, draft);
+    draft = preparePlanDraft(draft);
+    const normalized = normalizeDraft(draft);
+    const plan =
+      isRecord(draft) && legacyPlans.get(draft) === JSON.stringify(draft)
+        ? (draft as unknown as ImplementPlan)
+        : normalized;
     const graph = graphFromPlan(plan);
     const readiness = assessImplementGraphReadiness(
       options.consumerRoot,
@@ -1217,7 +1307,10 @@ export function compileImplementPlan(
   }
 }
 
-export function parseImplementPlan(bytes: Uint8Array): ImplementPlan {
+export function parseImplementPlan(
+  bytes: Uint8Array,
+  options: DeliveryReadOptions = {},
+): ImplementPlan {
   const text = new TextDecoder().decode(bytes);
   let parsed: unknown;
   try {
@@ -1226,8 +1319,15 @@ export function parseImplementPlan(bytes: Uint8Array): ImplementPlan {
     throw new Error("delivery-plan-json-invalid");
   }
   const normalized = normalizeDraft(parsed);
-  if (`${canonicalJson(normalized)}\n` !== text) {
+  if (`${canonicalJson(normalized)}\n` === text) return normalized;
+  if (
+    !options.allowLegacyOrder ||
+    `${canonicalJson(parsed)}\n` !== text ||
+    !sameNormalized(normalized, parsed, options)
+  ) {
     throw new Error("delivery-plan-not-canonical");
   }
-  return normalized;
+  // Keep proof-bound historical bytes unchanged; a mutation invalidates this association.
+  legacyPlans.set(parsed as object, JSON.stringify(parsed));
+  return parsed as ImplementPlan;
 }

package/src/delivery-revision.ts

@@ -0,0 +1,42 @@
+import type { ImplementPlan } from "./implement-plan.ts";
+import {
+  deliveryBoundPaths,
+  type EngineTaskRow,
+  taskApprovalBoundary,
+} from "./workflow-policy.ts";
+/** Compare authority only; retained bytes still require executor currentness and replay. */
+export function compareDeliveryRevision(
+  priorPlan: ImplementPlan | undefined,
+  nextPlan: ImplementPlan,
+  priorRows: readonly Pick<EngineTaskRow, "task_id">[],
+) {
+  const priorTasks = new Map(
+    (priorPlan?.tasks ?? []).map((task) => [task.taskId, task]),
+  );
+  const nextTasks = new Map(nextPlan.tasks.map((task) => [task.taskId, task]));
+  const priorBoundPaths = new Set(
+    priorPlan ? deliveryBoundPaths(priorPlan) : [],
+  );
+  const boundaryExpanded = deliveryBoundPaths(nextPlan).some(
+    (relative) => !priorBoundPaths.has(relative),
+  );
+  const compatible = new Set<string>();
+  if (priorPlan) {
+    for (const [taskId, priorTask] of priorTasks) {
+      const nextTask = nextTasks.get(taskId);
+      if (
+        nextTask &&
+        taskApprovalBoundary(priorPlan, priorTask) ===
+          taskApprovalBoundary(nextPlan, nextTask)
+      ) {
+        compatible.add(taskId);
+      }
+    }
+  }
+  const invalidated = new Set(
+    priorRows
+      .filter((row) => !compatible.has(row.task_id))
+      .map((row) => row.task_id),
+  );
+  return { compatible, invalidated, boundaryExpanded };
+}