@siduri-x/core 2.0.0 → 2.0.2

package/dist/capability.test.js

@@ -165,6 +165,7 @@ describe('AuthorizationCapability Cryptographic & Tamper Review', () => {
                     decisionCode: event1.decision.decisionCode,
                 } : null,
                 parametersHash: event1.parametersHash || null,
+                resultHash: null,
                 error: event1.error || null,
                 timestamp: event1.timestamp,
             });
@@ -190,6 +191,7 @@ describe('AuthorizationCapability Cryptographic & Tamper Review', () => {
                     decisionCode: event2.decision.decisionCode,
                 } : null,
                 parametersHash: event2.parametersHash || null,
+                resultHash: null,
                 error: event2.error || null,
                 timestamp: event2.timestamp,
             });
@@ -203,7 +205,47 @@ describe('AuthorizationCapability Cryptographic & Tamper Review', () => {
             });
             const tamperedHash1 = crypto.createHash('sha256').update(`${initialPrevHash}:${tamperedCanonical1}`, 'utf8').digest('hex');
             const brokenHash2 = crypto.createHash('sha256').update(`${tamperedHash1}:${canonical2}`, 'utf8').digest('hex');
-            expect(brokenHash2).not.toBe(event2.resultHash);
+            expect(brokenHash2).not.toBe(event2.eventHash);
+        });
+        it('detects tampering with resultHash on completed action events', async () => {
+            const store = new capability_1.InMemoryActionStore();
+            const initialPrevHash = '0000000000000000000000000000000000000000000000000000000000000000';
+            const event = {
+                executionId: 'exec-1',
+                actionId: 'act-1',
+                toolName: 'comm/send_email',
+                companionId: 'comp-1',
+                riskLevel: 'LOW',
+                lifecycle: 'COMPLETED',
+                parametersHash: 'param-hash-1',
+                resultHash: 'result-hash-original',
+                timestamp: '2026-09-12T10:00:00.000Z',
+            };
+            await store.appendAudit(event);
+            const log = await store.getAuditLog();
+            const recorded = log[0];
+            // Tampering with resultHash changes canonical payload and recalculates a mismatched hash
+            const tamperedPayload = {
+                executionId: recorded.executionId,
+                actionId: recorded.actionId,
+                toolName: recorded.toolName,
+                providerId: recorded.providerId || null,
+                companionId: recorded.companionId,
+                actorId: recorded.actorId || null,
+                sessionId: recorded.sessionId || null,
+                channel: recorded.channel || null,
+                correlationId: recorded.correlationId || null,
+                riskLevel: recorded.riskLevel,
+                lifecycle: recorded.lifecycle,
+                decision: null,
+                parametersHash: recorded.parametersHash || null,
+                resultHash: 'result-hash-TAMPERED',
+                error: recorded.error || null,
+                timestamp: recorded.timestamp,
+            };
+            const tamperedCanonical = (0, capability_1.canonicalizeJson)(tamperedPayload);
+            const recomputedHash = crypto.createHash('sha256').update(`${initialPrevHash}:${tamperedCanonical}`, 'utf8').digest('hex');
+            expect(recomputedHash).not.toBe(recorded.eventHash);
         });
     });
     describe('Durable Action Approval Restart Semantics', () => {
@@ -239,6 +281,7 @@ describe('AuthorizationCapability Cryptographic & Tamper Review', () => {
             await engine1.approveAction({
                 executionId: 'exec-restart-1',
                 approverActorId: 'operator-1',
+                approverRole: 'operator',
                 reason: 'Scheduled maintenance',
             });
             // 3. Process restarts: new ActionPolicyEngine instance with empty in-memory set but shared durable store

package/dist/chat-contract.d.ts

@@ -78,4 +78,6 @@ export interface ChatResponse {
  * Canonical helper to dispatch a chat request to a SiduriRuntime instance.
  * Guarantees a 1:1 identical response structure for localweb (apps/api) and standalone CLI.
  */
-export declare function dispatchCompanionChat(runtime: SiduriRuntime, payload: ChatRequest): Promise<ChatResponse>;
+export declare function dispatchCompanionChat(runtime: SiduriRuntime | {
+    runtime: SiduriRuntime;
+}, payload: ChatRequest): Promise<ChatResponse>;

package/dist/chat-contract.js

@@ -6,6 +6,9 @@ exports.dispatchCompanionChat = dispatchCompanionChat;
  * Guarantees a 1:1 identical response structure for localweb (apps/api) and standalone CLI.
  */
 async function dispatchCompanionChat(runtime, payload) {
+    const runner = 'runtime' in runtime && typeof runtime.handleUserMessage !== 'function'
+        ? runtime.runtime
+        : runtime;
     const userMessage = payload.message || payload.text || '';
     const history = Array.isArray(payload.history) ? payload.history : [];
     let roleOrContext;
@@ -19,8 +22,8 @@ async function dispatchCompanionChat(runtime, payload) {
         roleOrContext = 'OWNER';
     }
     const runtimeResult = (payload.medium || payload.signal)
-        ? await runtime.handleUserMessage(userMessage, roleOrContext, history, payload.medium, payload.signal)
-        : await runtime.handleUserMessage(userMessage, roleOrContext, history);
+        ? await runner.handleUserMessage(userMessage, roleOrContext, history, payload.medium, payload.signal)
+        : await runner.handleUserMessage(userMessage, roleOrContext, history);
     const delivery = runtimeResult?.delivery;
     // Normalize response plan
     const speech = delivery?.displayText ||

package/dist/container.d.ts

@@ -0,0 +1,74 @@
+import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, MouthOrgan, SelfRepository, EKnowledgeOrgan, OrganConfig, ActionStore, ActionPolicyEngine, ResponseGatingEngine, ExperienceDispatcher, ExperienceAdapter } from './index';
+import { SessionHistoryManager } from './session-history';
+import { SiduriRuntime } from './runtime';
+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>;
+    self?: OrganConfig | Record<string, unknown>;
+    externalKnowledge?: OrganConfig | Record<string, unknown>;
+    actionPolicy?: Record<string, unknown>;
+    actionStore?: 'in-memory' | 'sqlite' | {
+        type: 'sqlite' | 'in-memory';
+        dbPath?: string;
+    };
+    actionStorePath?: string;
+    [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;
+    self?: SelfRepository;
+    externalKnowledge?: EKnowledgeOrgan;
+    actionStore?: ActionStore;
+    actionPolicy?: ActionPolicyEngine;
+}
+/**
+ * CompanionContainer manages the lifecycle, discovery, wiring, and dependency injection
+ * of organs and infrastructure for a companion instance.
+ */
+export declare class CompanionContainer {
+    readonly id: string;
+    readonly config: SiduriRuntimeConfig;
+    readonly organs: RuntimeOrgans;
+    readonly gating: ResponseGatingEngine;
+    readonly actionPolicy: ActionPolicyEngine;
+    readonly dispatcher: ExperienceDispatcher;
+    readonly sessionHistory: SessionHistoryManager;
+    private _runtime?;
+    constructor(id: string, config: SiduriRuntimeConfig, organs?: RuntimeOrgans);
+    get brain(): BrainOrgan | undefined;
+    get memory(): MemoryOrgan | undefined;
+    get voice(): ExperienceAdapter | VoiceOrgan | undefined;
+    get knowledge(): KnowledgeOrgan | undefined;
+    get vision(): VisionOrgan | undefined;
+    get behavior(): BehaviorOrgan | undefined;
+    get body(): ExperienceAdapter | BodyOrgan | undefined;
+    get hands(): HandsOrgan | undefined;
+    get ear(): EarOrgan | undefined;
+    get observation(): ObservationOrgan | undefined;
+    set observation(org: ObservationOrgan | undefined);
+    get mouth(): MouthOrgan | undefined;
+    get self(): SelfRepository | undefined;
+    get externalKnowledge(): EKnowledgeOrgan | undefined;
+    initialize(): Promise<void>;
+    get runtime(): SiduriRuntime;
+}

package/dist/container.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompanionContainer = void 0;
+const index_1 = require("./index");
+const session_history_1 = require("./session-history");
+const runtime_1 = require("./runtime");
+/**
+ * CompanionContainer manages the lifecycle, discovery, wiring, and dependency injection
+ * of organs and infrastructure for a companion instance.
+ */
+class CompanionContainer {
+    id;
+    config;
+    organs;
+    gating;
+    actionPolicy;
+    dispatcher;
+    sessionHistory;
+    _runtime;
+    constructor(id, config, organs = {}) {
+        this.id = id;
+        this.config = config;
+        this.organs = organs;
+        this.gating = new index_1.ResponseGatingEngine();
+        let actionStore = organs.actionStore;
+        if (!actionStore) {
+            const storeOpt = config.actionStore;
+            const storePath = config.actionStorePath || (typeof storeOpt === 'object' ? storeOpt.dbPath : undefined);
+            if (storeOpt === 'sqlite' || (typeof storeOpt === 'object' && storeOpt.type === 'sqlite') || storePath) {
+                actionStore = new index_1.SqliteActionStore({ dbPath: storePath });
+            }
+        }
+        this.actionPolicy = organs.actionPolicy || new index_1.ActionPolicyEngine({
+            store: actionStore,
+        });
+        this.dispatcher = new index_1.ExperienceDispatcher();
+        if (this.organs.voice && typeof this.organs.voice.handleEvent === 'function') {
+            this.dispatcher.registerAdapter(this.organs.voice);
+        }
+        if (this.organs.body && typeof this.organs.body.handleEvent === 'function') {
+            this.dispatcher.registerAdapter(this.organs.body);
+        }
+        if (this.organs.mouth && typeof this.organs.mouth.handleEvent === 'function') {
+            this.dispatcher.registerAdapter(this.organs.mouth);
+        }
+        this.sessionHistory = new session_history_1.SessionHistoryManager();
+    }
+    // Direct organ accessors
+    get brain() { return this.organs.brain; }
+    get memory() { return this.organs.memory; }
+    get voice() { return this.organs.voice; }
+    get knowledge() { return this.organs.knowledge; }
+    get vision() { return this.organs.vision; }
+    get behavior() { return this.organs.behavior; }
+    get body() { return this.organs.body; }
+    get hands() { return this.organs.hands; }
+    get ear() { return this.organs.ear; }
+    get observation() { return this.organs.observation; }
+    set observation(org) { this.organs.observation = org; }
+    get mouth() { return this.organs.mouth; }
+    get self() { return this.organs.self; }
+    get externalKnowledge() { return this.organs.externalKnowledge; }
+    async initialize() {
+        if (this.organs.memory && typeof this.organs.memory.initialize === 'function') {
+            await this.organs.memory.initialize(this.id);
+        }
+        if (this.organs.hands && typeof this.organs.hands.listTools === 'function') {
+            const tools = await this.organs.hands.listTools();
+            for (const tool of tools) {
+                this.actionPolicy.registerToolDefinition(tool);
+            }
+        }
+    }
+    get runtime() {
+        if (!this._runtime) {
+            this._runtime = new runtime_1.SiduriRuntime(this.id, this.config, this);
+        }
+        return this._runtime;
+    }
+}
+exports.CompanionContainer = CompanionContainer;

package/dist/context.d.ts

@@ -25,7 +25,7 @@ export interface RequestContext {
     subject?: SubjectRef;
     metadata?: Record<string, unknown>;
 }
-export type DiagnosticCode = 'legacy_role_removed' | 'anonymous_session_generated' | 'companion_default_mapped_for_bootstrap' | 'actor_scoped_subject_mapped';
+export type DiagnosticCode = 'legacy_role_removed' | 'anonymous_session_generated' | 'companion_default_mapped_for_bootstrap' | 'actor_scoped_subject_mapped' | 'role_escalation_attempt_suppressed' | 'capability_escalation_attempt_suppressed';
 export type ContextErrorCode = 'MISSING_CONTEXT' | 'INVALID_CONTEXT' | 'FORBIDDEN_CONTEXT' | 'AMBIGUOUS_CONTEXT' | 'UNAUTHORIZED_CAPABILITY';
 export interface ContextError {
     code: ContextErrorCode;

package/dist/index.d.ts

@@ -25,6 +25,8 @@ export * from './session-history';
 export * from './schema-validator';
 export * from './siduri-db';
 export * from './database';
+export * from './container';
+export * from './perception-pipeline';
 import { EvidenceRecord } from './evidence';
 import { ActionIntent } from './action';
 import { RequestContext } from './context';
@@ -124,13 +126,15 @@ export interface MemoryOrgan {
     markClaimSessionOnly?(id: string): Promise<void>;
     expireClaim?(id: string): Promise<void>;
     revokeClaim?(id: string, reason?: string): Promise<void>;
-    getDirectives(): Promise<BehaviorDirective[]>;
-    proposeDirective(directiveData: Omit<BehaviorDirective, 'id' | 'status' | 'companionId'>): Promise<BehaviorDirective>;
-    approveDirective(id: string): Promise<void>;
-    rejectDirective(id: string): Promise<void>;
-    revokeDirective(id: string): Promise<void>;
-    disableDirective(id: string): Promise<void>;
-    expireDirective?(id: string): Promise<void>;
+    getDirectives(companionId?: string): Promise<BehaviorDirective[]>;
+    proposeDirective(directiveData: Omit<BehaviorDirective, 'id' | 'status' | 'companionId'> & {
+        companionId?: string;
+    }): Promise<BehaviorDirective>;
+    approveDirective(id: string, companionId?: string): Promise<void>;
+    rejectDirective(id: string, companionId?: string): Promise<void>;
+    revokeDirective(id: string, companionId?: string): Promise<void>;
+    disableDirective(id: string, companionId?: string): Promise<void>;
+    expireDirective?(id: string, companionId?: string): Promise<void>;
     supersedeClaim?(id: string, replacement: Omit<Claim, 'id' | 'status' | 'companionId'>): Promise<Claim>;
     updateClaim?(id: string, updates: Partial<Pick<Claim, 'subject' | 'predicate' | 'value' | 'scope' | 'sensitivity' | 'confidence' | 'validFrom' | 'validUntil'>>): Promise<Claim>;
     resetMemory?(): Promise<void>;

package/dist/index.js

@@ -42,5 +42,7 @@ __exportStar(require("./session-history"), exports);
 __exportStar(require("./schema-validator"), exports);
 __exportStar(require("./siduri-db"), exports);
 __exportStar(require("./database"), exports);
+__exportStar(require("./container"), exports);
+__exportStar(require("./perception-pipeline"), exports);
 // Mouth (Communication & Output Delivery)
 __exportStar(require("./mouth-types"), exports);

package/dist/input-normalizer.js

@@ -16,7 +16,9 @@ async function normalizeUserInput(message, roleOrContext = 'OWNER', history = []
     }
     const isContextObject = typeof roleOrContext === 'object' && roleOrContext !== null;
     const role = isContextObject
-        ? (roleOrContext.actor?.authorizationRole === 'viewer' ? 'VIEWER' : 'OWNER')
+        ? (roleOrContext.actor?.authorizationRole === 'viewer' || roleOrContext.actor?.authenticated === false
+            ? 'VIEWER'
+            : 'OWNER')
         : roleOrContext;
     const requestContext = isContextObject
         ? roleOrContext

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,255 @@
+"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,
+    });
+    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,
+    });
+    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,
+    });
+    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 {};