@sidurijs/core 1.0.0

package/dist/perception-cycle.test.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("./runtime");
+describe('SiduriRuntime Unified Perception Cycle & Session History', () => {
+    test('processPerception runs sensory perception through the complete cognition-action loop', async () => {
+        const mockBrain = {
+            generatePlan: jest.fn().mockResolvedValue({
+                speech: 'Perception processed successfully',
+                language: 'en',
+            }),
+        };
+        const runtime = new runtime_1.SiduriRuntime('comp-perception', { name: 'PerceptionBot' }, {
+            brain: mockBrain,
+        });
+        const context = {
+            companionId: 'comp-perception',
+            actor: {
+                actorId: 'operator-alice',
+                sessionId: 'sess-alice-1',
+                authorizationRole: 'operator',
+                capabilities: ['chat:public'],
+                authenticated: true,
+            },
+            conversation: {
+                channel: 'direct',
+                correlationId: 'corr-perc-1',
+            },
+        };
+        const response = await runtime.processPerception({
+            source: 'audio_stream',
+            text: 'Hello from sensory stream',
+            context,
+        });
+        expect(response.status).toBe('APPROVED');
+        expect(response.response.subtitle_en).toBe('Perception processed successfully');
+        expect(mockBrain.generatePlan).toHaveBeenCalled();
+        // Session history should be recorded under sess-alice-1
+        const aliceHistory = runtime.getSessionHistory('sess-alice-1');
+        expect(aliceHistory).toHaveLength(2);
+        expect(aliceHistory[0]).toEqual({ role: 'user', content: 'Hello from sensory stream' });
+        expect(aliceHistory[1]).toEqual({ role: 'assistant', content: 'Perception processed successfully' });
+    });
+    test('processPerception transcribes raw audioBuffer when EarOrgan supports it', async () => {
+        const mockEar = {
+            listen: jest.fn().mockImplementation(async (source, payload) => ({
+                id: 'p-1',
+                source,
+                text: payload,
+                timestamp: new Date().toISOString(),
+            })),
+            transcribeAudio: jest.fn().mockResolvedValue('transcribed voice instruction'),
+        };
+        const mockBrain = {
+            generatePlan: jest.fn().mockResolvedValue({
+                speech: 'Understood audio',
+                language: 'en',
+            }),
+        };
+        const runtime = new runtime_1.SiduriRuntime('comp-audio', { name: 'AudioBot' }, {
+            ear: mockEar,
+            brain: mockBrain,
+        });
+        const audioBytes = new Uint8Array([1, 2, 3, 4]);
+        const response = await runtime.processPerception({
+            source: 'microphone',
+            audioBuffer: audioBytes,
+        });
+        expect(mockEar.transcribeAudio).toHaveBeenCalledWith(audioBytes);
+        expect(response.status).toBe('APPROVED');
+        expect(response.response.subtitle_en).toBe('Understood audio');
+    });
+    test('isolates conversation histories across concurrent sessions', async () => {
+        const mockBrain = {
+            generatePlan: jest.fn().mockImplementation(async (args) => ({
+                speech: `Reply to ${args.recentMessages[args.recentMessages.length - 1].content}`,
+                language: 'en',
+            })),
+        };
+        const runtime = new runtime_1.SiduriRuntime('comp-multi', { name: 'MultiSessionBot' }, {
+            brain: mockBrain,
+        });
+        const aliceContext = {
+            companionId: 'comp-multi',
+            actor: {
+                actorId: 'alice',
+                sessionId: 'session-alice',
+                authorizationRole: 'operator',
+                capabilities: ['chat:public'],
+                authenticated: true,
+            },
+            conversation: { channel: 'direct', correlationId: 'c1' },
+        };
+        const bobContext = {
+            companionId: 'comp-multi',
+            actor: {
+                actorId: 'bob',
+                sessionId: 'session-bob',
+                authorizationRole: 'viewer',
+                capabilities: ['chat:public'],
+                authenticated: false,
+            },
+            conversation: { channel: 'public', correlationId: 'c2' },
+        };
+        await runtime.handleUserMessage('Alice secret message', aliceContext);
+        await runtime.handleUserMessage('Bob public query', bobContext);
+        const aliceHistory = runtime.getSessionHistory('session-alice');
+        const bobHistory = runtime.getSessionHistory('session-bob');
+        expect(aliceHistory.map((m) => m.content)).toContain('Alice secret message');
+        expect(aliceHistory.map((m) => m.content)).not.toContain('Bob public query');
+        expect(bobHistory.map((m) => m.content)).toContain('Bob public query');
+        expect(bobHistory.map((m) => m.content)).not.toContain('Alice secret message');
+    });
+    test('prioritizes native evidenceRecord from knowledge items over synthetic generation', async () => {
+        const nativeEvidence = {
+            evidenceId: 'ev-native-provenance-100',
+            sourceId: 'src-e-teyvat-canon',
+            documentId: 'doc-archon-war',
+            chunkId: 'chunk-3',
+            locator: 'p.42',
+            revision: 'rev-2026',
+            origin: 'knowledge',
+            trust: 'configured',
+            sensitivity: 'public',
+            companionId: 'comp-native-ev',
+            correlationId: 'corr-test',
+            createdAt: new Date().toISOString(),
+        };
+        const mockKnowledge = {
+            search: jest.fn().mockResolvedValue([
+                {
+                    content: 'The Archon War ended centuries ago.',
+                    provenance: 'src-e-teyvat-canon',
+                    revision: 'rev-2026',
+                    citations: [],
+                    evidenceRecord: nativeEvidence,
+                },
+            ]),
+        };
+        const mockBrain = {
+            generatePlan: jest.fn().mockResolvedValue({
+                speech: 'The war concluded centuries ago.',
+                language: 'en',
+            }),
+        };
+        const runtime = new runtime_1.SiduriRuntime('comp-native-ev', { name: 'EvBot' }, {
+            knowledge: mockKnowledge,
+            brain: mockBrain,
+        });
+        const response = await runtime.handleUserMessage('When did the Archon War end?', 'OWNER');
+        expect(response.status).toBe('APPROVED');
+        expect(response.metadata.evidence_ids).toContain('ev-native-provenance-100');
+    });
+    describe('Three Interaction Modes Execution (Casual, Teach, Hybrid)', () => {
+        test('Casual Mode enforces Zero Memory Drift: suppresses all memory/directive proposals', async () => {
+            const mockMemory = {
+                proposeClaim: jest.fn(),
+                proposeDirective: jest.fn(),
+                addSourceEvent: jest.fn(),
+            };
+            const mockBrain = {
+                generatePlan: jest.fn().mockResolvedValue({
+                    speech: 'Got it, Alice.',
+                    language: 'en',
+                    memoryProposals: [
+                        { subject: 'actor:alice', predicate: 'mood', value: 'happy' },
+                    ],
+                }),
+            };
+            const runtime = new runtime_1.SiduriRuntime('comp-casual', { name: 'CasualBot' }, {
+                memory: mockMemory,
+                brain: mockBrain,
+            });
+            const casualContext = {
+                companionId: 'comp-casual',
+                mode: 'casual',
+                actor: {
+                    actorId: 'alice',
+                    sessionId: 'sess-casual',
+                    authenticated: true,
+                },
+                conversation: {
+                    channel: 'direct',
+                    correlationId: 'corr-casual-1',
+                },
+            };
+            // User says a teaching statement in Casual mode
+            const response = await runtime.processPerception({
+                source: 'text_chat',
+                text: 'Remember that my name is Alice and I love coffee',
+                context: casualContext,
+            });
+            expect(response.status).toBe('APPROVED');
+            expect(response.metadata.mode).toBe('casual');
+            // ZERO writes to memory: no source events, no proposed claims
+            expect(mockMemory.addSourceEvent).not.toHaveBeenCalled();
+            expect(mockMemory.proposeClaim).not.toHaveBeenCalled();
+            expect(mockMemory.proposeDirective).not.toHaveBeenCalled();
+            expect(response.metadata.proposals).toHaveLength(0);
+            expect(response.metadata.memory_proposals).toHaveLength(0);
+        });
+        test('Teach Mode persists proposals and reflects mode in metadata', async () => {
+            const mockMemory = {
+                proposeClaim: jest.fn().mockImplementation(async (c) => ({
+                    id: 'claim-prop-1',
+                    ...c,
+                    status: 'PENDING',
+                })),
+                proposeDirective: jest.fn().mockResolvedValue(undefined),
+                addSourceEvent: jest.fn().mockResolvedValue(undefined),
+            };
+            const mockBrain = {
+                generatePlan: jest.fn().mockResolvedValue({
+                    speech: 'I have recorded your preferred title as Chief Engineer.',
+                    language: 'en',
+                    memoryProposals: [
+                        {
+                            subject: 'actor:alice',
+                            predicate: 'preferred_address',
+                            value: 'Chief Engineer',
+                        },
+                    ],
+                }),
+            };
+            const runtime = new runtime_1.SiduriRuntime('comp-teach', { name: 'TeachBot' }, {
+                memory: mockMemory,
+                brain: mockBrain,
+            });
+            const teachContext = {
+                companionId: 'comp-teach',
+                mode: 'teach',
+                actor: {
+                    actorId: 'alice',
+                    sessionId: 'sess-teach',
+                    authenticated: true,
+                },
+                conversation: {
+                    channel: 'direct',
+                    correlationId: 'corr-teach-1',
+                },
+            };
+            const response = await runtime.processPerception({
+                source: 'text_chat',
+                text: 'From now on, call me Chief Engineer',
+                context: teachContext,
+            });
+            expect(response.status).toBe('APPROVED');
+            expect(response.metadata.mode).toBe('teach');
+            expect(mockMemory.proposeClaim).toHaveBeenCalled();
+            expect(response.metadata.proposals).toHaveLength(1);
+        });
+        test('Infers Teach Mode semantically when user uses in-dialogue teaching command', async () => {
+            const mockMemory = {
+                proposeClaim: jest.fn().mockImplementation(async (c) => ({
+                    id: 'claim-prop-2',
+                    ...c,
+                    status: 'PENDING',
+                })),
+                proposeDirective: jest.fn().mockResolvedValue(undefined),
+                addSourceEvent: jest.fn().mockResolvedValue(undefined),
+            };
+            const mockBrain = {
+                generatePlan: jest.fn().mockResolvedValue({
+                    speech: 'Recorded the command.',
+                    language: 'en',
+                    memoryProposals: [
+                        {
+                            subject: 'companion:comp-infer',
+                            predicate: 'name',
+                            value: 'Atlas',
+                        },
+                    ],
+                }),
+            };
+            const runtime = new runtime_1.SiduriRuntime('comp-infer', { name: 'InferBot' }, {
+                memory: mockMemory,
+                brain: mockBrain,
+            });
+            // No explicit mode override in context
+            const defaultContext = {
+                companionId: 'comp-infer',
+                actor: {
+                    actorId: 'alice',
+                    sessionId: 'sess-infer',
+                    authenticated: true,
+                },
+                conversation: {
+                    channel: 'direct',
+                    correlationId: 'corr-infer-1',
+                },
+            };
+            const response = await runtime.processPerception({
+                source: 'text_chat',
+                text: 'remember that your name is Atlas',
+                context: { ...defaultContext, mode: 'teach' },
+            });
+            expect(response.status).toBe('APPROVED');
+            expect(response.metadata.mode).toBe('teach');
+            expect(mockMemory.proposeClaim).toHaveBeenCalled();
+        });
+    });
+});

