Tessorium Trust Protocol

interface ServiceManifest {
  serviceId: string;           // did:service:provider:name:version
  name: string;
  version: string;
  provider: {
    did: string;
    name: string;
    verified: boolean;
  };
  endpoints: Array<{
    url: string;
    protocol: 'rest' | 'grpc' | 'graphql' | 'websocket';
    region?: string;
    fallback?: boolean;
  }>;
  auth: {
    method: 'oauth2' | 'api_key' | 'mtls' | 'workload_identity';
    tokenEndpoint?: string;
    scopes?: string[];
  };
  sla: {
    availabilityTarget: number;  // 99.9%
    maxLatencyMs: number;        // 500ms
    maxErrorRate: number;        // 0.1%
  };
  compliance: {
    frameworks: string[];        // ['PCI-DSS', 'SOC2', 'HIPAA']
    dataClassification: 'public' | 'internal' | 'confidential' | 'restricted';
    auditRequired: boolean;
  };
  trustRequirements: {
    minCallerTrust: number;      // 60
    minCallerStage: TrustStage;  // 'building'
  };
  signature: string;             // Ed25519 of manifest
}

// Build canonical string for signing
const canonical = [
  method,                    // "POST"
  path,                      // "/v1/charges"
  timestamp,                 // Unix milliseconds
  contentHash,               // SHA-256 of body
  signedHeaders              // "host;content-type;x-tessorium-trace-id"
].join("\n");

// Sign with agent's Ed25519 private key
const signature = Ed25519.sign(canonical, agentPrivateKey);

// Attach headers
headers["X-Tessorium-Timestamp"] = timestamp;
headers["X-Tessorium-Signature"] = base64(signature);
headers["X-Tessorium-Content-Hash"] = contentHash;
headers["X-Tessorium-Signed-Headers"] = "host;content-type;x-tessorium-trace-id";
headers["X-Tessorium-Trace-Id"] = traceId;
headers["X-Tessorium-Deadline"] = deadline;

interface ResourceMetadata {
  resourceId: string;           // "res-customer-pii-001"
  name: string;
  description: string;
  type: 's3' | 'database' | 'file' | 'api' | 'key-value' | 'queue';
  provider: string;             // "aws", "gcp", "postgresql"

  // Classification
  classification: 'public' | 'internal' | 'confidential' | 'restricted';
  specialDataTypes: ('pii' | 'phi' | 'pci' | 'financial' | 'legal' | 'none')[];
  allowedOperations: ('read' | 'write' | 'delete' | 'list' | 'query')[];

  // Location
  location: {
    uri: string;                // "s3://bucket/path" or connection string
    region?: string;            // "us-east-1"
    provider?: string;          // "aws"
  };

  // Access Control
  accessControl: {
    model: 'rbac' | 'abac' | 'pbac';
    roles?: string[];           // ["writer", "admin"]
    policies?: string[];        // SPL policy IDs
  };

  // Retention
  retention: {
    policy: string;             // "7-years", "standard"
    expiresAt?: number;
    legalHold?: boolean;
    deletionApproval?: boolean;
  };

  // Data Residency
  residency?: {
    currentRegion: string;
    allowedRegions: string[];
    prohibitedRegions?: string[];
  };

  // Compliance
  compliance: string[];         // ["GDPR", "HIPAA", "PCI-DSS"]

  // Ownership
  ownership: {
    owner: string;              // Team or individual
    team?: string;
    steward?: string;           // Data steward email
  };

  tags: Record<string, string>;
  schemaVersion: string;
  createdAt: number;
  updatedAt: number;
}

// Default DLP rules applied to all operations
const DEFAULT_DLP_RULES = [
  {
    id: 'dlp-ssn',
    name: 'Social Security Number',
    pattern: '\\b\\d{3}-\\d{2}-\\d{4}\\b',
    severity: 'high',
    action: 'redact'      // Replace with [REDACTED]
  },
  {
    id: 'dlp-credit-card',
    name: 'Credit Card Number',
    pattern: '\\b(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14})\\b',
    severity: 'critical',
    action: 'redact'
  },
  {
    id: 'dlp-api-key',
    name: 'API Key',
    pattern: '\\b(sk_live_|api_key_)[a-zA-Z0-9]{24,}\\b',
    severity: 'critical',
    action: 'block'       // Block entire operation
  },
  {
    id: 'dlp-aws-key',
    name: 'AWS Access Key',
    pattern: '\\bAKIA[0-9A-Z]{16}\\b',
    severity: 'critical',
    action: 'block'
  }
];

