@abelxiaoxing/cadence 1.2.4 → 1.4.0

package/src/design-journal.ts

@@ -1,11 +1,18 @@
 import { createHash, randomUUID } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
+import { compareCanonicalStrings } from "./canonical.ts";
+import {
+  type ChangeContract,
+  normalizeChangeContract,
+} from "./change-contract.ts";
 import {
   type DesignEvidenceResult,
   validateEvidenceResult,
 } from "./contracts.ts";
 import { canonicalJson } from "./run-state.ts";
+import { configureSqlite, ensureSqliteSchema } from "./sqlite-schema.ts";
 import { prepareStateRoot, type ResolvedStateRoot } from "./state-root.ts";
+import { DESIGN_SCHEMA as SCHEMA } from "./storage-schema.ts";
 
 const SHA256 = /^[a-f0-9]{64}$/u;
 const IDENTIFIER = /^[a-z0-9](?:[a-z0-9._:-]{0,126}[a-z0-9])?$/iu;
@@ -13,51 +20,6 @@ const ZERO_HASH = "0".repeat(64);
 const MAX_PLAN_BYTES = 16 * 1024 * 1024;
 const MAX_CONTRACT_BYTES = 256 * 1024;
 
-const SCHEMA = `
-  CREATE TABLE IF NOT EXISTS design_facts (
-    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-    sequence INTEGER NOT NULL,
-    kind TEXT NOT NULL,
-    identity TEXT NOT NULL,
-    payload_json TEXT NOT NULL,
-    canonical_hash TEXT NOT NULL,
-    prior_record_hash TEXT NOT NULL,
-    record_hash TEXT NOT NULL,
-    PRIMARY KEY (run_id, sequence),
-    UNIQUE (run_id, kind, identity),
-    UNIQUE (run_id, record_hash)
-  ) STRICT;
-
-  CREATE TABLE IF NOT EXISTS design_operations (
-    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-    operation_id TEXT NOT NULL,
-    operation TEXT NOT NULL,
-    request_hash TEXT NOT NULL,
-    outcome_json TEXT NOT NULL,
-    PRIMARY KEY (run_id, operation_id)
-  ) STRICT;
-
-  CREATE TABLE IF NOT EXISTS design_compiled_plans (
-    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
-    revision INTEGER NOT NULL,
-    fact_sequence INTEGER NOT NULL,
-    raw_sha256 TEXT NOT NULL,
-    canonical_hash TEXT NOT NULL,
-    plan_bytes BLOB NOT NULL,
-    PRIMARY KEY (run_id, revision),
-    UNIQUE (run_id, fact_sequence),
-    FOREIGN KEY (run_id, fact_sequence)
-      REFERENCES design_facts(run_id, sequence) ON DELETE CASCADE
-  ) STRICT;
-
-  CREATE TABLE IF NOT EXISTS design_finalization_leases (
-    run_id TEXT PRIMARY KEY REFERENCES runs(run_id) ON DELETE CASCADE,
-    operation_id TEXT NOT NULL,
-    token TEXT NOT NULL UNIQUE,
-    expires_at INTEGER NOT NULL
-  ) STRICT;
-`;
-
 type DecisionCategory = "behavior" | "technical";
 type DesignGate = "gate-a" | "gate-b";
 
