Example Integrations

import { ATFSession, ContinuityStatus, HALTError } from "@atf-protocol/sdk";

  const session = new ATFSession({ dr, tar });

  async function checkContinuity(): Promise {
    const snap = await session.sampleCES({
      cesTemporal: session.remainingTTLPercent(),
      cesBudget: session.remainingBudgetPercent(),
      cesContext: 100 - session.contextDriftPercent(),
      cesIntegrity: session.chainIntegrityPercent(),
    });
    // Formula: CES = T×0.30 + B×0.30 + D×0.20 + I×0.20 (RGC-INV-001 — immutable)
    const rcr = await session.commitRCR(snap);
    console.log(`CES: ${rcr.cesScore.toFixed(1)} — ${rcr.continuityStatus}`);

    if (rcr.continuityStatus === ContinuityStatus.HALT) {
      throw new HALTError(rcr); // RGC-INV-003 — execution must cease
    }
    return rcr.cesScore >= 50;  // NOMINAL or MONITORING
  }

  // Guard every execution with a CES check
  for (const decision of pendingDecisions) {
    const ok = await checkContinuity().catch((err) => {
      if (err instanceof HALTError) { haltExecution(err.rcr); return false; }
      throw err;
    });
    if (ok) await executeDecision(decision);
    else     await escalateToOperator(decision);
  }

package main

  import (
      "errors"
      atf "github.com/atf-protocol/sdk-go"
  )

  func monitorAndExecute(session *atf.Session, decisions []Decision) error {
      for _, d := range decisions {
          snap := atf.CESSnapshot{
              CesTemporal:  session.RemainingTTLPercent(),
              CesBudget:    session.RemainingBudgetPercent(),
              CesContext:   100 - session.ContextDriftPercent(),
              CesIntegrity: session.ChainIntegrityPercent(),
          }
          // CES = T*0.30 + B*0.30 + D*0.20 + I*0.20 — RGC-INV-001
          rcr, err := session.CommitRCR(snap)
          if err != nil {
              return fmt.Errorf("RCR commit: %w", err)
          }

          var haltErr *atf.HALTError
          if errors.As(err, &haltErr) {
              // RGC-INV-003: CES < 10.0 — execution MUST cease
              return fmt.Errorf("HALT: CES %.1f, RCR: %s", rcr.CESScore, rcr.RCRID)
          }

          if rcr.ContinuityStatus == atf.StatusNominal ||
             rcr.ContinuityStatus == atf.StatusMonitoring {
              if err := executeDecision(d); err != nil {
                  return err
              }
          }
      }
      return nil
  }

import { ForensicExporter, ExportAuthorization, OEPBundle } from "@atf-protocol/sdk";
  import { writeFileSync } from "fs";

  const exporter = new ForensicExporter({
    platformPrivateKeyB64: process.env.ATF_PRIVATE_KEY_B64!,
    // Caller keys are never embedded in OEP (FEA-INV-003, FEA-INV-005)
  });

  const auth: ExportAuthorization = {
    authorizedBy: "HUMAN-harold-nunes-001",
    scope: "session_id:SESSION-20260516-001",
    purpose: "DFSA regulatory audit 2026-Q2",
    exportFormat: "OEP_V1",
  };

  const bundle: OEPBundle = await exporter.export({
    sessionId: "SESSION-20260516-001",
    authorization: auth,
    includeRCRs: true,
    includeTARs: true,
    includeDRs: true,
  });

  // Self-contained — verifiable with only the platform public key (OEP-INV-002)
  console.log(`Package: ${bundle.packageId}`);
  console.log(`Items: ${bundle.itemCount}`);
  console.log(`Merkle: ${bundle.merkleRoot.slice(0, 32)}...`);

  writeFileSync("export_DFSA_2026Q2.oep.json", JSON.stringify(bundle.toJSON(), null, 2));
  console.log(`Saved: export_DFSA_2026Q2.oep.json (${bundle.sizeBytes.toLocaleString()} bytes)`);

package main

  import (
      "encoding/json"
      "os"
      atf "github.com/atf-protocol/sdk-go"
  )

  func exportForRegulator(sessionID string) error {
      exporter, _ := atf.NewForensicExporter(atf.ExporterConfig{
          PlatformPrivateKeyB64: os.Getenv("ATF_PRIVATE_KEY_B64"),
          // Caller keys never embedded (FEA-INV-003, FEA-INV-005)
      })

      auth := atf.ExportAuthorization{
          AuthorizedBy: "HUMAN-harold-nunes-001",
          Scope:        "session_id:" + sessionID,
          Purpose:      "DFSA regulatory audit 2026-Q2",
      }

      bundle, err := exporter.Export(atf.ExportConfig{
          SessionID:     sessionID,
          Authorization: auth,
          IncludeRCRs:  true,
          IncludeTARs:  true,
          IncludeDRs:   true,
      })
      if err != nil {
          return fmt.Errorf("export: %w", err)
      }

      data, _ := json.MarshalIndent(bundle, "", "  ")
      if err := os.WriteFile("export_DFSA_2026Q2.oep.json", data, 0600); err != nil {
          return err
      }
      fmt.Printf("OEP: %s (%d items, %d bytes)\n", bundle.PackageID, bundle.ItemCount, bundle.SizeBytes)
      return nil
  }

import { OEPVerifier, OEPBundle, TwoPlaneResult } from "@atf-protocol/sdk";
  import { readFileSync } from "fs";

  const verifier = new OEPVerifier(PLATFORM_PUBLIC_KEY_B64);
  // No network — only receipt JSON + public key (ATF-INV-006)

  const raw = readFileSync("export_DFSA_2026Q2.oep.json", "utf-8");
  const bundle = OEPBundle.fromJSON(JSON.parse(raw));

  // FVP-INV-007: Two independent verification planes
  const result: TwoPlaneResult = await verifier.verifyFull(bundle);

  if (result.finalVerdict !== "PASS") {
    const failures = result.failures.map(f => `  - ${f.invariant}: ${f.detail}`).join("\n");
    throw new Error(`OEP verification FAIL:\n${failures}`);
  }

  console.log(`✓ ${bundle.itemCount} items verified (crypto + semantic planes)`);

verifier := atf.NewOEPVerifier(platformPublicKeyB64)
  bundle, _ := atf.LoadOEPBundle("export_DFSA_2026Q2.oep.json")

  // Two-plane verification — FVP-INV-007
  result, err := verifier.VerifyFull(bundle)
  if err != nil { log.Fatal(err) }

  if result.FinalVerdict != atf.VerdictPass {
      for _, f := range result.Failures {
          fmt.Printf("FAIL %s: %s\n", f.Invariant, f.Detail)
      }
      os.Exit(1)
  }
  fmt.Printf("✓ %d items verified offline\n", bundle.ItemCount)