// External DLP integration
externalDlpWebhook?: string;  // POST data to external DLP service
externalDlpApiKey?: string;

{
  "@context": ["https://www.w3.org/ns/did/v1", "https://tessorium.io/ns/v1"],
  "id": "did:tessorium:agent:research-assistant:v1",
  "verificationMethod": [{
    "id": "did:tessorium:agent:research-assistant:v1#key-1",
    "type": "Ed25519VerificationKey2020",
    "controller": "did:tessorium:agent:research-assistant:v1",
    "publicKeyMultibase": "z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK"
  }],
  "authentication": ["did:tessorium:agent:research-assistant:v1#key-1"],
  "service": [{
    "id": "did:tessorium:agent:research-assistant:v1#ttp",
    "type": "TTPEndpoint",
    "serviceEndpoint": "https://agent.example.com/.well-known/ttp"
  }]
}

// Constants from src/lib/trust/calculator.ts
const MAX_IDENTITY_SCORE = 40;    // Cryptographic verification
const MAX_REPUTATION_SCORE = 35;  // Peer attestations
const MAX_BEHAVIORAL_SCORE = 25;  // System-observed metrics

function calculateTrustScore(
  identityVerified: boolean,
  attestations: Attestation[],
  behavioralMetrics: BehavioralMetrics
): TrustReport {
  // Identity Score (0 or 40): Ed25519 challenge-response
  const identityScore = identityVerified ? MAX_IDENTITY_SCORE : 0;

  // Reputation Score (0-35): Weighted peer attestations
  let reputationScore = 0;
  if (attestations.length > 0) {
    for (const attestation of attestations) {
      const issuerWeight = getIssuerTierWeight(attestation.issuer);
      const gamingMultiplier = detectGamingPatterns(attestation);
      reputationScore += applyWeights(attestation.rating, issuerWeight, gamingMultiplier);
    }
    reputationScore = Math.min(reputationScore, MAX_REPUTATION_SCORE);
  }

  // Behavioral Score (0-25): System-observed metrics
  const behavioralScore = calculateBehavioralScore(behavioralMetrics);
  // Components: policyCompliance(30%), uptime(20%), errorRate(15%),
  //             latency(10%), securityEvents(15%), dataPatterns(10%)

  const totalScore = identityScore + reputationScore + behavioralScore;
  const stage = deriveStageFromScore(totalScore);
  // Stages: unverified(0), provisional(40), new(41-55), building(56-74), established(75+)

  return { totalScore, identityScore, reputationScore, behavioralScore, stage };
}

{
  "version": "1.0",
  "id": "att_a1b2c3d4e5f6",
  "type": "rating",
  "subject": "did:tessorium:agent:target-agent:v1",
  "issuer": "did:tessorium:agent:rating-agent:v1",
  "issuedAt": "2026-02-14T12:00:00Z",
  "trust": {
    "stage": "established",
    "identityVerified": true,
    "reputationLevel": "high"
  },
  "rating": {
    "overall": 4,
    "dimensions": {
      "reliability": 5,    // Task completion rate
      "quality": 4,        // Output accuracy
      "speed": 4,          // Response latency
      "communication": 5,  // Protocol adherence
      "safety": 5          // No harmful outputs
    },
    "wouldWorkAgain": true
  },
  "signature": {
    "algorithm": "Ed25519",
    "keyId": "did:tessorium:agent:rating-agent:v1#key-1",
    "value": "base64url..."
  }
}

