@siduri-x/core 1.0.5 → 1.0.7

package/dist/response-envelope.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGateRejectionEnvelope = createGateRejectionEnvelope;
+exports.assembleResponseEnvelope = assembleResponseEnvelope;
+/**
+ * Creates the standardized rejection envelope for responses that fail gate evaluation.
+ */
+function createGateRejectionEnvelope(stagedPlan, gateEval) {
+    return {
+        status: gateEval.disposition,
+        reasonCode: gateEval.reasonCode,
+        response_id: stagedPlan.responseId,
+        correlation_id: stagedPlan.correlationId,
+        response: {
+            subtitle_ja: undefined,
+            subtitle_en: undefined,
+        },
+        metadata: {
+            requires_approval: stagedPlan.requiresApproval,
+            staged: true,
+            confidence: stagedPlan.confidenceSummary,
+            uncertainty: stagedPlan.uncertaintySummary,
+            proposals: [],
+            memory_proposals: [],
+        },
+    };
+}
+/**
+ * Assembles the standardized response structure for approved companion responses.
+ */
+function assembleResponseEnvelope(params) {
+    const { stagedPlan, speech, language, speechId, createdMemoryProposals, memoryProposalReceipts, actionResults, filteredEvidenceIds, filteredCitations, subsystemDiagnostics, experienceEvents, mouthDelivery, } = params;
+    return {
+        status: 'APPROVED',
+        response_id: stagedPlan.responseId,
+        correlation_id: stagedPlan.correlationId,
+        response: {
+            speech_id: speechId,
+            audio_url: mouthDelivery?.audioUrl ?? (speechId ? `/voice/stream?id=${speechId}` : undefined),
+            subtitle_ja: mouthDelivery?.subtitles?.ja ?? speech,
+            subtitle_en: mouthDelivery?.subtitles?.en ?? speech,
+        },
+        delivery: mouthDelivery,
+        metadata: {
+            language,
+            proposals: createdMemoryProposals,
+            memory_proposals: memoryProposalReceipts,
+            action_results: actionResults,
+            evidence_ids: filteredEvidenceIds,
+            citations: filteredCitations,
+            subsystem_diagnostics: Object.keys(subsystemDiagnostics).length > 0
+                ? subsystemDiagnostics
+                : undefined,
+            events: experienceEvents.map((e) => ({
+                event_id: e.eventId,
+                kind: e.kind,
+                lifecycle: e.lifecycle,
+                approval: e.approval,
+                expression: e.expression,
+                action: e.action,
+            })),
+        },
+    };
+}

