SINT Gate

// @sint/gate-policy-gateway — core interface
async function intercept(
  token: SintCapabilityToken,
  action: PhysicalAction,
  context: PhysicalActionContext
): Promise<InterceptResult>

// @sint/core — packages/core/src/types.ts
interface SintCapabilityToken {
  // Identity
  agentId: string;           // UUID of the requesting agent
  issuerId: string;          // Public key (hex) of the issuing authority
  
  // Authorization scope
  resource: string;          // e.g., "robot:arm:joint_1", "drone:motors", "valve:inlet"
  action: string;            // e.g., "move", "actuate", "open", "close"
  
  // Physical constraints
  constraints: PhysicalConstraints;
  
  // Safety classification
  tier: 1 | 2 | 3 | 4 | 5;
  
  // Validity window
  issuedAt: number;          // Unix ms
  expiresAt: number;         // Unix ms (max 24h from issuedAt)
  
  // Delegation provenance
  delegationChain: string[]; // Ordered list: root issuer → leaf issuer (max length 3)
  
  // Replay prevention
  nonce: string;             // UUID v4, single-use
  
  // Cryptographic binding
  signature: string;         // base64url(ed25519.sign(canonical_json, issuerPrivateKey))
}

interface PhysicalConstraints {
  force_newtons?: number;        // Maximum force in Newtons
  velocity_mps?: number;         // Maximum velocity in m/s
  temperature_celsius?: number;  // Maximum temperature in °C
  geofence?: GeoPolygon;         // WGS84 polygon boundary
  joint_angles?: JointAngleLimits; // Per-joint min/max in degrees
  custom?: Record<string, number>; // Domain-specific numeric limits
}

# sintctl
sintctl tokens issue \
  --agent <agentId> \
  --resource "robot:arm:joint_1" \
  --action "move" \
  --tier 3 \
  --force 50 \
  --velocity 0.3 \
  --ttl 3600

// REST API
const res = await fetch('https://gateway.example.com/v1/tokens', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <admin_api_key>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    agentId: 'agent-uuid',
    resource: 'robot:arm:joint_1',
    action: 'move',
    tier: 3,
    constraints: { force_newtons: 50, velocity_mps: 0.3 },
    ttlSeconds: 3600,
  }),
});
const { token, tokenId } = await res.json();

// POST /v1/tokens/delegate
{
  parentTokenId: string;
  delegateeAgentId: string;
  constraints: PhysicalConstraints;  // Must be ≤ parent on all fields
  tier: number;                      // Must be ≤ parent tier
  ttlSeconds: number;                // Must be ≤ parent remaining TTL
}

interface PhysicalActionContext {
  human_detected: boolean;       // From proximity sensor / vision system
  human_distance_meters?: number;
  environment: 'indoor' | 'outdoor' | 'unknown';
  ambient_temperature_celsius?: number;
  // ... domain-specific fields
}

intercept(token, action, context)
  │
  ├─► 1. Schema Validation      — Zod, rejects malformed input
  ├─► 2. Token Verification     — Ed25519 sig, expiry, nonce, revocation
  ├─► 3. Policy Evaluation      — Active rules for resource+action
  ├─► 4. Constraint Check       — PhysicalActionContext vs token limits
  ├─► 5. Tier Assignment        — Token tier + context escalation
  ├─► 6. Goal Hijack Detection  — 25+ regex patterns on action payload
  ├─► 7. CSML Anomaly Scoring   — Behavioral anomaly score
  └─► 8. Evidence Logging       — SHA-256 chain entry

// Enforcement in @sint/gate-policy-gateway
function enforceConstraints(
  requested: PhysicalActionContext,
  allowed: PhysicalConstraints
): ConstraintResult {
  if (requested.force_newtons > (allowed.force_newtons ?? Infinity)) {
    return { violated: true, field: 'force_newtons', 
             requested: requested.force_newtons, 
             allowed: allowed.force_newtons };
  }
  // ... same pattern for velocity, temperature, joint angles
  
  if (allowed.geofence && !pointInPolygon(requested.position, allowed.geofence)) {
    return { violated: true, field: 'geofence', ... };
  }
  
  return { violated: false };
}

// @sint/gate-capability-tokens — delegation validation
const childConstraints: PhysicalConstraints = {
  force_newtons: Math.min(parent.constraints.force_newtons ?? Infinity, 
                          requested.force_newtons ?? Infinity),
  velocity_mps:  Math.min(parent.constraints.velocity_mps ?? Infinity,
                          requested.velocity_mps ?? Infinity),
  // ...
};

// @sint/gate-evidence-ledger — LedgerEntry
interface LedgerEntry {
  id: string;              // UUID v4
  previousHash: string;    // SHA-256 of previous entry (genesis: "0".repeat(64))
  entryHash: string;       // SHA-256(previousHash + payload)
  
  payload: {
    decision: 'approve' | 'deny' | 'escalate';
    agentId: string;
    tokenId: string;
    tokenHash: string;     // SHA-256 of serialized token
    action: string;
    resource: string;
    tier: number;
    constraints: PhysicalConstraints;
    csmlScore: number;
    hijackDetected: boolean;
    timestamp: number;     // Unix ms
  };
}

// GET /v1/ledger/proof/:entryId
{
  entryId: string;
  entryHash: string;
  merkleProof: string[];   // Path to chain root
  chainRoot: string;       // Current chain tip hash
  verifiable: boolean;
}

sintctl ledger verify --from-genesis
# ✓ Chain intact: 12,847 entries, root: a3f9c2...
# ✗ Tampering detected at entry 8,432: hash mismatch

# Export as newline-delimited JSON for Splunk/Datadog/ELK
sintctl ledger export --format ndjson --since 24h > ledger-export.ndjson
# GET /v1/ledger/export?format=ndjson&since=86400

CLOSED (normal operation)
  │
  ├──► [trip condition] ──► OPEN (all actions denied)
  │                              │
  │                              ├──► [manual reset + operator auth] ──► HALF-OPEN
  │                                        │
  │                                        ├──► [test action passes] ──► CLOSED
  │                                        └──► [test action fails]  ──► OPEN

# Requires operator credentials (API key with estop:reset scope)
sintctl estop reset --reason "False positive: sensor malfunction confirmed"

# REST
POST /v1/intercept  # No dedicated estop endpoint — managed via sintctl or dashboard