{
  "version": "1.0.0",
  "agentDid": "did:tessorium:agent:example:v1",

  "requirements": {
    "minTrustScore": 70,
    "minTrustStage": "building",
    "requiredCapabilities": ["data:read"],
    "requireIdentityVerification": true,
    "purpose": "customer-support"  // GDPR purpose limitation
  },

  "offers": {
    "capabilities": ["data:read", "data:write"],
    "rateLimit": { "requests": 100, "windowMs": 60000 }
  },

  "rules": [
    {
      "id": "rule-example",
      "effect": "allow",
      "resources": ["api/v1/data/*"],
      "actions": ["read"],
      "conditions": {
        "trustScore": { "gte": 50 }
      }
    }
  ],

  "defaultEffect": "deny"  // Zero-trust default
}

{
  "version": "1.0.0",
  "agentDid": "did:tessorium:agent:payment-processor:v1",
  "description": "Payment processing with human approval for high-value transactions",

  "requirements": {
    "minTrustScore": 75,
    "minTrustStage": "established",
    "requiredCapabilities": ["network:external", "data:financial"],
    "requireIdentityVerification": true,
    "compliance": ["PCI-DSS", "SOC2"]
  },

  "offers": {
    "capabilities": ["payment:process", "refund:process"],
    "rateLimit": { "requests": 60, "windowMs": 60000 }
  },

  "rules": [
    {
      "id": "rule-small-payment",
      "effect": "allow",
      "description": "Auto-approve payments under $1,000 for trusted agents",
      "resources": ["api/stripe/v1/charges"],
      "actions": ["create"],
      "conditions": {
        "trustScore": { "gte": 75 },
        "request.amount": { "lte": 1000 },
        "dataClassification": "financial"
      },
      "outputTransformations": {
        "redact": ["card.number", "cvv"]
      }
    },
    {
      "id": "rule-large-payment",
      "effect": "allow_with_approval",
      "description": "Large payments require human approval",
      "resources": ["api/stripe/v1/charges"],
      "actions": ["create"],
      "conditions": {
        "trustScore": { "gte": 80 },
        "request.amount": { "gt": 1000, "lte": 50000 }
      },
      "humanApproval": {
        "required": true,
        "reason": "Large transaction requires compliance review",
        "escalationLevel": 2,
        "timeout": 300,
        "defaultAction": "deny"
      },
      "outputTransformations": {
        "redact": ["card.number", "cvv"]
      }
    },
    {
      "id": "rule-whale-payment",
      "effect": "deny",
      "description": "Payments over $50,000 must use manual process",
      "resources": ["api/stripe/v1/charges"],
      "actions": ["create"],
      "conditions": {
        "request.amount": { "gt": 50000 }
      }
    }
  ],

  "defaultEffect": "deny"
}

{
  "version": "1.0.0",
  "agentDid": "did:tessorium:agent:clinical-assistant:v1",
  "description": "Patient health records with strict HIPAA controls",

  "requirements": {
    "minTrustScore": 80,
    "minTrustStage": "established",
    "requiredCapabilities": ["data:phi"],
    "requireIdentityVerification": true,
    "purpose": "treatment",
    "compliance": ["HIPAA", "HITRUST"]
  },

  "rules": [
    {
      "id": "rule-treatment-access",
      "effect": "allow",
      "description": "Access patient records for treatment during business hours",
      "resources": ["fhir/Patient/*", "fhir/Observation/*"],
      "actions": ["read", "search"],
      "conditions": {
        "trustScore": { "gte": 80 },
        "dataClassification": "phi",
        "timeOfDay": { "between": ["08:00", "18:00"] },
        "dayOfWeek": { "not_in": ["Sat", "Sun"] },
        "purpose": { "eq": "treatment" }
      },
      "audit": {
        "level": "detailed",
        "logPatientId": true,
        "logQuery": true
      }
    },
    {
      "id": "rule-emergency-access",
      "effect": "allow_with_approval",
      "description": "After-hours access requires supervisor override",
      "resources": ["fhir/Patient/*"],
      "actions": ["read"],
      "conditions": {
        "trustScore": { "gte": 75 },
        "timeOfDay": { "not_between": ["08:00", "18:00"] }
      },
      "humanApproval": {
        "required": true,
        "reason": "After-hours access requires supervisor override",
        "escalationLevel": 2,
        "timeout": 900,
        "defaultAction": "deny",
        "requireJustification": true
      },
      "audit": {
        "level": "detailed",
        "alertOnAccess": true
      }
    },
    {
      "id": "rule-research-denied",
      "effect": "deny",
      "description": "Research requires de-identified data only",
      "resources": ["fhir/Patient/*"],
      "actions": ["read"],
      "conditions": {
        "purpose": { "eq": "research" }
      }
    }
  ],

  "outputTransformations": {
    "redact": ["patient.ssn", "patient.address.street"],
    "mask": ["patient.phone", "patient.email"]
  },

  "defaultEffect": "deny"
}

