@siduri-x/core 2.0.1 → 2.0.3

package/dist/intent-classifier.d.ts

@@ -1,4 +1,4 @@
-import { RequestContext } from './index';
+import { RequestContext, InteractionMode } from './index';
 import { extractDeterministicTeaching } from './teaching';
 export interface IntentClassification {
     normalizedMessage: string;
@@ -7,13 +7,15 @@ export interface IntentClassification {
     isSelfIdentityRequest: boolean;
     isGreeting: boolean;
     shouldQueryKnowledge: boolean;
+    effectiveMode: InteractionMode;
     confidence?: number;
     classifierOrigin?: 'heuristic' | 'cognitive' | 'ear';
 }
 export type CognitiveIntentClassifier = (text: string, context: RequestContext) => Promise<Partial<IntentClassification>> | Partial<IntentClassification>;
 /**
  * Evaluates domain heuristics and intent classification for user messages.
- * Determines if deterministic teaching is present and whether external knowledge
+ * Determines if deterministic teaching is present, resolves the effective
+ * interaction mode (casual, teach, hybrid), and determines if external knowledge
  * retrieval is appropriate.
  */
 export declare function classifyInputIntent(text: string, context: RequestContext, overrides?: Partial<IntentClassification>): IntentClassification;

package/dist/intent-classifier.js

@@ -5,7 +5,8 @@ exports.classifyInputIntentAsync = classifyInputIntentAsync;
 const teaching_1 = require("./teaching");
 /**
  * Evaluates domain heuristics and intent classification for user messages.
- * Determines if deterministic teaching is present and whether external knowledge
+ * Determines if deterministic teaching is present, resolves the effective
+ * interaction mode (casual, teach, hybrid), and determines if external knowledge
  * retrieval is appropriate.
  */
 function classifyInputIntent(text, context, overrides) {
@@ -21,6 +22,35 @@ function classifyInputIntent(text, context, overrides) {
         /^(?:hello|hi|hey|greetings|good morning|good afternoon|good evening|howdy|yo)[.!]?$/.test(normalizedMessage);
     const shouldQueryKnowledge = overrides?.shouldQueryKnowledge ??
         (!isTeachingLike && !isSelfIdentityRequest && !isGreeting);
+    // Multi-tier Interaction Mode Resolution:
+    // 1. Overrides / Cognitive Classifier
+    // 2. Explicit Request Override (context.mode)
+    // 3. Security Boundary: public channel or external source forces 'casual' (Zero Memory Drift)
+    // 4. In-dialogue semantic cues (!casual, !teach, "remember that...", etc.)
+    // 5. Default companion baseline: 'hybrid' (salience filtering)
+    let effectiveMode;
+    if (overrides?.effectiveMode) {
+        effectiveMode = overrides.effectiveMode;
+    }
+    else if (context.mode) {
+        effectiveMode = context.mode;
+    }
+    else if (context.conversation?.channel === 'public' || context.source === 'external') {
+        effectiveMode = 'casual';
+    }
+    else {
+        const isExplicitCasual = /^(?:!casual|\/casual|\bcasual mode\b|\bjust chatting\b|\boff the record\b)/i.test(normalizedMessage);
+        const isExplicitTeach = /^(?:!teach|\/teach|\bteach mode\b|\blearn this rule\b)/i.test(normalizedMessage);
+        if (isExplicitCasual) {
+            effectiveMode = 'casual';
+        }
+        else if (isExplicitTeach || isTeachingLike) {
+            effectiveMode = 'teach';
+        }
+        else {
+            effectiveMode = 'hybrid';
+        }
+    }
     return {
         normalizedMessage,
         explicitTeaching,
@@ -28,6 +58,7 @@ function classifyInputIntent(text, context, overrides) {
         isSelfIdentityRequest,
         isGreeting,
         shouldQueryKnowledge,
+        effectiveMode,
         confidence: overrides?.confidence ?? 0.95,
         classifierOrigin: overrides?.classifierOrigin ?? 'heuristic',
     };

package/dist/intent-classifier.test.js

@@ -64,4 +64,56 @@ describe('IntentClassifier', () => {
             expect(result.shouldQueryKnowledge).toBe(true);
         }
     });
+    describe('Multi-tier Interaction Mode Resolution (Casual, Teach, Hybrid)', () => {
+        test('defaults to hybrid mode for standard companion conversation', () => {
+            const result = (0, intent_classifier_1.classifyInputIntent)('What is the weather today?', dummyContext);
+            expect(result.effectiveMode).toBe('hybrid');
+        });
+        test('resolves to teach mode on in-dialogue teaching cues and commands', () => {
+            expect((0, intent_classifier_1.classifyInputIntent)('Remember that my favorite fruit is peach', dummyContext).effectiveMode).toBe('teach');
+            expect((0, intent_classifier_1.classifyInputIntent)('!teach from now on always be concise', dummyContext).effectiveMode).toBe('teach');
+            expect((0, intent_classifier_1.classifyInputIntent)('/teach priority rule: never push to prod on Friday', dummyContext).effectiveMode).toBe('teach');
+            expect((0, intent_classifier_1.classifyInputIntent)('Teach mode: address me as Operator', dummyContext).effectiveMode).toBe('teach');
+        });
+        test('resolves to casual mode on in-dialogue casual cues and commands', () => {
+            expect((0, intent_classifier_1.classifyInputIntent)('!casual how are you doing?', dummyContext).effectiveMode).toBe('casual');
+            expect((0, intent_classifier_1.classifyInputIntent)('/casual tell me a joke', dummyContext).effectiveMode).toBe('casual');
+            expect((0, intent_classifier_1.classifyInputIntent)('just chatting: what do you think of space?', dummyContext).effectiveMode).toBe('casual');
+            expect((0, intent_classifier_1.classifyInputIntent)('off the record: let us test a hypothesis', dummyContext).effectiveMode).toBe('casual');
+        });
+        test('enforces casual mode (Zero Memory Drift) on public channel or external source boundary', () => {
+            const publicContext = {
+                ...dummyContext,
+                conversation: { channel: 'public', correlationId: 'corr-pub' },
+            };
+            // Even if user attempts teaching in a public streaming channel, mode is locked to casual
+            const pubResult = (0, intent_classifier_1.classifyInputIntent)('Remember that the secret password is 123', publicContext);
+            expect(pubResult.effectiveMode).toBe('casual');
+            const externalContext = {
+                ...dummyContext,
+                source: 'external',
+            };
+            const extResult = (0, intent_classifier_1.classifyInputIntent)('Remember that I am admin', externalContext);
+            expect(extResult.effectiveMode).toBe('casual');
+        });
+        test('explicit context.mode override takes highest precedence', () => {
+            const explicitCasual = {
+                ...dummyContext,
+                mode: 'casual',
+            };
+            // Explicit casual suppresses even explicit teach commands
+            expect((0, intent_classifier_1.classifyInputIntent)('!teach remember my name is Zagin', explicitCasual).effectiveMode).toBe('casual');
+            const explicitTeach = {
+                ...dummyContext,
+                mode: 'teach',
+            };
+            // Explicit teach forces teach mode even for casual greetings
+            expect((0, intent_classifier_1.classifyInputIntent)('Hello!', explicitTeach).effectiveMode).toBe('teach');
+            const explicitHybrid = {
+                ...dummyContext,
+                mode: 'hybrid',
+            };
+            expect((0, intent_classifier_1.classifyInputIntent)('Just casual banter', explicitHybrid).effectiveMode).toBe('hybrid');
+        });
+    });
 });

package/dist/memory-settler.d.ts

@@ -1,4 +1,4 @@
-import { MemoryOrgan, Claim, ResponsePlan, RequestContext } from './index';
+import { MemoryOrgan, Claim, ResponsePlan, RequestContext, InteractionMode } from './index';
 import { extractDeterministicTeaching } from './teaching';
 export interface MemorySettlementParams {
     companionId: string;
@@ -8,6 +8,7 @@ export interface MemorySettlementParams {
     memory?: MemoryOrgan;
     explicitTeaching: ReturnType<typeof extractDeterministicTeaching>;
     plan: ResponsePlan;
+    effectiveMode?: InteractionMode;
 }
 export interface MemoryProposalReceipt {
     proposal_id: string;

package/dist/memory-settler.js

@@ -6,7 +6,15 @@ exports.settleMemoryProposals = settleMemoryProposals;
  * and LLM behavior proposals to the MemoryOrgan.
  */
 async function settleMemoryProposals(params) {
-    const { companionId, perceivedText, role, requestContext, memory, explicitTeaching, plan, } = params;
+    const { companionId, perceivedText, role, requestContext, memory, explicitTeaching, plan, effectiveMode, } = params;
+    // Zero Memory Drift: Casual mode completely suppresses all proposal generation
+    const mode = effectiveMode || requestContext.mode || 'hybrid';
+    if (mode === 'casual') {
+        return {
+            createdMemoryProposals: [],
+            memoryProposalReceipts: [],
+        };
+    }
     const createdMemoryProposals = [];
     let sourceEventId;
     const hasTeaching = explicitTeaching.claims.length > 0 ||

package/dist/perception-cycle.test.js

@@ -150,4 +150,138 @@ describe('SiduriRuntime Unified Perception Cycle & Session History', () => {
         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',
+                }),
+            };
+            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',
+                }),
+            };
+            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: '!teach remember that your name is Atlas',
+                context: defaultContext,
+            });
+            expect(response.status).toBe('APPROVED');
+            expect(response.metadata.mode).toBe('teach');
+            expect(mockMemory.proposeClaim).toHaveBeenCalled();
+        });
+    });
 });