@@ -151,6 +113,7 @@ export interface DesignGateProjection {
 }
 
 export interface DesignStatusProjection {
+  changeContract?: ChangeContract;
   runId: string;
   change?: string;
   evidence: DesignEvidenceProjection[];
@@ -283,7 +246,9 @@ function normalizeRefs(refs: readonly string[]): string[] {
   ) {
     throw new Error("design-decision-refs-invalid");
   }
-  return [...new Set(refs)].sort((left, right) => left.localeCompare(right));
+  return [...new Set(refs)].sort((left, right) =>
+    compareCanonicalStrings(left, right),
+  );
 }
 
 export class DesignJournal {
@@ -318,11 +283,8 @@ export class DesignJournal {
     const stateRoot = prepareStateRoot(unresolved);
     const database = new DatabaseSync(stateRoot.databasePath);
     try {
-      database.exec("PRAGMA foreign_keys = ON");
-      database.exec("PRAGMA journal_mode = WAL");
-      database.exec("PRAGMA synchronous = FULL");
-      database.exec("PRAGMA busy_timeout = 5000");
-      database.exec(SCHEMA);
+      configureSqlite(database);
+      ensureSqliteSchema(database, SCHEMA);
       return new DesignJournal(stateRoot, database, options);
     } catch (error) {
       try {
@@ -868,10 +830,10 @@ export class DesignJournal {
           }))
           .sort(
             (left, right) =>
-              left.path.localeCompare(right.path) ||
+              compareCanonicalStrings(left.path, right.path) ||
               left.lineStart - right.lineStart ||
               left.lineEnd - right.lineEnd ||
-              left.claimHash.localeCompare(right.claimHash),
+              compareCanonicalStrings(left.claimHash, right.claimHash),
           ),
       };
       const fact = this.#appendFact(
@@ -954,6 +916,7 @@ export class DesignJournal {
           revision,
           contractHash: decisionContractHash,
           refs,
+          authorityChanged: prior?.contractHash !== decisionContractHash,
         };
         const fact = this.#appendFact(
           input.runId,
@@ -1019,7 +982,7 @@ export class DesignJournal {
           runId: string;
           operationId: string;
           gate: "gate-a";
-          contract: string;
+          contract: string | ChangeContract;
         }
       | {
           runId: string;
@@ -1035,9 +998,18 @@ export class DesignJournal {
     if (input.gate !== "gate-a" && input.gate !== "gate-b") {
       throw new Error("design-gate-invalid");
     }
+    const changeContract =
+      input.gate === "gate-a" && typeof input.contract !== "string"
+        ? normalizeChangeContract(input.contract)
+        : undefined;
     const gateAContractHash =
       input.gate === "gate-a"
-        ? contractHash("abel-design-gate-a", input.contract)
+        ? contractHash(
+            "abel-design-gate-a",
+            changeContract
+              ? canonicalJson(changeContract)
+              : (input.contract as string),
+          )
         : undefined;
     return this.#transaction(() => {
       this.#run(input.runId, true);
@@ -1062,9 +1034,9 @@ export class DesignJournal {
         if (!current.gateA.current) throw new Error("design-gate-a-required");
         const plan = this.#currentPlanProjection(input.runId);
         if (!plan) throw new Error("design-plan-required");
-        const latestDecisionSequence = this.#facts(input.runId)
-          .filter((fact) => fact.kind === "decision")
-          .at(-1)?.sequence;
+        const latestDecisionSequence = this.#latestSubstantiveDecisionSequence(
+          input.runId,
+        );
         if (
           plan.sequence <= (current.gateA.approvedSequence ?? 0) ||
           (latestDecisionSequence !== undefined &&
@@ -1093,6 +1065,7 @@ export class DesignJournal {
           gate: input.gate,
           revision,
           contractHash: approvedContractHash,
+          ...(changeContract ? { changeContract } : {}),
         };
         const fact = this.#appendFact(
           input.runId,
@@ -1148,6 +1121,20 @@ export class DesignJournal {
     return undefined;
   }
 
+  #certifyPlan(runId: string, planHash: string): void {
+    const gates = this.#gateStatus(runId);
+    if (gates.gateB.current && gates.gateB.proof?.contractHash === planHash)
+      return;
+    const previous = this.#latestApproval(runId, "gate-b");
+    const revision = (previous?.proof.revision ?? 0) + 1;
+    this.#appendFact(runId, "approval", `gate-b:${revision}`, {
+      gate: "gate-b",
+      revision,
+      contractHash: planHash,
+      authority: "compiler",
+    });
+  }
+
   recordCompiledPlan(input: {
     runId: string;
     operationId: string;
@@ -1155,6 +1142,7 @@ export class DesignJournal {
     rawSha256: string;
     canonicalHash: string;
     lease?: DesignFinalizationLease;
+    certify?: boolean;
   }): Record<string, unknown> {
     requireHash(input.rawSha256, "design-plan-raw-hash");
     requireHash(input.canonicalHash, "design-plan-canonical-hash");
@@ -1193,6 +1181,32 @@ export class DesignJournal {
         throw new Error("design-gate-a-required");
       }
       const prior = this.#currentPlanProjection(input.runId);
+      const status = this.status(input.runId);
+      const latestDecision =
+        this.#latestSubstantiveDecisionSequence(input.runId) ?? 0;
+      if (
+        prior &&
+        prior.rawSha256 === input.rawSha256 &&
+        prior.canonicalHash === input.canonicalHash &&
+        prior.sequence > latestDecision &&
+        prior.sequence > (status.gates.gateA.approvedSequence ?? 0)
+      ) {
+        if (input.certify) this.#certifyPlan(input.runId, input.canonicalHash);
+        const outcome = {
+          operation: "compile-plan",
+          runId: input.runId,
+          plan: prior,
+          gates: this.#gateStatus(input.runId),
+        };
+        this.#recordOperation(
+          input.runId,
+          input.operationId,
+          "compile-plan",
+          request,
+          outcome,
+        );
+        return structuredClone(outcome);
+      }
       const revision = (prior?.revision ?? 0) + 1;
       const payload = {
         revision,
@@ -1227,6 +1241,7 @@ export class DesignJournal {
         recordHash: fact.record_hash,
         sequence: fact.sequence,
       };
+      if (input.certify) this.#certifyPlan(input.runId, input.canonicalHash);
       const outcome = {
         operation: "compile-plan",
         runId: input.runId,
@@ -1511,26 +1526,34 @@ export class DesignJournal {
     });
   }
 
-  #gateStatus(runId: string): DesignStatusProjection["gates"] {
-    const facts = this.#facts(runId);
-    const latestBehavior = facts
+  #latestSubstantiveDecisionSequence(
+    runId: string,
+    category?: DecisionCategory,
+  ): number | undefined {
+    return this.#facts(runId)
       .filter((fact) => {
         if (fact.kind !== "decision") return false;
-        return (
-          parseRecord(fact.payload_json, "design-decision-record-invalid")
-            .category === "behavior"
+        const decision = parseRecord(
+          fact.payload_json,
+          "design-decision-record-invalid",
         );
-      })
-      .at(-1)?.sequence;
-    const latestTechnical = facts
-      .filter((fact) => {
-        if (fact.kind !== "decision") return false;
         return (
-          parseRecord(fact.payload_json, "design-decision-record-invalid")
-            .category === "technical"
+          decision.authorityChanged !== false &&
+          (category === undefined || decision.category === category)
         );
       })
       .at(-1)?.sequence;
+  }
+
+  #gateStatus(runId: string): DesignStatusProjection["gates"] {
+    const latestBehavior = this.#latestSubstantiveDecisionSequence(
+      runId,
+      "behavior",
+    );
+    const latestTechnical = this.#latestSubstantiveDecisionSequence(
+      runId,
+      "technical",
+    );
     const plan = this.#currentPlanProjection(runId);
     const gateAApproval = this.#latestApproval(runId, "gate-a");
     const gateBApproval = this.#latestApproval(runId, "gate-b");
@@ -1587,6 +1610,119 @@ export class DesignJournal {
     return { gateA, gateB };
   }
 
+  /** Seed a new revision only from a completed, privately finalized delivery. */
+  inheritFinalizedAuthority(runId: string): void {
+    this.#transaction(() => {
+      const run = this.#run(runId, true);
+      if (!run.change_name || this.#facts(runId).length > 0) return;
+      const candidates = this.#database
+        .prepare(`
+        SELECT facts.run_id, facts.payload_json FROM design_facts AS facts
+        JOIN runs ON runs.run_id = facts.run_id
+        WHERE runs.root_hash = ? AND runs.stage = 'abel-design'
+          AND runs.change_name = ? AND runs.state = 'completed'
+          AND facts.kind = 'finalization' AND runs.run_id <> ?
+      `)
+        .all(run.root_hash, run.change_name, runId) as unknown as Array<{
+        run_id: string;
+        payload_json: string;
+      }>;
+      const source = candidates
+        .map((row) => ({
+          runId: row.run_id,
+          fact: parseRecord(
+            row.payload_json,
+            "design-finalization-record-invalid",
+          ),
+        }))
+        .sort(
+          (left, right) =>
+            Number(right.fact.deliveryRevision) -
+            Number(left.fact.deliveryRevision),
+        )[0];
+      if (!source) return;
+      const status = this.status(source.runId);
+      const plan = this.currentCompiledPlan(source.runId);
+      const gateA = status.gates.gateA.proof;
+      const gateB = status.gates.gateB.proof;
+      if (
+        !plan ||
+        !gateA ||
+        !gateB ||
+        !status.gates.gateA.current ||
+        !status.gates.gateB.current ||
+        sha256(plan.bytes) !== plan.projection.rawSha256 ||
+        !this.verifyFinalizedDelivery({
+          change: run.change_name,
+          deliveryRevision: Number(source.fact.deliveryRevision),
+          receiptHash: String(source.fact.receiptHash),
+          gateA,
+          gateB,
+          planCanonicalHash: plan.projection.canonicalHash,
+        })
+      ) {
+        throw new Error("design-inherited-authority-invalid");
+      }
+      this.#appendFact(runId, "inheritance", "finalized-authority", {
+        sourceRunId: source.runId,
+        deliveryRevision: source.fact.deliveryRevision,
+        receiptHash: source.fact.receiptHash,
+        gateA,
+        gateB,
+      });
+      for (const decision of status.decisions) {
+        this.#appendFact(
+          runId,
+          "decision",
+          `${decision.decisionId}:${decision.revision}`,
+          {
+            decisionId: decision.decisionId,
+            category: decision.category,
+            revision: decision.revision,
+            contractHash: decision.contractHash,
+            refs: decision.refs,
+          },
+        );
+      }
+      this.#appendFact(runId, "approval", `gate-a:${gateA.revision}`, {
+        gate: "gate-a",
+        revision: gateA.revision,
+        contractHash: gateA.contractHash,
+        ...(status.changeContract
+          ? { changeContract: status.changeContract }
+          : {}),
+      });
+      const projection = plan.projection;
+      const fact = this.#appendFact(
+        runId,
+        "plan",
+        String(projection.revision),
+        {
+          revision: projection.revision,
+          rawSha256: projection.rawSha256,
+          canonicalHash: projection.canonicalHash,
+        },
+      );
+      this.#database
+        .prepare(`INSERT INTO design_compiled_plans(
+        run_id, revision, fact_sequence, raw_sha256, canonical_hash, plan_bytes
+      ) VALUES (?, ?, ?, ?, ?, ?)`)
+        .run(
+          runId,
+          projection.revision,
+          fact.sequence,
+          projection.rawSha256,
+          projection.canonicalHash,
+          Buffer.from(plan.bytes),
+        );
+      this.#appendFact(runId, "approval", `gate-b:${gateB.revision}`, {
+        gate: "gate-b",
+        revision: gateB.revision,
+        contractHash: gateB.contractHash,
+      });
+    });
+  }
+
   status(runId: string): DesignStatusProjection {
     this.#assertOpen();
     const run = this.#run(runId, false);
@@ -1609,12 +1745,20 @@ export class DesignJournal {
       );
       latestDecisions.set(decision.decisionId, decision);
     }
+    const approved = facts
+      .filter((fact) => fact.kind === "approval")
+      .map((fact) => parseRecord(fact.payload_json, "design-approval-invalid"))
+      .filter((fact) => fact.gate === "gate-a")
+      .at(-1);
     return {
       runId,
       ...(run.change_name ? { change: run.change_name } : {}),
+      ...(approved?.changeContract
+        ? { changeContract: normalizeChangeContract(approved.changeContract) }
+        : {}),
       evidence,
       decisions: [...latestDecisions.values()].sort((left, right) =>
-        left.decisionId.localeCompare(right.decisionId),
+        compareCanonicalStrings(left.decisionId, right.decisionId),
       ),
       gates: this.#gateStatus(runId),
       plan: this.#currentPlanProjection(runId) ?? null,