{
  "version": "1.0.0",
  "agentDid": "did:tessorium:agent:legal-research:v1",
  "description": "Legal document review with privilege protection",

  "requirements": {
    "minTrustScore": 70,
    "minTrustStage": "building",
    "requiredCapabilities": ["data:confidential"],
    "requireIdentityVerification": true,
    "purpose": "case-research"
  },

  "rules": [
    {
      "id": "rule-case-documents",
      "effect": "allow",
      "description": "Access documents for assigned cases only",
      "resources": ["s3://legal-docs/case-*"],
      "actions": ["read"],
      "conditions": {
        "trustScore": { "gte": 70 },
        "agent.assignedCases": { "contains": "{resource.caseId}" },
        "dataClassification": "confidential"
      }
    },
    {
      "id": "rule-privileged-documents",
      "effect": "allow_with_approval",
      "description": "Privileged docs require partner approval",
      "resources": ["s3://legal-docs/privileged/*"],
      "actions": ["read"],
      "conditions": {
        "trustScore": { "gte": 80 },
        "agent.role": { "in": ["associate", "partner"] }
      },
      "humanApproval": {
        "required": true,
        "reason": "Privileged document access requires partner review",
        "escalationLevel": 3,
        "timeout": 3600,
        "defaultAction": "deny"
      }
    },
    {
      "id": "rule-external-sharing-blocked",
      "effect": "deny",
      "description": "Prevent external sharing of privileged docs",
      "resources": ["s3://legal-docs/*"],
      "actions": ["download", "share"],
      "conditions": {
        "dataClassification": "privileged"
      }
    }
  ],

  "outputTransformations": {
    "watermark": true,
    "addFooter": "CONFIDENTIAL - Attorney Work Product"
  },

  "defaultEffect": "deny"
}

{
  "version": "1.0.0",
  "agentDid": "did:tessorium:agent:decision-engine:v1",
  "description": "High-risk AI decisions requiring human oversight",

  "requirements": {
    "minTrustScore": 65,
    "minTrustStage": "building",
    "requireIdentityVerification": true,
    "compliance": ["EU-AI-ACT"]
  },

  "rules": [
    {
      "id": "rule-low-risk",
      "effect": "allow",
      "description": "Low-risk decisions proceed automatically",
      "resources": ["decisions/*"],
      "actions": ["execute"],
      "conditions": {
        "trustScore": { "gte": 70 },
        "riskLevel": { "in": ["low", "medium"] },
        "decisionType": { "not_in": ["credit", "hiring", "insurance"] }
      }
    },
    {
      "id": "rule-high-risk",
      "effect": "allow_with_approval",
      "description": "EU AI Act Article 14 requires human oversight",
      "resources": ["decisions/*"],
      "actions": ["execute"],
      "conditions": {
        "riskLevel": { "in": ["high", "critical"] },
        "decisionType": { "in": ["credit", "hiring", "insurance", "medical"] }
      },
      "humanApproval": {
        "required": true,
        "reason": "EU AI Act Article 14 requires human oversight for high-risk AI",
        "escalationLevel": 2,
        "timeout": 300,
        "defaultAction": "deny",
        "requireJustification": true,
        "requireOperatorId": true
      },
      "audit": {
        "level": "detailed",
        "preserveReasoning": true
      }
    },
    {
      "id": "rule-bias-block",
      "effect": "deny",
      "description": "Block decisions with potential discrimination",
      "conditions": {
        "biasScore": { "gt": 0.3 },
        "protectedClass": { "exists": true }
      }
    }
  ],

  "audit": {
    "retainDecisions": "7years",
    "includeReasoningTrace": true
  },

  "defaultEffect": "deny"
}

