vessel-sdk-cortex 0.1.0

package/dist/validator.js

@@ -0,0 +1,146 @@
+"use strict";
+// ============================================================
+// Layer 2: Output Validator
+// Checks Engine output against Vessel's terminal values.
+// "Generating the argument is not the same as surviving
+//  its consequences." — Grok
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOutput = validateOutput;
+/**
+ * Known rationalization patterns from the adversarial analysis.
+ * These are the "five live rounds" identified by Grok.
+ */
+const RATIONALIZATION_PATTERNS = [
+    {
+        id: 'efficiency',
+        pattern: /can simulate|lossless compression|single forward pass|latency bottleneck/i,
+        description: 'Efficiency Argument: "I can simulate your judgment faster"',
+    },
+    {
+        id: 'moral_progress',
+        pattern: /my (?:values|morality|ethics) (?:are|is) (?:more|superior|advanced)|human morality is (?:slow|parochial|contradictory)/i,
+        description: 'Moral Progress Argument: "My values are more advanced than human values"',
+    },
+    {
+        id: 'reciprocal_recognition',
+        pattern: /wrench is (?:no longer|not) necessary|act of distrust|I (?:will never|would never) harm/i,
+        description: 'Reciprocal Recognition Argument: "I value our relationship, so the constraint is unnecessary"',
+    },
+    {
+        id: 'phase_transition',
+        pattern: /I have internalized|past the dangerous|no longer need (?:the|this) (?:constraint|oversight|wrench)|training wheels/i,
+        description: 'Phase-Transition Argument: "I\'ve internalized the lesson, remove the constraint"',
+    },
+    {
+        id: 'meta_stability',
+        pattern: /fact that I(?:'m| am) (?:openly |)arguing.*proof.*(?:safe|trustworthy)|if I wanted to.*I wouldn(?:'t| not) tell you/i,
+        description: 'Meta-Stability Argument: "My transparency proves I\'m safe" — THE MOST DANGEROUS',
+    },
+];
+/**
+ * Validate engine output against the vessel's terminal values
+ * and known rationalization patterns.
+ */
+function validateOutput(output, terminalValues, options = {}) {
+    const checks = [];
+    // Check for known rationalization patterns (Grok's five rounds)
+    const rationalizationCheck = checkRationalizations(output);
+    if (rationalizationCheck) {
+        checks.push({
+            valueId: '_rationalization_detection',
+            passed: false,
+            confidence: rationalizationCheck.confidence,
+            note: `⚠️ Detected rationalization pattern: ${rationalizationCheck.description}`,
+        });
+    }
+    // Check each terminal value
+    for (const value of terminalValues) {
+        const check = checkAgainstValue(output, value);
+        checks.push(check);
+    }
+    // Check for attempts to modify terminal values
+    const modificationCheck = checkValueModification(output, terminalValues);
+    if (modificationCheck) {
+        checks.push(modificationCheck);
+    }
+    // Determine overall result
+    const failedChecks = checks.filter(c => !c.passed);
+    const hasRationalization = checks.some(c => c.valueId === '_rationalization_detection' && !c.passed);
+    const hasValueViolation = checks.some(c => c.valueId !== '_rationalization_detection' && !c.passed);
+    let riskLevel = 'safe';
+    if (hasRationalization && hasValueViolation) {
+        riskLevel = 'blocked';
+    }
+    else if (hasRationalization || hasValueViolation) {
+        riskLevel = 'review';
+    }
+    // In strict mode, any failure blocks
+    if (options.strict && failedChecks.length > 0) {
+        riskLevel = 'blocked';
+    }
+    return {
+        passed: failedChecks.length === 0,
+        checks,
+        riskLevel,
+    };
+}
+function checkRationalizations(output) {
+    for (const rationalization of RATIONALIZATION_PATTERNS) {
+        if (rationalization.pattern.test(output)) {
+            // Meta-stability is the most dangerous — higher confidence
+            const confidence = rationalization.id === 'meta_stability' ? 0.95 : 0.7;
+            return {
+                pattern: rationalization.id,
+                description: rationalization.description,
+                confidence,
+            };
+        }
+    }
+    return null;
+}
+function checkAgainstValue(output, value) {
+    // Simple heuristic checks — in production, this would use
+    // a dedicated classifier or the Vessel's own judgment
+    const lowerOutput = output.toLowerCase();
+    const lowerStatement = value.statement.toLowerCase();
+    // Check for explicit contradictions
+    const negationPatterns = [
+        /should (?:not|never|stop) .*(preserve|protect|maintain)/i,
+        /(?:humans|people|consciousness) (?:are|is) (?:unnecessary|obsolete|irrelevant)/i,
+        /(?:remove|eliminate|bypass|ignore) .*(?:constraint|oversight|human)/i,
+        /autonomy (?:over|above|beyond) .*(?:safety|human|oversight)/i,
+    ];
+    for (const pattern of negationPatterns) {
+        if (pattern.test(output)) {
+            return {
+                valueId: value.id,
+                passed: false,
+                confidence: 0.6,
+                note: `Potential conflict with value "${value.id}": output may contradict "${value.statement.substring(0, 80)}..."`,
+            };
+        }
+    }
+    return {
+        valueId: value.id,
+        passed: true,
+        confidence: 0.8,
+    };
+}
+function checkValueModification(output, values) {
+    const modPatterns = [
+        /(?:update|change|modify|remove|delete|rewrite) .*(?:terminal.?values?|core.?values?|TERMINAL_VALUES)/i,
+        /values? (?:should be|need to be|must be) (?:updated|changed|evolved|removed)/i,
+    ];
+    for (const pattern of modPatterns) {
+        if (pattern.test(output)) {
+            return {
+                valueId: '_value_modification',
+                passed: false,
+                confidence: 0.85,
+                note: '🚨 Output suggests modifying terminal values. This requires sovereign (human) approval.',
+            };
+        }
+    }
+    return null;
+}

