@siduri-x/core 2.0.0 → 2.0.2

package/dist/runtime.js

@@ -1,420 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SiduriRuntime = void 0;
-const index_1 = require("./index");
-const input_normalizer_1 = require("./input-normalizer");
-const intent_classifier_1 = require("./intent-classifier");
-const context_retriever_1 = require("./context-retriever");
-const prompt_compiler_1 = require("./prompt-compiler");
-const cognition_planner_1 = require("./cognition-planner");
-const memory_settler_1 = require("./memory-settler");
-const action_executor_1 = require("./action-executor");
-const experience_emitter_1 = require("./experience-emitter");
-const response_envelope_1 = require("./response-envelope");
-const session_history_1 = require("./session-history");
+const perception_pipeline_1 = require("./perception-pipeline");
+const container_1 = require("./container");
 /**
- * SiduriRuntime coordinates companion lifecycle, sensory perception,
- * context retrieval, cognition planning, safety gating, action execution,
- * and experience emission across decoupled organs.
+ * SiduriRuntime coordinates companion perception and cognition execution.
+ * Lifecycle management and organ storage are handled by CompanionContainer.
+ * The 12-stage perception cycle is executed via PerceptionPipeline.
  */
 class SiduriRuntime {
     id;
     config;
-    brain;
-    memory;
-    voice;
-    knowledge;
-    vision;
-    behavior;
-    body;
-    hands;
-    ear;
-    observation;
-    mouth;
-    self;
-    externalKnowledge;
-    gating;
-    actionPolicy;
-    dispatcher;
-    sessionHistory = new session_history_1.SessionHistoryManager();
-    // Backward-compatible getter/setter for conversation history
+    container;
+    pipeline;
+    constructor(id, config, containerOrOrgans = {}, pipeline) {
+        this.id = id;
+        this.config = config;
+        if (containerOrOrgans instanceof container_1.CompanionContainer) {
+            this.container = containerOrOrgans;
+        }
+        else {
+            this.container = new container_1.CompanionContainer(id, config, containerOrOrgans);
+        }
+        this.pipeline = pipeline || (0, perception_pipeline_1.createDefaultPerceptionPipeline)();
+    }
+    // Direct organ accessors through container
+    get organs() { return this.container.organs; }
+    get brain() { return this.container.brain; }
+    get memory() { return this.container.memory; }
+    get voice() { return this.container.voice; }
+    get knowledge() { return this.container.knowledge; }
+    get vision() { return this.container.vision; }
+    get behavior() { return this.container.behavior; }
+    get body() { return this.container.body; }
+    get hands() { return this.container.hands; }
+    get ear() { return this.container.ear; }
+    get observation() { return this.container.observation; }
+    set observation(org) { this.container.observation = org; }
+    get mouth() { return this.container.mouth; }
+    get self() { return this.container.self; }
+    get externalKnowledge() { return this.container.externalKnowledge; }
+    get gating() { return this.container.gating; }
+    get actionPolicy() { return this.container.actionPolicy; }
+    get dispatcher() { return this.container.dispatcher; }
+    get sessionHistory() { return this.container.sessionHistory; }
+    // Conversation history accessors
     get conversationHistory() {
-        return this.sessionHistory.getHistory('default');
+        return this.container.sessionHistory.getHistory('default');
     }
     set conversationHistory(messages) {
-        this.sessionHistory.setHistory('default', messages);
-    }
-    constructor(id, config, organs = {}) {
-        this.id = id;
-        this.config = config;
-        this.brain = organs.brain;
-        this.memory = organs.memory;
-        this.voice = organs.voice;
-        this.knowledge = organs.knowledge;
-        this.vision = organs.vision;
-        this.behavior = organs.behavior;
-        this.body = organs.body;
-        this.hands = organs.hands;
-        this.ear = organs.ear;
-        this.observation = organs.observation;
-        this.mouth = organs.mouth;
-        this.self = organs.self;
-        this.externalKnowledge = organs.externalKnowledge;
-        this.gating = new index_1.ResponseGatingEngine();
-        let actionStore = organs.actionStore;
-        if (!actionStore) {
-            const storeOpt = config.actionStore;
-            const storePath = config.actionStorePath || (typeof storeOpt === 'object' ? storeOpt.dbPath : undefined);
-            if (storeOpt === 'sqlite' || (typeof storeOpt === 'object' && storeOpt.type === 'sqlite') || storePath) {
-                actionStore = new index_1.SqliteActionStore({ dbPath: storePath });
-            }
-        }
-        this.actionPolicy = organs.actionPolicy || new index_1.ActionPolicyEngine({
-            store: actionStore,
-        });
-        this.dispatcher = new index_1.ExperienceDispatcher();
-        if (this.voice && typeof this.voice.handleEvent === 'function') {
-            this.dispatcher.registerAdapter(this.voice);
-        }
-        if (this.body && typeof this.body.handleEvent === 'function') {
-            this.dispatcher.registerAdapter(this.body);
-        }
-        if (this.mouth && typeof this.mouth.handleEvent === 'function') {
-            this.dispatcher.registerAdapter(this.mouth);
-        }
+        this.container.sessionHistory.setHistory('default', messages);
     }
     async initialize() {
-        if (this.memory && typeof this.memory.initialize === 'function') {
-            await this.memory.initialize(this.id);
-        }
-        if (this.hands && typeof this.hands.listTools === 'function') {
-            const tools = await this.hands.listTools();
-            for (const tool of tools) {
-                this.actionPolicy.registerToolDefinition(tool);
-            }
-        }
+        return this.container.initialize();
     }
-    // --- Session History Accessors ---
     getSessionHistory(sessionKey) {
-        return this.sessionHistory.getHistory(sessionKey);
+        return this.container.sessionHistory.getHistory(sessionKey);
     }
     clearHistory(sessionKey) {
-        this.sessionHistory.clear(sessionKey);
-    }
-    // --- Observation & Vision Facades ---
-    async analyzeVision(imageUrl, prompt) {
-        if (!this.vision || typeof this.vision.analyze !== 'function') {
-            throw new Error('Vision organ is not configured on this runtime');
-        }
-        return this.vision.analyze(imageUrl, prompt);
-    }
-    async ingestObservation(frame, sourceName, providerId) {
-        if (!this.observation || typeof this.observation.ingest !== 'function') {
-            return { duplicate: false, reason: 'provider_failure' };
-        }
-        return this.observation.ingest(frame, sourceName, providerId);
-    }
-    getCurrentObservations(now) {
-        if (!this.observation || typeof this.observation.current !== 'function') {
-            return [];
-        }
-        return this.observation.current(now);
-    }
-    clearExpiredObservations(now) {
-        if (!this.observation || typeof this.observation.clearExpired !== 'function') {
-            return 0;
-        }
-        return this.observation.clearExpired(now);
-    }
-    // --- Memory Facades ---
-    async getClaims(limit) {
-        if (!this.memory || typeof this.memory.getClaims !== 'function') {
-            return [];
-        }
-        return this.memory.getClaims(limit);
-    }
-    async getPendingClaims(limit) {
-        if (!this.memory || typeof this.memory.getPendingClaims !== 'function') {
-            return [];
-        }
-        return this.memory.getPendingClaims(limit);
-    }
-    async getDirectives() {
-        if (!this.memory || typeof this.memory.getDirectives !== 'function') {
-            return [];
-        }
-        return this.memory.getDirectives();
-    }
-    async approveClaim(id) {
-        if (!this.memory || typeof this.memory.approveClaim !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return this.memory.approveClaim(id);
-    }
-    async rejectClaim(id) {
-        if (!this.memory || typeof this.memory.rejectClaim !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return this.memory.rejectClaim(id);
-    }
-    async updateClaim(id, updates) {
-        if (!this.memory || typeof this.memory.updateClaim !== 'function') {
-            throw new Error('Memory organ updateClaim not supported');
-        }
-        return this.memory.updateClaim(id, updates);
-    }
-    async approveDirective(id) {
-        if (!this.memory || typeof this.memory.approveDirective !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return this.memory.approveDirective(id);
-    }
-    async rejectDirective(id) {
-        if (!this.memory || typeof this.memory.rejectDirective !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return this.memory.rejectDirective(id);
-    }
-    async revokeDirective(id) {
-        if (!this.memory || typeof this.memory.revokeDirective !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return this.memory.revokeDirective(id);
+        this.container.sessionHistory.clear(sessionKey);
     }
-    async disableDirective(id) {
-        if (!this.memory || typeof this.memory.disableDirective !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return this.memory.disableDirective(id);
-    }
-    async resetMemory() {
-        if (!this.memory || typeof this.memory.resetMemory !== 'function') {
-            throw new Error('Memory organ does not support reset');
-        }
-        return this.memory.resetMemory();
-    }
-    // --- Response Gating Facades ---
-    stageResponse(options) {
-        return this.gating.stageResponse(options);
-    }
-    evaluateGate(plan, evidenceRecords) {
-        return this.gating.evaluateGate(plan, evidenceRecords);
-    }
-    approveResponse(options) {
-        return this.gating.approveResponse(options);
-    }
-    rejectResponse(options) {
-        return this.gating.rejectResponse(options);
-    }
-    getStagedPlan(responseId) {
-        return this.gating.getStagedPlan(responseId);
-    }
-    findStagedPlanByCorrelation(companionId, correlationId) {
-        return this.gating.findStagedPlanByCorrelation(companionId, correlationId);
-    }
-    // --- Universal Perception & Cognition Cycle ---
     /**
      * Processes an incoming perception (sensory audio, text, platform event, or observation alert)
-     * through the perception -> retrieval -> cognition -> gating -> action -> experience cycle.
+     * through the decoupled PerceptionPipeline.
      */
     async processPerception(perception) {
-        let rawText = perception.text || '';
-        // If audio buffer is provided and Ear supports transcription, transcribe it
-        if (!rawText && perception.audioBuffer && this.ear && typeof this.ear.transcribeAudio === 'function') {
-            rawText = await this.ear.transcribeAudio(perception.audioBuffer);
-        }
-        const roleOrContext = perception.context || perception.roleOrContext || 'OWNER';
-        const history = perception.history || [];
-        // 1. Input validation, RequestContext synthesis, and Ear perception routing
-        const input = await (0, input_normalizer_1.normalizeUserInput)(rawText, roleOrContext, history, this.id, this.ear);
-        const sessionKey = input.requestContext.actor.sessionId ||
-            input.requestContext.conversation.correlationId ||
-            'default';
-        const currentMessage = { role: 'user', content: input.perceivedText };
-        const boundedSessionHistory = [...input.boundedHistory, currentMessage].slice(-20);
-        this.sessionHistory.setHistory(sessionKey, boundedSessionHistory);
-        this.sessionHistory.setHistory('default', boundedSessionHistory);
-        // 2. Intent classification (delegating to Ear if available, else heuristics)
-        const intent = await (0, intent_classifier_1.classifyInputIntentAsync)(input.perceivedText, input.requestContext, this.ear?.classifyIntent
-            ? (t, c) => this.ear.classifyIntent(t, c)
-            : undefined);
-        // 3. Concurrent Knowledge & Memory retrieval with diagnostics & evidence handling
-        const contextRetrieval = await (0, context_retriever_1.retrieveRuntimeContext)({
+        const context = {
             companionId: this.id,
-            perceivedText: input.perceivedText,
-            requestContext: input.requestContext,
-            role: input.role,
-            isContextObject: input.isContextObject,
-            shouldQueryKnowledge: intent.shouldQueryKnowledge,
-            knowledge: this.knowledge,
-            memory: this.memory,
-            self: this.self,
-            externalKnowledge: this.externalKnowledge,
-        });
-        // 4. Neutral system prompt and contextual prompt compilation
-        const prompts = await (0, prompt_compiler_1.compilePrompts)({
-            companionName: this.config.name,
-            companionId: this.id,
-            role: input.role,
-            requestContext: input.requestContext,
-            behavior: this.behavior,
-            activeDirectives: contextRetrieval.activeDirectives,
-            subsystemDiagnostics: contextRetrieval.subsystemDiagnostics,
-            knowledgeData: contextRetrieval.knowledgeData,
-            memoryData: contextRetrieval.memoryData,
-            lifeContext: contextRetrieval.lifeContext,
-        });
-        // 5. Cognition planning via BrainOrgan
-        const plan = await (0, cognition_planner_1.generateCognitionPlan)({
             companionName: this.config.name,
-            brain: this.brain,
-            systemPrompt: prompts.systemPrompt,
-            contextPrompt: prompts.contextPrompt,
-            recentMessages: this.sessionHistory.getHistory(sessionKey).slice(-10),
-            recipient: input.role,
-            perceivedText: input.perceivedText,
-        });
-        // 6. Stage response and evaluate safety gating boundary
-        const stagedPlan = this.gating.stageResponse({
-            requestContext: input.requestContext,
-            candidateSpeech: plan.speech,
-            candidateLanguage: plan.language || 'ja',
-            internalMonologue: plan.internalMonologue,
-            memoryProposals: plan.memoryProposals,
-            behaviorProposals: plan.behaviorProposals,
-            evidenceRecords: contextRetrieval.collectedEvidence,
-            citations: contextRetrieval.citations,
-        });
-        const gateEval = this.gating.evaluateGate(stagedPlan, contextRetrieval.collectedEvidence);
-        if (!gateEval.admissible) {
-            return (0, response_envelope_1.createGateRejectionEnvelope)(stagedPlan, gateEval);
-        }
-        this.sessionHistory.append(sessionKey, { role: 'assistant', content: plan.speech });
-        this.sessionHistory.append('default', { role: 'assistant', content: plan.speech });
-        // 7. Settle memory proposals and persist source events
-        const memorySettlement = await (0, memory_settler_1.settleMemoryProposals)({
-            companionId: this.id,
-            perceivedText: input.perceivedText,
-            role: input.role,
-            requestContext: input.requestContext,
-            memory: this.memory,
-            explicitTeaching: intent.explicitTeaching,
-            plan,
-        });
-        // 8. Authorize and execute action intents under Primary Security Invariant
-        const actionResults = await (0, action_executor_1.executeActionIntents)({
-            actionIntents: plan.actionIntents,
-            requestContext: input.requestContext,
-            actionPolicy: this.actionPolicy,
-            hands: this.hands,
-        });
-        // 9. Dispatch ExperienceEvents to registered adapters
-        const experienceEmission = await (0, experience_emitter_1.emitExperienceEvents)({
-            companionId: this.id,
-            requestContext: input.requestContext,
-            stagedPlan,
-            gateEval,
-            speech: plan.speech,
-            language: plan.language || 'ja',
-            dispatcher: this.dispatcher,
-            voice: this.voice,
-            body: this.body,
-        });
-        // 10. Deliver utterance via Mouth organ (UI / Output Channel Decoupling)
-        let mouthDelivery;
-        if (this.mouth && typeof this.mouth.speak === 'function') {
-            try {
-                const avatarEvent = experienceEmission.experienceEvents.find((e) => e.kind === 'avatar');
-                mouthDelivery = await this.mouth.speak({
-                    utteranceId: stagedPlan.responseId,
-                    companionId: this.id,
-                    responseId: stagedPlan.responseId,
-                    correlationId: stagedPlan.correlationId,
-                    text: plan.speech,
-                    language: plan.language || 'ja',
-                    subtitleJa: plan.speech,
-                    subtitleEn: plan.speech,
-                    spokenJa: plan.speech,
-                    expression: avatarEvent?.expression,
-                    medium: perception.medium,
-                    signal: perception.signal,
-                    audioUrl: experienceEmission.speechId
-                        ? `/voice/stream?id=${experienceEmission.speechId}`
-                        : undefined,
-                    metadata: {
-                        subsystemDiagnostics: contextRetrieval.subsystemDiagnostics,
-                        internalMonologue: plan.internalMonologue,
-                    },
-                    citations: gateEval.filteredCitations,
-                    evidenceIds: gateEval.filteredEvidenceIds,
-                });
-            }
-            catch (e) {
-                console.error('[SiduriRuntime] Mouth delivery failed:', e?.message || e);
-            }
-        }
-        // 11. Assemble and return response envelope
-        return (0, response_envelope_1.assembleResponseEnvelope)({
-            stagedPlan,
-            speech: plan.speech,
-            language: plan.language,
-            speechId: experienceEmission.speechId,
-            createdMemoryProposals: memorySettlement.createdMemoryProposals,
-            memoryProposalReceipts: memorySettlement.memoryProposalReceipts,
-            actionResults,
-            filteredEvidenceIds: gateEval.filteredEvidenceIds,
-            filteredCitations: gateEval.filteredCitations,
-            subsystemDiagnostics: contextRetrieval.subsystemDiagnostics,
-            experienceEvents: experienceEmission.experienceEvents,
-            mouthDelivery,
-        });
-    }
-    // --- Mouth Facades ---
-    async speakMouth(utterance) {
-        if (!this.mouth || typeof this.mouth.speak !== 'function')
-            return undefined;
-        return this.mouth.speak(utterance);
-    }
-    formatMouth(utterance, medium) {
-        if (!this.mouth || typeof this.mouth.format !== 'function')
-            return undefined;
-        return this.mouth.format(utterance, medium);
-    }
-    registerMouthChannel(channel) {
-        if (this.mouth && typeof this.mouth.registerChannel === 'function') {
-            this.mouth.registerChannel(channel);
-        }
+            perception,
+            organs: this.container.organs,
+            gating: this.container.gating,
+            actionPolicy: this.container.actionPolicy,
+            dispatcher: this.container.dispatcher,
+            sessionHistory: this.container.sessionHistory,
+            rawText: perception.text || '',
+        };
+        return this.pipeline.execute(context);
     }
-    unregisterMouthChannel(channelId) {
-        if (this.mouth && typeof this.mouth.unregisterChannel === 'function') {
-            this.mouth.unregisterChannel(channelId);
-        }
-    }
-    async broadcastMouth(utterance) {
-        if (!this.mouth || typeof this.mouth.broadcast !== 'function')
-            return [];
-        return this.mouth.broadcast(utterance);
-    }
-    interruptMouth(reason) {
-        if (this.mouth && typeof this.mouth.interrupt === 'function') {
-            this.mouth.interrupt(reason);
-        }
-    }
-    streamMouth(utterance) {
-        if (!this.mouth || typeof this.mouth.stream !== 'function') {
-            return (async function* () {
-                yield {
-                    utteranceId: utterance.utteranceId,
-                    index: 0,
-                    deltaText: utterance.text,
-                    isComplete: true,
-                    medium: 'web',
-                };
-            })();
-        }
-        return this.mouth.stream(utterance);
-    }
-    // --- Backward-Compatible Chat Adapter ---
+    /**
+     * Primary entrypoint for text chat messages.
+     */
     async handleUserMessage(message, roleOrContext = 'OWNER', history = [], medium, signal) {
         return this.processPerception({
             source: 'text_chat',

package/dist/schema-validator.test.js

@@ -31,7 +31,7 @@ describe('validateCompanionConfig', () => {
                         properties: {
                             provider: {
                                 type: 'string',
-                                enum: ['postgres', 'in-memory', 'none'],
+                                enum: ['sqlite', 'in-memory', 'none'],
                             },
                             maxConnections: { type: 'number' },
                         },
@@ -107,7 +107,7 @@ describe('validateCompanionConfig', () => {
             name: 'Test',
             organs: {
                 memory: {
-                    provider: 'postgres',
+                    provider: 'sqlite',
                     maxConnections: 'ten', // should be number
                 },
             },

package/dist/siduri-db.d.ts

@@ -17,10 +17,10 @@ export interface SelfDirective {
     companionId: string;
     priority: number;
     directive: string;
-    status: 'ACTIVE' | 'DISABLED' | 'SUPERSEDED';
-    category: 'behavioral' | 'guardrail' | 'relational';
+    status: 'PENDING' | 'ACTIVE' | 'DISABLED' | 'SUPERSEDED' | 'REJECTED' | 'REVOKED' | 'EXPIRED';
+    category: 'behavioral' | 'guardrail' | 'relational' | string;
     supersedesId?: string;
-    createdAt: string;
+    createdAt?: string;
 }
 export interface SelfRelationship {
     companionId: string;
@@ -77,12 +77,14 @@ export interface MemoryClaim {
     subject: string;
     predicate: string;
     value: string;
-    status: 'PENDING' | 'APPROVED' | 'REJECTED';
+    status: 'PENDING' | 'APPROVED' | 'REJECTED' | 'SESSION_ONLY' | 'SUPERSEDED' | 'REVOKED' | 'EXPIRED';
     confidence: number;
     validFrom?: string;
     validUntil?: string;
     evidence?: string[];
     assertedAt: string;
+    supersedes?: string;
+    sourceEventId?: string;
 }
 export interface SiduriDatabaseOptions {
     dbPath?: string;
@@ -98,7 +100,12 @@ export declare class SiduriDatabase {
     setPersonality(companionId: string, traits: PersonalityTraits): void;
     getActiveDirectives(companionId: string): SelfDirective[];
     commitDirective(directive: SelfDirective): void;
-    disableDirective(id: string): void;
+    getDirective(id: string, companionId?: string): SelfDirective | undefined;
+    approveDirective(id: string, companionId?: string): void;
+    rejectDirective(id: string, companionId?: string): void;
+    revokeDirective(id: string, companionId?: string): void;
+    expireDirective(id: string, companionId?: string): void;
+    disableDirective(id: string, companionId?: string): void;
     getRelationship(companionId: string, entityId: string): SelfRelationship | undefined;
     upsertRelationship(rel: SelfRelationship): void;
     getInventory(companionId: string, domain?: string): LifeInventoryItem[];
@@ -111,9 +118,21 @@ export declare class SiduriDatabase {
     upsertPreference(pref: LifePreference): void;
     recordEvent(event: EpisodicEvent): void;
     getRecentEvents(companionId: string, limit?: number): EpisodicEvent[];
-    proposeClaim(claim: Omit<MemoryClaim, 'status'>): MemoryClaim;
-    approveClaim(id: string): void;
-    rejectClaim(id: string): void;
+    getEvent(id: string): EpisodicEvent | undefined;
+    proposeClaim(claim: Omit<MemoryClaim, 'status' | 'confidence' | 'assertedAt'> & {
+        confidence?: number;
+        assertedAt?: string;
+        supersedes?: string;
+        sourceEventId?: string;
+    }): MemoryClaim;
+    approveClaim(id: string, companionId?: string): void;
+    rejectClaim(id: string, companionId?: string): void;
+    revokeClaim(id: string, companionId?: string): void;
+    expireClaim(id: string, companionId?: string): void;
+    markClaimSessionOnly(id: string, companionId?: string): void;
     searchClaims(companionId: string, query: string, limit?: number): MemoryClaim[];
+    getPendingClaims(companionId: string, limit?: number): MemoryClaim[];
     getApprovedClaims(companionId: string, limit?: number): MemoryClaim[];
+    getClaim(id: string): MemoryClaim | undefined;
+    resetMemory(companionId: string): void;
 }