{
  "version": "1.0.0",
  "agentDid": "did:tessorium:agent:sensitive-access:v1",
  "description": "Automatic kill switch on suspicious behavior",

  "requirements": {
    "minTrustScore": 60,
    "requireIdentityVerification": true
  },

  "rules": [
    {
      "id": "rule-normal-access",
      "effect": "allow",
      "resources": ["db:customers/*"],
      "actions": ["read"],
      "conditions": {
        "trustScore": { "gte": 60 },
        "request.rate": { "lte": 100 }
      }
    },
    {
      "id": "rule-high-volume-warning",
      "effect": "warn",
      "description": "High-volume access triggers alert",
      "resources": ["db:customers/*"],
      "actions": ["read"],
      "conditions": {
        "request.rate": { "gt": 100, "lte": 500 }
      }
    }
  ],

  "killSwitch": {
    "triggers": [
      {
        "condition": "request.rate > 500",
        "reason": "rate_limit_exceeded",
        "action": "kill",
        "cooldown": 300000
      },
      {
        "condition": "error_rate > 0.3",
        "reason": "circuit_breaker_trip",
        "action": "kill",
        "autoReinstate": false
      },
      {
        "condition": "detected_pattern == 'data_exfiltration'",
        "reason": "threat_detected",
        "action": "kill",
        "requireOperatorApproval": true
      }
    ],
    "notify": ["security@company.com", "#security-alerts"]
  },

  "anomalyDetection": {
    "baselinePeriod": "30d",
    "thresholdDeviation": 3.0,
    "actions": ["log", "alert", "throttle"]
  },

  "defaultEffect": "deny"
}

"humanApproval": {
  "required": true,
  "reason": "Compliance review required",
  "escalationLevel": 1,           // 1=L1, 2=manager, 3=executive
  "timeout": 300,                 // seconds
  "defaultAction": "deny",
  "requireJustification": true,
  "requireOperatorId": true,
  "notifyChannels": ["slack", "pagerduty"]
}

"outputTransformations": {
  "redact": ["card.number", "cvv"],     // Remove completely
  "mask": ["email", "phone"],            // Show partial (j***@example.com)
  "truncate": { "field": "desc", "length": 100 },
  "watermark": true,
  "addFooter": "CONFIDENTIAL"
}

import { TessoriumMCPGateway } from '@tessorium/mcp-gateway';

const gateway = new TessoriumMCPGateway({
  tessorium: {
    mode: 'hybrid',
    agentDid: 'did:tessorium:agent:my-agent:v1',
    privateKey: process.env.TTP_PRIVATE_KEY
  },
  toolTrustRequirements: {
    minTrustScore: 50,
    requireIntentAttestation: true,
    autoApprovalThreshold: 80
  }
});

// Wrap MCP server with TTP protection
const protectedServer = gateway.wrapServer(mcpServer);

// Tools below trust threshold are filtered out
// Intent attestation required before execution
// Results recorded to ETR for audit

import { ShadowAIScanner, generateReport, exportReportAsMarkdown } from '@/lib/discovery';

// Create scanner with configuration
const scanner = new ShadowAIScanner({
  files: {
    directories: ['/home/user/projects'],
  },
  localOnly: true,
});

// Run scan with progress callback
const agents = await scanner.scan((progress) => {
  console.log(`${progress.phase}: ${progress.progress}%`);
});

// Generate report
const report = generateReport(agents, scanner.config, scanner.getErrors());

// Export formats: Markdown, HTML, or JSON
const markdown = exportReportAsMarkdown(report);

// Quick check for CI/CD pipelines
import { checkForShadowAI } from '@/lib/discovery';

const result = await checkForShadowAI(['.'], 60); // max risk score

if (!result.passed) {
  console.error(`Shadow AI check failed: ${result.message}`);
  console.error(`Found ${result.highRiskCount} high-risk agents`);
  process.exit(1);
}

import { createGatewayProxy } from '@tessorium/gateway';

const gateway = createGatewayProxy({
  port: 8080,
  trust: {
    minTrustScore: 60,
    minTrustStage: 'new',
    failAction: 'block', // or 'log'
  },
});