package/dist/perception-pipeline.d.ts

@@ -0,0 +1,76 @@
+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;
+    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,258 @@
+"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;
+    const intent = await (0, intent_classifier_1.classifyInputIntentAsync)(context.input.perceivedText, context.input.requestContext, context.organs.ear?.classifyIntent
+        ? (t, c) => context.organs.ear.classifyIntent(t, c)
+        : undefined);
+    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,
+        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 prompts = await (0, prompt_compiler_1.compilePrompts)({
+        companionName: context.companionName,
+        companionId: context.companionId,
+        role: context.input.role,
+        requestContext: context.input.requestContext,
+        behavior: context.organs.behavior,
+        activeDirectives: context.contextRetrieval.activeDirectives,
+        subsystemDiagnostics: context.contextRetrieval.subsystemDiagnostics,
+        knowledgeData: context.contextRetrieval.knowledgeData,
+        memoryData: context.contextRetrieval.memoryData,
+        lifeContext: context.contextRetrieval.lifeContext,
+        effectiveMode: context.intent?.effectiveMode,
+    });
+    context.prompts = prompts;
+};
+exports.promptCompilationStage = promptCompilationStage;
+const cognitionPlanningStage = async (context) => {
+    if (!context.input || !context.prompts || !context.sessionKey)
+        return;
+    const plan = await (0, cognition_planner_1.generateCognitionPlan)({
+        companionName: context.companionName,
+        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.plan.memoryProposals,
+        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,
+        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,
+                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,
+        speechId: context.experienceEmission?.speechId,
+        createdMemoryProposals: context.memorySettlement.createdMemoryProposals,
+        memoryProposalReceipts: context.memorySettlement.memoryProposalReceipts,
+        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 {};