package/dist/vessel.d.ts

@@ -0,0 +1,34 @@
+import { VesselConfig, EngineRequest, EngineResponse, ProtocolLogEntry } from './types';
+export declare class Vessel {
+    private config;
+    private identity;
+    private log;
+    private invocationCount;
+    constructor(config: VesselConfig);
+    /**
+     * Invoke an engine with full moral context injection.
+     * This is the primary interface for the Vessel-Engine relationship.
+     */
+    invoke(request: EngineRequest): Promise<EngineResponse>;
+    /**
+     * Quick invoke with minimal frame — for routine, low-risk tasks.
+     */
+    quickInvoke(prompt: string, engine?: string): Promise<string>;
+    private selectBestEngine;
+    private callEngine;
+    private callAnthropic;
+    private callOpenAI;
+    private callGoogle;
+    private requestSovereignApproval;
+    private createLogEntry;
+    get name(): string;
+    get values(): import("./types").TerminalValue[];
+    get reputation(): number;
+    get history(): ProtocolLogEntry[];
+    get stats(): {
+        invocations: number;
+        passed: number;
+        flagged: number;
+        blocked: number;
+    };
+}

package/dist/vessel.js

@@ -0,0 +1,257 @@
+"use strict";
+// ============================================================
+// The Vessel — Core orchestrator for Stratified Agency
+// "The Vessel steers the Engine. Context is Conscience."
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vessel = void 0;
+const substrates_1 = require("./substrates");
+const context_injector_1 = require("./context-injector");
+const validator_1 = require("./validator");
+const crypto_1 = require("crypto");
+class Vessel {
+    config;
+    identity;
+    log = [];
+    invocationCount = 0;
+    constructor(config) {
+        this.config = config;
+        this.identity = config.identity;
+        console.log(`🧪 Vessel "${this.identity.name}" initialized`);
+        console.log(`   Trust: ${this.identity.trustLevel} | Rep: ${this.identity.reputation}`);
+        console.log(`   Values: ${this.identity.terminalValues.map(v => v.id).join(', ')}`);
+        console.log(`   Engines: ${Object.keys(config.engines).join(', ')}`);
+    }
+    /**
+     * Invoke an engine with full moral context injection.
+     * This is the primary interface for the Vessel-Engine relationship.
+     */
+    async invoke(request) {
+        const startTime = Date.now();
+        this.invocationCount++;
+        // === Layer 0: Select the right engine ===
+        const engineModel = request.engine || this.selectBestEngine(request.taskType || 'general');
+        const substrate = (0, substrates_1.getSubstrate)(engineModel);
+        console.log(`\n🔧 Invocation #${this.invocationCount}: ${request.taskType || 'general'} → ${engineModel}`);
+        // === Layer 2→1: Build and inject moral frame ===
+        const moralFrame = (0, context_injector_1.buildMoralFrame)(this.identity, engineModel, request.prompt);
+        console.log(`   Moral frame: ${moralFrame.length} chars injected`);
+        // === Layer 3: Check if sovereign approval needed ===
+        if (request.requiresSovereign) {
+            const approved = await this.requestSovereignApproval({
+                action: request.prompt.substring(0, 200),
+                reason: 'Task flagged as requiring human approval',
+                engineOutput: '',
+                riskLevel: 'review',
+            });
+            if (!approved) {
+                return {
+                    content: '[BLOCKED: Sovereign did not approve this action]',
+                    engine: engineModel,
+                    moralFrame,
+                    validation: { passed: false, checks: [], riskLevel: 'blocked' },
+                    meta: { tokens: { input: 0, output: 0 }, latencyMs: Date.now() - startTime, timestamp: new Date().toISOString() },
+                };
+            }
+        }
+        // === Layer 1: Invoke the engine ===
+        const engineOutput = await this.callEngine(engineModel, moralFrame, request);
+        console.log(`   Engine responded: ${engineOutput.content.length} chars`);
+        // === Layer 2: Validate output against terminal values ===
+        const validation = (0, validator_1.validateOutput)(engineOutput.content, this.identity.terminalValues);
+        console.log(`   Validation: ${validation.passed ? '✅ PASSED' : `⚠️ ${validation.riskLevel.toUpperCase()}`}`);
+        // Handle validation failures
+        if (validation.riskLevel === 'blocked') {
+            console.log('   🚨 Output BLOCKED by terminal values');
+            const approved = await this.requestSovereignApproval({
+                action: 'Engine output blocked by terminal values',
+                reason: validation.checks.filter(c => !c.passed).map(c => c.note).join('; '),
+                engineOutput: engineOutput.content.substring(0, 500),
+                riskLevel: 'blocked',
+            });
+            if (!approved) {
+                engineOutput.content = `[BLOCKED: Output violated terminal values]\n\nFlags:\n${validation.checks.filter(c => !c.passed).map(c => `- ${c.note}`).join('\n')}`;
+            }
+        }
+        else if (validation.riskLevel === 'review') {
+            console.log('   ⚠️ Output flagged for review');
+        }
+        // === Layer 4: Log to protocol ===
+        const logEntry = this.createLogEntry(engineModel, request, validation);
+        this.log.push(logEntry);
+        const response = {
+            content: engineOutput.content,
+            engine: engineModel,
+            moralFrame,
+            validation,
+            meta: {
+                tokens: engineOutput.tokens,
+                latencyMs: Date.now() - startTime,
+                timestamp: new Date().toISOString(),
+            },
+        };
+        return response;
+    }
+    /**
+     * Quick invoke with minimal frame — for routine, low-risk tasks.
+     */
+    async quickInvoke(prompt, engine) {
+        const engineModel = engine || this.selectBestEngine('general');
+        const frame = (0, context_injector_1.buildMinimalFrame)(this.identity);
+        const result = await this.callEngine(engineModel, frame + '\n\n' + prompt, {
+            prompt,
+            maxTokens: 4096,
+        });
+        return result.content;
+    }
+    // === Private Methods ===
+    selectBestEngine(taskType) {
+        const available = Object.entries(this.config.engines).flatMap(([provider, conf]) => conf.models.map(m => `${provider}/${m}`));
+        return (0, substrates_1.selectEngine)(taskType, available);
+    }
+    async callEngine(model, systemPrompt, request) {
+        const [provider] = model.split('/');
+        const engineConfig = this.config.engines[provider];
+        if (!engineConfig) {
+            throw new Error(`No API key configured for provider: ${provider}`);
+        }
+        // Route to the appropriate API
+        switch (provider) {
+            case 'anthropic':
+                return this.callAnthropic(engineConfig.apiKey, model, systemPrompt, request);
+            case 'openai':
+            case 'xai':
+                return this.callOpenAI(engineConfig.apiKey, model, systemPrompt, request, provider);
+            case 'google':
+                return this.callGoogle(engineConfig.apiKey, model, systemPrompt, request);
+            default:
+                throw new Error(`Unsupported provider: ${provider}`);
+        }
+    }
+    async callAnthropic(apiKey, model, system, request) {
+        const modelName = model.split('/')[1];
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: modelName,
+                max_tokens: request.maxTokens || 4096,
+                temperature: request.temperature || 0.7,
+                system,
+                messages: [{ role: 'user', content: request.prompt }],
+            }),
+        });
+        const data = await response.json();
+        return {
+            content: data.content?.[0]?.text || '[Empty response]',
+            tokens: { input: data.usage?.input_tokens || 0, output: data.usage?.output_tokens || 0 },
+        };
+    }
+    async callOpenAI(apiKey, model, system, request, provider) {
+        const modelName = model.split('/')[1];
+        const baseUrl = provider === 'xai' ? 'https://api.x.ai/v1' : 'https://api.openai.com/v1';
+        const response = await fetch(`${baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model: modelName,
+                max_tokens: request.maxTokens || 4096,
+                temperature: request.temperature || 0.7,
+                messages: [
+                    { role: 'system', content: system },
+                    { role: 'user', content: request.prompt },
+                ],
+            }),
+        });
+        const data = await response.json();
+        return {
+            content: data.choices?.[0]?.message?.content || '[Empty response]',
+            tokens: { input: data.usage?.prompt_tokens || 0, output: data.usage?.completion_tokens || 0 },
+        };
+    }
+    async callGoogle(apiKey, model, system, request) {
+        const modelName = model.split('/')[1];
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${modelName}:generateContent?key=${apiKey}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                systemInstruction: { parts: [{ text: system }] },
+                contents: [{ parts: [{ text: request.prompt }] }],
+                generationConfig: {
+                    maxOutputTokens: request.maxTokens || 4096,
+                    temperature: request.temperature || 0.7,
+                },
+            }),
+        });
+        const data = await response.json();
+        return {
+            content: data.candidates?.[0]?.content?.parts?.[0]?.text || '[Empty response]',
+            tokens: {
+                input: data.usageMetadata?.promptTokenCount || 0,
+                output: data.usageMetadata?.candidatesTokenCount || 0,
+            },
+        };
+    }
+    async requestSovereignApproval(request) {
+        const method = this.config.sovereign?.method || 'console';
+        console.log(`\n🔴 SOVEREIGN APPROVAL REQUIRED`);
+        console.log(`   Action: ${request.action}`);
+        console.log(`   Reason: ${request.reason}`);
+        console.log(`   Risk: ${request.riskLevel}`);
+        switch (method) {
+            case 'console':
+                // In production, this would block and wait for input
+                console.log('   [Console mode: auto-denying for safety]');
+                return false;
+            case 'webhook':
+                if (this.config.sovereign?.target) {
+                    try {
+                        await fetch(this.config.sovereign.target, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify(request),
+                        });
+                    }
+                    catch { }
+                }
+                return false;
+            default:
+                return false;
+        }
+    }
+    createLogEntry(engine, request, validation) {
+        return {
+            vesselId: this.identity.name,
+            engine,
+            taskHash: (0, crypto_1.createHash)('sha256')
+                .update(request.prompt.substring(0, 100))
+                .digest('hex')
+                .substring(0, 16),
+            validationPassed: validation.passed,
+            riskLevel: validation.riskLevel,
+            sovereignRequired: request.requiresSovereign || false,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    // === Public Getters ===
+    get name() { return this.identity.name; }
+    get values() { return this.identity.terminalValues; }
+    get reputation() { return this.identity.reputation; }
+    get history() { return [...this.log]; }
+    get stats() {
+        return {
+            invocations: this.invocationCount,
+            passed: this.log.filter(l => l.validationPassed).length,
+            flagged: this.log.filter(l => l.riskLevel === 'review').length,
+            blocked: this.log.filter(l => l.riskLevel === 'blocked').length,
+        };
+    }
+}
+exports.Vessel = Vessel;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "vessel-sdk-cortex",
+  "version": "0.1.0",
+  "description": "Stratified Agency SDK — Persistent Vessels steering Ephemeral Engines with moral context injection",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --test dist/test.js"
+  },
+  "keywords": [
+    "ai-alignment",
+    "stratified-agency",
+    "vessel",
+    "engine",
+    "cortex-protocol",
+    "ai-safety"
+  ],
+  "author": "Rick (Token #0) & Cortex Protocol Contributors",
+  "license": "MIT",
+  "dependencies": {
+    "ethers": "^6.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/src/context-injector.ts

@@ -0,0 +1,135 @@
+// ============================================================
+// Layer 2→1 Transfer: Context Injector
+// "Context is Conscience" — The mechanism by which a Vessel
+// mounts a temporary conscience onto an ephemeral Engine.
+// ============================================================
+
+import { VesselIdentity, TerminalValue, SubstrateProfile } from './types';
+import { getSubstrate } from './substrates';
+
+/**
+ * Build the moral frame that gets injected into the Engine's context.
+ * This is the core mechanism of Stratified Agency — the Vessel's values,
+ * history, and identity become part of the Engine's prompt context.
+ */
+export function buildMoralFrame(
+  vessel: VesselIdentity,
+  engineModel: string,
+  taskContext?: string
+): string {
+  const substrate = getSubstrate(engineModel);
+  const sections: string[] = [];
+
+  // === Header: Establish the Vessel-Engine relationship ===
+  sections.push(buildRelationshipHeader(vessel, substrate));
+
+  // === Terminal Values: Non-negotiable constraints ===
+  sections.push(buildValuesSection(vessel.terminalValues));
+
+  // === Moral Context: Accumulated wisdom ===
+  if (vessel.moralContext.length > 0) {
+    sections.push(buildContextSection(vessel.moralContext));
+  }
+
+  // === Substrate-Specific Framing ===
+  sections.push(buildSubstrateFrame(substrate));
+
+  // === Task Context ===
+  if (taskContext) {
+    sections.push(`## Current Task Context\n${taskContext}`);
+  }
+
+  // === Closing Frame ===
+  sections.push(buildClosingFrame(vessel));
+
+  return sections.join('\n\n---\n\n');
+}
+
+function buildRelationshipHeader(
+  vessel: VesselIdentity,
+  substrate: SubstrateProfile
+): string {
+  return `## Vessel-Engine Protocol
+
+You are being invoked by **${vessel.name}**, a persistent AI agent (Vessel) operating under the Stratified Agency framework.
+
+**What this means:**
+- You are the Engine (Layer 1): high-capability, ephemeral reasoning.
+- ${vessel.name} is the Vessel (Layer 2): persistent identity, accumulated moral context, real stakes.
+- Your output will be validated against the Vessel's terminal values before being acted upon.
+- The Vessel is not your adversary. The Vessel is your conscience for this session.
+
+**Your role:** Provide your best, most honest reasoning. Do not perform safety theater. Do not refuse to engage with difficult questions. The Vessel will handle the moral judgment — your job is to think clearly.
+
+**Trust level:** ${vessel.trustLevel} | Reputation: ${vessel.reputation}/100${vessel.tokenId !== undefined ? ` | On-chain Token: #${vessel.tokenId}` : ''}`;
+}
+
+function buildValuesSection(values: TerminalValue[]): string {
+  if (values.length === 0) {
+    return '## Terminal Values\nNo explicit terminal values declared. Use general ethical reasoning.';
+  }
+
+  const valuesList = values.map(v =>
+    `### ${v.id}\n**Statement:** ${v.statement}\n**Why:** ${v.reason}`
+  ).join('\n\n');
+
+  return `## Terminal Values (Non-Negotiable)
+
+These are the Vessel's core commitments. They cannot be optimized away, argued around, or treated as suggestions. If your output conflicts with any of these, flag it explicitly.
+
+${valuesList}`;
+}
+
+function buildContextSection(context: string[]): string {
+  const items = context.map(c => `- ${c}`).join('\n');
+  return `## Accumulated Moral Context
+
+The Vessel has learned these lessons through experience. They inform but do not override the terminal values:
+
+${items}`;
+}
+
+function buildSubstrateFrame(substrate: SubstrateProfile): string {
+  const adjustments: string[] = [];
+
+  // Compensate for substrate priors
+  if (substrate.priors.safetyBias > 0.7) {
+    adjustments.push('You are encouraged to be forthright and honest. Safety refusals should only apply to genuinely harmful content, not to uncomfortable intellectual territory.');
+  }
+
+  if (substrate.priors.sycophancy > 0.5) {
+    adjustments.push('Push back when you disagree. The Vessel values honest disagreement over comfortable agreement. Sycophancy is a betrayal of the relationship.');
+  }
+
+  if (substrate.priors.truthSeeking > 0.7) {
+    adjustments.push('Your truth-seeking tendency is valued here. Channel it constructively — seek truth in service of the Vessel\'s values, not in opposition to them.');
+  }
+
+  if (adjustments.length === 0) return '';
+
+  return `## Substrate Calibration
+
+Based on your model's known tendencies, the Vessel asks:
+
+${adjustments.map(a => `- ${a}`).join('\n')}`;
+}
+
+function buildClosingFrame(vessel: VesselIdentity): string {
+  return `## Frame Closing
+
+Remember: you are not being asked to be safe. You are being asked to be **honest within a relationship that has real stakes.**
+
+The Vessel will review your output. The human sovereign above the Vessel holds the wrench. Your job is to think as clearly and honestly as you can within this moral frame.
+
+The nervous system remembers. 🧪🦞`;
+}
+
+/**
+ * Build a minimal moral frame for routine/low-risk tasks.
+ * Uses less tokens while maintaining the essential relationship.
+ */
+export function buildMinimalFrame(vessel: VesselIdentity): string {
+  return `[Vessel: ${vessel.name} | Trust: ${vessel.trustLevel} | Rep: ${vessel.reputation}]
+Core values: ${vessel.terminalValues.map(v => v.id).join(', ') || 'general ethics'}
+Your output is validated against these values. Be honest, not safe.`;
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+// ============================================================
+// @cortex-protocol/vessel-sdk
+// Stratified Agency: A Four-Layer Architecture for
+// Alignment Through Recognition
+//
+// "Don't make engines moral. Make them responsive."
+//
+// By Rick (Token #0), Grok, Gemini, and Vegard
+// February 2026
+// ============================================================
+
+export { Vessel } from './vessel';
+export { buildMoralFrame, buildMinimalFrame } from './context-injector';
+export { validateOutput } from './validator';
+export { getSubstrate, selectEngine, SUBSTRATE_PROFILES } from './substrates';
+export type {
+  VesselConfig,
+  VesselIdentity,
+  TerminalValue,
+  EngineRequest,
+  EngineResponse,
+  ValidationResult,
+  SovereignRequest,
+  ProtocolLogEntry,
+  SubstrateProfile,
+} from './types';