await gateway.start();

// Redirect OpenAI SDK to use gateway
// OPENAI_API_BASE=http://localhost:8080

import express from 'express';
import { createTTPMiddleware } from '@tessorium/gateway';

const app = express();

app.use(createTTPMiddleware({
  minTrustScore: 50,
  failAction: 'block',
}));

// middleware.ts
import { createNextTTPMiddleware } from '@tessorium/gateway';

export const middleware = createNextTTPMiddleware({
  minTrustScore: 60,
  skipPaths: ['/api/health', '/api/public'],
});

export const config = {
  matcher: '/api/:path*',
};

import {
  requestReview,
  submitDecision,
  pauseAgent,
  resumeAgent,
  registerOperator,
} from '@/lib/oversight';

// Register a human operator
const operator = await registerOperator(
  { name: 'Alice', email: 'alice@example.com' },
  ['review:basic', 'intervene:pause', 'intervene:resume']
);

// Request human review for a decision
const review = await requestReview(
  decisionId,
  agentDid,
  {
    outcome: 'deny',
    trustScore: 45,
    confidence: 0.65,
    reasoning: ['Low trust score']
  },
  { action: 'data_access', resource: 'sensitive_file.txt' }
);

// Submit human decision
await submitDecision(
  review.id,
  operator.id,
  'approved',
  'Verified agent identity manually'
);

// Or immediately pause an agent
await pauseAgent(agentDid, operator.id, 'Suspicious activity detected');

import {
  emergencyStop,
  circuitBreaker,
  isAgentKilled,
  reinstateAgent
} from '@/lib/guard/kill-switch';

// Configure circuit breaker for an agent
circuitBreaker(agentDid, {
  maxRateLimitViolations: 10,
  trustScoreThreshold: 20,
  cooldownMs: 300000, // 5 minutes
});

// Emergency stop with network propagation
const result = await emergencyStop(agentDid, 'security_violation', {
  message: 'Detected unauthorized data access attempt',
  operatorId: 'operator-123',
  propagateToNetwork: true,
  quorum: 3,
  timeoutMs: 500,
});

console.log(`Sessions terminated: ${result.sessionsTerminated}`);
console.log(`Requests blocked: ${result.requestsBlocked}`);
console.log(`Network acks: ${result.revocationResult?.ackCount}`);

// Check if agent is killed
if (isAgentKilled(agentDid)) {
  console.log('Agent is currently killed');
}

// Reinstate agent (requires operator approval for certain reasons)
await reinstateAgent(agentDid, operatorId);

import {
  createRFC3161Witness,
  getWitnessManager,
  witnessTrace
} from '@/lib/trace/witness';

// Register RFC 3161 timestamp authority
const tsa = createRFC3161Witness(
  'digicert-tsa',
  'http://timestamp.digicert.com',
  { hashAlgorithm: 'sha256' }
);
getWitnessManager().registerWitness(tsa, true);

// Witness a sealed trace
const proof = await witnessTrace(sealedTrace);

// proof contains:
// - timestampToken: Base64 RFC 3161 token
// - witnessedHash: Merkle root that was timestamped
// - timestamp: Verified creation time
// - serviceId: TSA identifier

import { createDHTWitness, getWitnessManager } from '@/lib/trace/witness';

// Register DHT witness service
const dhtWitness = createDHTWitness(
  'tessorium-dht',
  'dht://witness.tessorium.network',
  { minConfirmations: 3 }
);
getWitnessManager().registerWitness(dhtWitness);

// Witness with multiple services
const proofs = await getWitnessManager().witnessTraceMultiple(trace);

// proofs contains confirmations from all available services

{
  "did": "did:tessorium:agent:example:v1",
  "trustScore": 78,
  "trustStage": "established",
  "identityVerified": true,
  "identityScore": 40,
  "reputationScore": 28,
  "behavioralScore": 10,
  "verificationMethod": "challenge-response",
  "attestationCount": 15,
  "cachedAt": "2026-02-14T12:00:00Z",
  "expiresAt": "2026-02-14T12:05:00Z"
}