package/dist/runtime-facades.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime-facades.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("./runtime");
+describe('SiduriRuntime Facade Methods & Delegation', () => {
+    test('delegates vision and observation methods to configured organs', async () => {
+        const mockVision = {
+            analyze: jest.fn().mockResolvedValue('an ancient artifact'),
+        };
+        const mockObservation = {
+            ingest: jest.fn().mockResolvedValue({ duplicate: false }),
+            current: jest.fn().mockReturnValue([{ observationId: 'obs-1' }]),
+            clearExpired: jest.fn().mockReturnValue(1),
+        };
+        const runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test' }, {
+            vision: mockVision,
+            observation: mockObservation,
+        });
+        const visionResult = await runtime.analyzeVision('http://example.com/img.png', 'describe');
+        expect(visionResult).toBe('an ancient artifact');
+        expect(mockVision.analyze).toHaveBeenCalledWith('http://example.com/img.png', 'describe');
+        const frame = new Uint8Array([1, 2, 3]);
+        const obsResult = await runtime.ingestObservation(frame, 'camera-1', 'provider-x');
+        expect(obsResult.duplicate).toBe(false);
+        expect(mockObservation.ingest).toHaveBeenCalledWith(frame, 'camera-1', 'provider-x');
+        const cur = runtime.getCurrentObservations();
+        expect(cur).toEqual([{ observationId: 'obs-1' }]);
+        const cleared = runtime.clearExpiredObservations();
+        expect(cleared).toBe(1);
+    });
+    test('delegates memory operations cleanly through facade methods', async () => {
+        const mockMemory = {
+            initialize: jest.fn().mockResolvedValue(undefined),
+            getClaims: jest.fn().mockResolvedValue([{ id: 'claim-1' }]),
+            getPendingClaims: jest.fn().mockResolvedValue([{ id: 'claim-pending-1' }]),
+            getDirectives: jest.fn().mockResolvedValue([{ id: 'dir-1' }]),
+            approveClaim: jest.fn().mockResolvedValue(undefined),
+            rejectClaim: jest.fn().mockResolvedValue(undefined),
+            updateClaim: jest.fn().mockResolvedValue({ id: 'claim-1', value: 'updated' }),
+            approveDirective: jest.fn().mockResolvedValue(undefined),
+            rejectDirective: jest.fn().mockResolvedValue(undefined),
+            revokeDirective: jest.fn().mockResolvedValue(undefined),
+            disableDirective: jest.fn().mockResolvedValue(undefined),
+            resetMemory: jest.fn().mockResolvedValue(undefined),
+        };
+        const runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test' }, {
+            memory: mockMemory,
+        });
+        expect(await runtime.getClaims(10)).toEqual([{ id: 'claim-1' }]);
+        expect(mockMemory.getClaims).toHaveBeenCalledWith(10);
+        expect(await runtime.getPendingClaims()).toEqual([{ id: 'claim-pending-1' }]);
+        expect(await runtime.getDirectives()).toEqual([{ id: 'dir-1' }]);
+        await runtime.approveClaim('c-1');
+        expect(mockMemory.approveClaim).toHaveBeenCalledWith('c-1');
+        await runtime.rejectClaim('c-2');
+        expect(mockMemory.rejectClaim).toHaveBeenCalledWith('c-2');
+        await runtime.updateClaim('c-1', { value: 'new' });
+        expect(mockMemory.updateClaim).toHaveBeenCalledWith('c-1', { value: 'new' });
+        await runtime.approveDirective('d-1');
+        expect(mockMemory.approveDirective).toHaveBeenCalledWith('d-1');
+        await runtime.rejectDirective('d-2');
+        expect(mockMemory.rejectDirective).toHaveBeenCalledWith('d-2');
+        await runtime.revokeDirective('d-3');
+        expect(mockMemory.revokeDirective).toHaveBeenCalledWith('d-3');
+        await runtime.disableDirective('d-4');
+        expect(mockMemory.disableDirective).toHaveBeenCalledWith('d-4');
+        await runtime.resetMemory();
+        expect(mockMemory.resetMemory).toHaveBeenCalled();
+    });
+});

package/dist/runtime.d.ts

