External Governance Services for AI Systems

BoundaryEnforcer

Implements Tractatus 12.1-12.7: AI cannot make values decisions without human approval.

const enforcer = require('./services/BoundaryEnforcer.service')
const result = await enforcer.enforce(action, context)
// Returns: { allowed, decision, action, principle, ... }

InstructionPersistenceClassifier

Classifies instructions by quadrant (STRATEGIC/OPERATIONAL/TACTICAL/SYSTEM) and persistence level (HIGH/MEDIUM/LOW).

const classifier = require('./services/InstructionPersistenceClassifier.service')
const result = await classifier.classify({ text: instruction, context, source })
// Returns: { quadrant, persistence, temporal_scope, explicitness }

CrossReferenceValidator

Validates AI actions against stored instructions to prevent pattern recognition overrides.

const validator = require('./services/CrossReferenceValidator.service')
const result = await validator.validate(action, context)
// Returns: { status: 'REJECTED', conflicts, correct_parameters }

ContextPressureMonitor

Monitors token usage and context pressure, triggering safety protocols at thresholds.

const monitor = require('./services/ContextPressureMonitor.service')
const result = await monitor.analyzePressure(context)
// Returns: { level: 'HIGH', score, shouldReduce: true }

MetacognitiveVerifier

Verifies action reasoning and confidence, requiring confirmation for low-confidence actions.

const verifier = require('./services/MetacognitiveVerifier.service')
const result = await verifier.verify(action, reasoning, context)
// Returns: { decision, confidence, level, issues, scores, recommendations }

PluralisticDeliberationOrchestrator

Manages multi-stakeholder deliberation to support value pluralism in decisions.

const orchestrator = require('./services/PluralisticDeliberationOrchestrator.service')
const conflict = await orchestrator.analyzeConflict(decision, context)
const outcome = await orchestrator.facilitateDeliberation(conflict, stakeholders)

Express Middleware Integration

const express = require('express')
const enforcer = require('./services/BoundaryEnforcer.service')

const app = express()

// Add boundary checking middleware
app.use(async (req, res, next) => {
  if (req.body.action) {
    const check = await enforcer.enforce(req.body.action, req.body.context)

    if (!check.allowed) {
      return res.status(403).json({
        error: 'Boundary violation',
        reason: check.reason,
        alternatives: check.alternatives
      })
    }
  }
  next()
})

Instruction Validation

const {
  InstructionPersistenceClassifier,
  CrossReferenceValidator
} = require('./services')

// Classify and store user instruction
const classification = await
  InstructionPersistenceClassifier.classify(
    userInstruction
  )

if (classification.explicitness >= 0.6) {
  await storeInstruction(classification)
}

// Validate AI action before execution
const validation = await
  CrossReferenceValidator.validate(
    proposedAction,
    await getStoredInstructions()
  )

if (validation.status === 'REJECTED') {
  console.error(validation.conflicts)
  useCorrectParameters(
    validation.correct_parameters
  )
}