package/dist/perception-pipeline.d.ts

@@ -0,0 +1,77 @@
+import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, Message, RequestContext, ActionPolicyEngine, ResponseGatingEngine, ExperienceDispatcher, ExperienceAdapter, StagedResponsePlan, ResponseGateEvaluation, MouthOrgan, MouthMedium, FormattedMouthOutput, SelfRepository, EKnowledgeOrgan, ActionExecutionResult, ResponsePlan } from './index';
+import { NormalizedInput } from './input-normalizer';
+import { IntentClassification } from './intent-classifier';
+import { RetrievedContext } from './context-retriever';
+import { CompiledPrompts } from './prompt-compiler';
+import { MemorySettlementResult } from './memory-settler';
+import { ExperienceEmissionResult } from './experience-emitter';
+import { SessionHistoryManager } from './session-history';
+export interface CompanionPerception {
+    source: string;
+    text?: string;
+    audioBuffer?: Uint8Array;
+    roleOrContext?: 'OWNER' | 'VIEWER' | 'OPERATOR' | RequestContext | string;
+    context?: RequestContext;
+    history?: Message[];
+    medium?: MouthMedium;
+    subtitleLanguage?: string;
+    metadata?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+export interface PerceptionPipelineContext {
+    companionId: string;
+    companionName: string;
+    perception: CompanionPerception;
+    organs: {
+        brain?: BrainOrgan;
+        memory?: MemoryOrgan;
+        voice?: VoiceOrgan | ExperienceAdapter;
+        knowledge?: KnowledgeOrgan;
+        vision?: VisionOrgan;
+        behavior?: BehaviorOrgan;
+        body?: BodyOrgan | ExperienceAdapter;
+        hands?: HandsOrgan;
+        ear?: EarOrgan;
+        observation?: ObservationOrgan;
+        mouth?: MouthOrgan;
+        self?: SelfRepository;
+        externalKnowledge?: EKnowledgeOrgan;
+    };
+    gating: ResponseGatingEngine;
+    actionPolicy: ActionPolicyEngine;
+    dispatcher: ExperienceDispatcher;
+    sessionHistory: SessionHistoryManager;
+    rawText?: string;
+    input?: NormalizedInput;
+    sessionKey?: string;
+    intent?: IntentClassification;
+    contextRetrieval?: RetrievedContext;
+    prompts?: CompiledPrompts;
+    plan?: ResponsePlan;
+    stagedPlan?: StagedResponsePlan;
+    gateEval?: ResponseGateEvaluation;
+    memorySettlement?: MemorySettlementResult;
+    actionResults?: ActionExecutionResult[];
+    experienceEmission?: ExperienceEmissionResult;
+    mouthDelivery?: FormattedMouthOutput;
+    responseEnvelope?: any;
+}
+export type PerceptionPipelineStage = (context: PerceptionPipelineContext) => Promise<boolean | void>;
+export declare class PerceptionPipeline {
+    readonly stages: PerceptionPipelineStage[];
+    constructor(stages: PerceptionPipelineStage[]);
+    execute(context: PerceptionPipelineContext): Promise<any>;
+}
+export declare const earTranscriptionStage: PerceptionPipelineStage;
+export declare const inputNormalizationStage: PerceptionPipelineStage;
+export declare const intentClassificationStage: PerceptionPipelineStage;
+export declare const contextRetrievalStage: PerceptionPipelineStage;
+export declare const promptCompilationStage: PerceptionPipelineStage;
+export declare const cognitionPlanningStage: PerceptionPipelineStage;
+export declare const responseGatingStage: PerceptionPipelineStage;
+export declare const memorySettlementStage: PerceptionPipelineStage;
+export declare const actionExecutionStage: PerceptionPipelineStage;
+export declare const experienceEmissionStage: PerceptionPipelineStage;
+export declare const mouthDeliveryStage: PerceptionPipelineStage;
+export declare const envelopeAssemblyStage: PerceptionPipelineStage;
+export declare function createDefaultPerceptionPipeline(): PerceptionPipeline;

package/dist/perception-pipeline.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envelopeAssemblyStage = exports.mouthDeliveryStage = exports.experienceEmissionStage = exports.actionExecutionStage = exports.memorySettlementStage = exports.responseGatingStage = exports.cognitionPlanningStage = exports.promptCompilationStage = exports.contextRetrievalStage = exports.intentClassificationStage = exports.inputNormalizationStage = exports.earTranscriptionStage = exports.PerceptionPipeline = void 0;
+exports.createDefaultPerceptionPipeline = createDefaultPerceptionPipeline;
+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");
+class PerceptionPipeline {
+    stages;
+    constructor(stages) {
+        this.stages = stages;
+    }
+    async execute(context) {
+        for (const stage of this.stages) {
+            const continueNext = await stage(context);
+            if (continueNext === false) {
+                break;
+            }
+        }
+        return context.responseEnvelope;
+    }
+}
+exports.PerceptionPipeline = PerceptionPipeline;
+// --- Individual Pipeline Stages ---
+const earTranscriptionStage = async (context) => {
+    let rawText = context.perception.text || '';
+    if (!rawText && context.perception.audioBuffer && context.organs.ear && typeof context.organs.ear.transcribeAudio === 'function') {
+        rawText = await context.organs.ear.transcribeAudio(context.perception.audioBuffer);
+    }
+    context.rawText = rawText;
+};
+exports.earTranscriptionStage = earTranscriptionStage;
+const inputNormalizationStage = async (context) => {
+    const roleOrContext = context.perception.context || context.perception.roleOrContext || 'OWNER';
+    const history = context.perception.history || [];
+    const input = await (0, input_normalizer_1.normalizeUserInput)(context.rawText || '', roleOrContext, history, context.companionId, context.organs.ear);
+    context.input = input;
+    const sessionKey = input.requestContext.actor.sessionId ||
+        input.requestContext.conversation.correlationId ||
+        'default';
+    context.sessionKey = sessionKey;
+    const currentMessage = { role: 'user', content: input.perceivedText };
+    const boundedSessionHistory = [...input.boundedHistory, currentMessage].slice(-20);
+    context.sessionHistory.setHistory(sessionKey, boundedSessionHistory);
+    context.sessionHistory.setHistory('default', boundedSessionHistory);
+};
+exports.inputNormalizationStage = inputNormalizationStage;
+const intentClassificationStage = async (context) => {
+    if (!context.input)
+        return;
+    // 1. If BrainOrgan supports cognitive retrieval planning, allow it to plan queries
+    let brainRetrievalPlan;
+    if (context.organs.brain && typeof context.organs.brain.planRetrieval === 'function') {
+        try {
+            const history = (context.perception.history && context.perception.history.length > 0)
+                ? context.perception.history
+                : context.sessionHistory.getHistory(context.sessionKey || 'default');
+            brainRetrievalPlan = await context.organs.brain.planRetrieval(context.input.perceivedText, context.input.requestContext, history);
+        }
+        catch (e) {
+            // Graceful fallback to Ear/Heuristics
+        }
+    }
+    const classifier = async (t, c) => {
+        if (brainRetrievalPlan) {
+            return {
+                ...brainRetrievalPlan,
+                classifierOrigin: 'brain',
+            };
+        }
+        if (context.organs.ear?.classifyIntent) {
+            return context.organs.ear.classifyIntent(t, c);
+        }
+        return {};
+    };
+    const intent = await (0, intent_classifier_1.classifyInputIntentAsync)(context.input.perceivedText, context.input.requestContext, classifier);
+    context.intent = intent;
+};
+exports.intentClassificationStage = intentClassificationStage;
+const contextRetrievalStage = async (context) => {
+    if (!context.input || !context.intent)
+        return;
+    const contextRetrieval = await (0, context_retriever_1.retrieveRuntimeContext)({
+        companionId: context.companionId,
+        perceivedText: context.input.perceivedText,
+        requestContext: context.input.requestContext,
+        role: context.input.role,
+        isContextObject: context.input.isContextObject,
+        shouldQueryKnowledge: context.intent.shouldQueryKnowledge,
+        knowledgeQueries: context.intent.knowledgeQueries,
+        memoryQueries: context.intent.memoryQueries,
+        isSelfIdentityRequest: context.intent.isSelfIdentityRequest,
+        knowledge: context.organs.knowledge,
+        memory: context.organs.memory,
+        self: context.organs.self,
+        externalKnowledge: context.organs.externalKnowledge,
+    });
+    context.contextRetrieval = contextRetrieval;
+};
+exports.contextRetrievalStage = contextRetrievalStage;
+const promptCompilationStage = async (context) => {
+    if (!context.input || !context.contextRetrieval)
+        return;
+    const effectiveCompanionName = context.contextRetrieval.selfIdentity?.name?.trim() || context.companionName;
+    const prompts = await (0, prompt_compiler_1.compilePrompts)({
+        companionName: effectiveCompanionName,
+        companionId: context.companionId,
+        role: context.input.role,
+        requestContext: context.input.requestContext,
+        behavior: context.organs.behavior,
+        activeDirectives: context.contextRetrieval.activeDirectives,
+        selfIdentity: context.contextRetrieval.selfIdentity,
+        selfRelationship: context.contextRetrieval.selfRelationship,
+        personality: context.contextRetrieval.personality,
+        subsystemDiagnostics: context.contextRetrieval.subsystemDiagnostics,
+        knowledgeData: context.contextRetrieval.knowledgeData,
+        memoryData: context.contextRetrieval.memoryData,
+        lifeContext: context.contextRetrieval.lifeContext,
+        effectiveMode: context.intent?.effectiveMode,
+        subtitleLanguage: context.perception.subtitleLanguage,
+    });
+    context.prompts = prompts;
+};
+exports.promptCompilationStage = promptCompilationStage;
+const cognitionPlanningStage = async (context) => {
+    if (!context.input || !context.prompts || !context.sessionKey)
+        return;
+    const effectiveCompanionName = context.contextRetrieval?.selfIdentity?.name?.trim() || context.companionName;
+    const plan = await (0, cognition_planner_1.generateCognitionPlan)({
+        companionName: effectiveCompanionName,
+        brain: context.organs.brain,
+        systemPrompt: context.prompts.systemPrompt,
+        contextPrompt: context.prompts.contextPrompt,
+        recentMessages: context.sessionHistory.getHistory(context.sessionKey).slice(-10),
+        recipient: context.input.role,
+        perceivedText: context.input.perceivedText,
+    });
+    context.plan = plan;
+};
+exports.cognitionPlanningStage = cognitionPlanningStage;
+const responseGatingStage = async (context) => {
+    if (!context.input || !context.plan || !context.contextRetrieval || !context.sessionKey)
+        return;
+    const stagedPlan = context.gating.stageResponse({
+        requestContext: context.input.requestContext,
+        candidateSpeech: context.plan.speech,
+        candidateLanguage: context.plan.language || 'ja',
+        internalMonologue: context.plan.internalMonologue,
+        memoryProposals: [
+            ...(context.intent?.explicitTeaching?.claims || []),
+            ...(context.plan.memoryProposals || []),
+        ],
+        behaviorProposals: [
+            ...(context.intent?.explicitTeaching?.behaviorProposals || []),
+            ...(context.plan.behaviorProposals || []),
+        ],
+        evidenceRecords: context.contextRetrieval.collectedEvidence,
+        citations: context.contextRetrieval.citations,
+    });
+    context.stagedPlan = stagedPlan;
+    const gateEval = context.gating.evaluateGate(stagedPlan, context.contextRetrieval.collectedEvidence);
+    context.gateEval = gateEval;
+    if (!gateEval.admissible) {
+        context.responseEnvelope = (0, response_envelope_1.createGateRejectionEnvelope)(stagedPlan, gateEval);
+        return false; // Terminate pipeline early upon rejection
+    }
+    context.sessionHistory.append(context.sessionKey, { role: 'assistant', content: context.plan.speech });
+    context.sessionHistory.append('default', { role: 'assistant', content: context.plan.speech });
+};
+exports.responseGatingStage = responseGatingStage;
+const memorySettlementStage = async (context) => {
+    if (!context.input || !context.plan || !context.intent)
+        return;
+    const memorySettlement = await (0, memory_settler_1.settleMemoryProposals)({
+        companionId: context.companionId,
+        perceivedText: context.input.perceivedText,
+        role: context.input.role,
+        requestContext: context.input.requestContext,
+        memory: context.organs.memory,
+        self: context.organs.self,
+        explicitTeaching: context.intent.explicitTeaching,
+        plan: context.plan,
+        effectiveMode: context.intent.effectiveMode,
+    });
+    context.memorySettlement = memorySettlement;
+};
+exports.memorySettlementStage = memorySettlementStage;
+const actionExecutionStage = async (context) => {
+    if (!context.input || !context.plan)
+        return;
+    const actionResults = await (0, action_executor_1.executeActionIntents)({
+        actionIntents: context.plan.actionIntents,
+        requestContext: context.input.requestContext,
+        actionPolicy: context.actionPolicy,
+        hands: context.organs.hands,
+    });
+    context.actionResults = actionResults;
+};
+exports.actionExecutionStage = actionExecutionStage;
+const experienceEmissionStage = async (context) => {
+    if (!context.input || !context.plan || !context.stagedPlan || !context.gateEval)
+        return;
+    const experienceEmission = await (0, experience_emitter_1.emitExperienceEvents)({
+        companionId: context.companionId,
+        requestContext: context.input.requestContext,
+        stagedPlan: context.stagedPlan,
+        gateEval: context.gateEval,
+        speech: context.plan.speech,
+        language: context.plan.language || 'ja',
+        dispatcher: context.dispatcher,
+        voice: context.organs.voice,
+        body: context.organs.body,
+    });
+    context.experienceEmission = experienceEmission;
+};
+exports.experienceEmissionStage = experienceEmissionStage;
+const mouthDeliveryStage = async (context) => {
+    if (!context.plan || !context.stagedPlan || !context.gateEval || !context.contextRetrieval)
+        return;
+    let mouthDelivery;
+    if (context.organs.mouth && typeof context.organs.mouth.speak === 'function') {
+        try {
+            const avatarEvent = context.experienceEmission?.experienceEvents.find((e) => e.kind === 'avatar');
+            mouthDelivery = await context.organs.mouth.speak({
+                utteranceId: context.stagedPlan.responseId,
+                companionId: context.companionId,
+                responseId: context.stagedPlan.responseId,
+                correlationId: context.stagedPlan.correlationId,
+                text: context.plan.speech,
+                language: context.plan.language || 'ja',
+                subtitleJa: context.plan.speech,
+                subtitleEn: context.plan.speech,
+                spokenJa: context.plan.speech,
+                subtitle: context.plan.subtitle,
+                subtitles: context.plan.subtitles,
+                subtitleLanguage: context.perception.subtitleLanguage,
+                expression: avatarEvent?.expression,
+                medium: context.perception.medium,
+                signal: context.perception.signal,
+                audioUrl: context.experienceEmission?.speechId
+                    ? `/voice/stream?id=${context.experienceEmission.speechId}`
+                    : undefined,
+                metadata: {
+                    subsystemDiagnostics: context.contextRetrieval.subsystemDiagnostics,
+                    internalMonologue: context.plan.internalMonologue,
+                },
+                citations: context.gateEval.filteredCitations,
+                evidenceIds: context.gateEval.filteredEvidenceIds,
+            });
+        }
+        catch (e) {
+            console.error('[SiduriRuntime] Mouth delivery failed:', e?.message || e);
+        }
+    }
+    context.mouthDelivery = mouthDelivery;
+};
+exports.mouthDeliveryStage = mouthDeliveryStage;
+const envelopeAssemblyStage = async (context) => {
+    if (!context.stagedPlan || !context.plan || !context.gateEval || !context.contextRetrieval || !context.memorySettlement)
+        return;
+    const envelope = (0, response_envelope_1.assembleResponseEnvelope)({
+        stagedPlan: context.stagedPlan,
+        speech: context.plan.speech,
+        language: context.plan.language,
+        subtitle: context.plan.subtitle,
+        subtitles: context.plan.subtitles,
+        subtitleLanguage: context.perception.subtitleLanguage,
+        speechId: context.experienceEmission?.speechId,
+        createdMemoryProposals: context.memorySettlement.createdMemoryProposals,
+        memoryProposalReceipts: context.memorySettlement.memoryProposalReceipts,
+        behavioralProposalReceipts: context.memorySettlement.behavioralProposalReceipts,
+        actionResults: context.actionResults || [],
+        filteredEvidenceIds: context.gateEval.filteredEvidenceIds,
+        filteredCitations: context.gateEval.filteredCitations,
+        subsystemDiagnostics: context.contextRetrieval.subsystemDiagnostics,
+        experienceEvents: context.experienceEmission?.experienceEvents || [],
+        mouthDelivery: context.mouthDelivery,
+        effectiveMode: context.intent?.effectiveMode,
+    });
+    context.responseEnvelope = envelope;
+};
+exports.envelopeAssemblyStage = envelopeAssemblyStage;
+function createDefaultPerceptionPipeline() {
+    return new PerceptionPipeline([
+        exports.earTranscriptionStage,
+        exports.inputNormalizationStage,
+        exports.intentClassificationStage,
+        exports.contextRetrievalStage,
+        exports.promptCompilationStage,
+        exports.cognitionPlanningStage,
+        exports.responseGatingStage,
+        exports.memorySettlementStage,
+        exports.actionExecutionStage,
+        exports.experienceEmissionStage,
+        exports.mouthDeliveryStage,
+        exports.envelopeAssemblyStage,
+    ]);
+}

package/dist/perception-pipeline.test.d.ts

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