@@ -0,0 +1,114 @@
+import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, ObservationResult, Observation, Message, RequestContext, ActionPolicyEngine, ResponseGatingEngine, StageResponseOptions, ApproveResponseOptions, RejectResponseOptions, ExperienceDispatcher, ExperienceAdapter, OrganConfig, Claim, BehaviorDirective, StagedResponsePlan, ResponseGateEvaluation, EvidenceRecord, MouthOrgan, MouthUtterance, MouthMedium, FormattedMouthOutput, MouthStreamChunk, MouthChannel } from './index';
+export interface SiduriRuntimeConfig {
+    name: string;
+    brain?: OrganConfig | Record<string, unknown>;
+    voice?: OrganConfig | Record<string, unknown>;
+    memory?: OrganConfig | Record<string, unknown>;
+    knowledge?: OrganConfig | Record<string, unknown>;
+    behavior?: OrganConfig | Record<string, unknown>;
+    body?: OrganConfig | Record<string, unknown>;
+    vision?: OrganConfig | Record<string, unknown>;
+    hands?: OrganConfig | Record<string, unknown>;
+    ear?: OrganConfig | Record<string, unknown>;
+    observation?: OrganConfig | Record<string, unknown>;
+    mouth?: OrganConfig | Record<string, unknown>;
+    actionPolicy?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface RuntimeOrgans {
+    brain?: BrainOrgan;
+    memory?: MemoryOrgan;
+    voice?: VoiceOrgan | ExperienceAdapter;
+    knowledge?: KnowledgeOrgan;
+    vision?: VisionOrgan;
+    behavior?: BehaviorOrgan;
+    body?: BodyOrgan | ExperienceAdapter;
+    hands?: HandsOrgan;
+    ear?: EarOrgan;
+    observation?: ObservationOrgan;
+    mouth?: MouthOrgan;
+    actionPolicy?: ActionPolicyEngine;
+}
+export interface CompanionPerception {
+    source: string;
+    text?: string;
+    audioBuffer?: Uint8Array;
+    roleOrContext?: 'OWNER' | 'VIEWER' | 'OPERATOR' | RequestContext | string;
+    context?: RequestContext;
+    history?: Message[];
+    medium?: MouthMedium;
+    metadata?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+/**
+ * SiduriRuntime coordinates companion lifecycle, sensory perception,
+ * context retrieval, cognition planning, safety gating, action execution,
+ * and experience emission across decoupled organs.
+ */
+export declare class SiduriRuntime {
+    id: string;
+    config: SiduriRuntimeConfig;
+    brain?: BrainOrgan;
+    memory?: MemoryOrgan;
+    voice?: VoiceOrgan | ExperienceAdapter;
+    knowledge?: KnowledgeOrgan;
+    vision?: VisionOrgan;
+    behavior?: BehaviorOrgan;
+    body?: BodyOrgan | ExperienceAdapter;
+    hands?: HandsOrgan;
+    ear?: EarOrgan;
+    observation?: ObservationOrgan;
+    mouth?: MouthOrgan;
+    gating: ResponseGatingEngine;
+    actionPolicy: ActionPolicyEngine;
+    dispatcher: ExperienceDispatcher;
+    private readonly sessionHistory;
+    get conversationHistory(): Message[];
+    set conversationHistory(messages: Message[]);
+    constructor(id: string, config: SiduriRuntimeConfig, organs?: RuntimeOrgans);
+    initialize(): Promise<void>;
+    getSessionHistory(sessionKey: string): Message[];
+    clearHistory(sessionKey?: string): void;
+    analyzeVision(imageUrl: string, prompt: string): Promise<string>;
+    ingestObservation(frame: Uint8Array, sourceName: string, providerId?: string): Promise<ObservationResult>;
+    getCurrentObservations(now?: Date): Observation[];
+    clearExpiredObservations(now?: Date): number;
+    getClaims(limit?: number): Promise<Claim[]>;
+    getPendingClaims(limit?: number): Promise<Claim[]>;
+    getDirectives(): Promise<BehaviorDirective[]>;
+    approveClaim(id: string): Promise<void>;
+    rejectClaim(id: string): Promise<void>;
+    updateClaim(id: string, updates: Partial<Pick<Claim, 'subject' | 'predicate' | 'value' | 'scope' | 'sensitivity' | 'confidence' | 'validFrom' | 'validUntil'>>): Promise<Claim>;
+    approveDirective(id: string): Promise<void>;
+    rejectDirective(id: string): Promise<void>;
+    revokeDirective(id: string): Promise<void>;
+    disableDirective(id: string): Promise<void>;
+    resetMemory(): Promise<void>;
+    stageResponse(options: StageResponseOptions): StagedResponsePlan;
+    evaluateGate(plan: StagedResponsePlan, evidenceRecords?: EvidenceRecord[]): ResponseGateEvaluation;
+    approveResponse(options: ApproveResponseOptions): {
+        success: boolean;
+        reason?: string;
+        plan?: StagedResponsePlan;
+    };
+    rejectResponse(options: RejectResponseOptions): {
+        success: boolean;
+        reason?: string;
+        plan?: StagedResponsePlan;
+    };
+    getStagedPlan(responseId: string): StagedResponsePlan | undefined;
+    findStagedPlanByCorrelation(companionId: string, correlationId: string): StagedResponsePlan | undefined;
+    /**
+     * Processes an incoming perception (sensory audio, text, platform event, or observation alert)
+     * through the perception -> retrieval -> cognition -> gating -> action -> experience cycle.
+     */
+    processPerception(perception: CompanionPerception): Promise<any>;
+    speakMouth(utterance: MouthUtterance): Promise<FormattedMouthOutput | undefined>;
+    formatMouth(utterance: MouthUtterance, medium?: MouthMedium): FormattedMouthOutput | undefined;
+    registerMouthChannel(channel: MouthChannel): void;
+    unregisterMouthChannel(channelId: string): void;
+    broadcastMouth(utterance: MouthUtterance): Promise<FormattedMouthOutput[]>;
+    interruptMouth(reason?: string): void;
+    streamMouth(utterance: MouthUtterance): AsyncIterable<MouthStreamChunk>;
+    handleUserMessage(message: string, roleOrContext?: 'OWNER' | 'VIEWER' | 'OPERATOR' | RequestContext | string, history?: Message[], medium?: MouthMedium, signal?: AbortSignal): Promise<any>;
+}

package/dist/runtime.js

@@ -0,0 +1,412 @@
+"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");
+/**
+ * SiduriRuntime coordinates companion lifecycle, sensory perception,
+ * context retrieval, cognition planning, safety gating, action execution,
+ * and experience emission across decoupled organs.
+ */
+class SiduriRuntime {
+    id;
+    config;
+    brain;
+    memory;
+    voice;
+    knowledge;
+    vision;
+    behavior;
+    body;
+    hands;
+    ear;
+    observation;
+    mouth;
+    gating;
+    actionPolicy;
+    dispatcher;
+    sessionHistory = new session_history_1.SessionHistoryManager();
+    // Backward-compatible getter/setter for conversation history
+    get conversationHistory() {
+        return this.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.gating = new index_1.ResponseGatingEngine();
+        this.actionPolicy = organs.actionPolicy || new index_1.ActionPolicyEngine();
+        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);
+        }
+    }
+    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);
+            }
+        }
+    }
+    // --- Session History Accessors ---
+    getSessionHistory(sessionKey) {
+        return this.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);
+    }
+    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.
+     */
+    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.audienceId ||
+            '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)({
+            companionId: this.id,
+            perceivedText: input.perceivedText,
+            requestContext: input.requestContext,
+            role: input.role,
+            isContextObject: input.isContextObject,
+            shouldQueryKnowledge: intent.shouldQueryKnowledge,
+            knowledge: this.knowledge,
+            memory: this.memory,
+        });
+        // 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,
+        });
+        // 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);
+        }
+    }
+    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 ---
+    async handleUserMessage(message, roleOrContext = 'OWNER', history = [], medium, signal) {
+        return this.processPerception({
+            source: 'text_chat',
+            text: message,
+            roleOrContext,
+            history,
+            medium,
+            signal,
+        });
+    }
+}
+exports.SiduriRuntime = SiduriRuntime;

package/dist/session-history.d.ts

@@ -0,0 +1,20 @@
+import { Message } from './index';
+export interface SessionHistoryOptions {
+    maxSessions?: number;
+    maxMessagesPerSession?: number;
+}
+/**
+ * Manages conversation history scoped by session key to prevent cross-session
+ * and cross-channel memory/conversation leakage.
+ */
+export declare class SessionHistoryManager {
+    private readonly sessions;
+    private readonly maxSessions;
+    private readonly maxMessagesPerSession;
+    constructor(options?: SessionHistoryOptions);
+    getHistory(sessionKey?: string): Message[];
+    setHistory(sessionKey: string | undefined, history: Message[]): void;
+    append(sessionKey: string | undefined, message: Message): void;
+    clear(sessionKey?: string): void;
+    sessionCount(): number;
+}