@siduri-x/core 2.0.1 → 2.0.2

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 {};

package/dist/perception-pipeline.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const perception_pipeline_1 = require("./perception-pipeline");
+const gating_1 = require("./gating");
+const action_policy_1 = require("./action-policy");
+const dispatcher_1 = require("./dispatcher");
+const session_history_1 = require("./session-history");
+describe('PerceptionPipeline (Pipes & Filters Execution)', () => {
+    function createMockContext(overrides = {}) {
+        return {
+            companionId: 'test-companion',
+            companionName: 'Test Companion',
+            perception: {
+                source: 'text_chat',
+                text: 'Hello world',
+                roleOrContext: 'OWNER',
+            },
+            organs: {},
+            gating: new gating_1.ResponseGatingEngine(),
+            actionPolicy: new action_policy_1.ActionPolicyEngine(),
+            dispatcher: new dispatcher_1.ExperienceDispatcher(),
+            sessionHistory: new session_history_1.SessionHistoryManager(),
+            ...overrides,
+        };
+    }
+    test('executes stages in sequence and returns response envelope', async () => {
+        const executedStages = [];
+        const stageA = async (ctx) => {
+            executedStages.push('stageA');
+            ctx.rawText = (ctx.perception.text || '').toUpperCase();
+        };
+        const stageB = async (ctx) => {
+            executedStages.push('stageB');
+            ctx.responseEnvelope = { result: ctx.rawText };
+        };
+        const pipeline = new perception_pipeline_1.PerceptionPipeline([stageA, stageB]);
+        const ctx = createMockContext();
+        const result = await pipeline.execute(ctx);
+        expect(executedStages).toEqual(['stageA', 'stageB']);
+        expect(result).toEqual({ result: 'HELLO WORLD' });
+    });
+    test('halts pipeline execution early when a stage returns false', async () => {
+        const executedStages = [];
+        const stageA = async () => {
+            executedStages.push('stageA');
+        };
+        const stageReject = async (ctx) => {
+            executedStages.push('stageReject');
+            ctx.responseEnvelope = { rejected: true, reason: 'halt_early' };
+            return false; // halt
+        };
+        const stageB = async () => {
+            executedStages.push('stageB');
+        };
+        const pipeline = new perception_pipeline_1.PerceptionPipeline([stageA, stageReject, stageB]);
+        const ctx = createMockContext();
+        const result = await pipeline.execute(ctx);
+        expect(executedStages).toEqual(['stageA', 'stageReject']);
+        expect(result).toEqual({ rejected: true, reason: 'halt_early' });
+    });
+    test('createDefaultPerceptionPipeline constructs a 12-stage pipeline', () => {
+        const defaultPipeline = (0, perception_pipeline_1.createDefaultPerceptionPipeline)();
+        expect(defaultPipeline.stages.length).toBe(12);
+    });
+});

package/dist/runtime-facades.test.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const runtime_1 = require("./runtime");
-describe('SiduriRuntime Facade Methods & Delegation', () => {
-    test('delegates vision and observation methods to configured organs', async () => {
+const container_1 = require("./container");
+describe('CompanionContainer & Direct Domain Access', () => {
+    test('delegates vision and observation methods to configured organs via container', async () => {
         const mockVision = {
             analyze: jest.fn().mockResolvedValue('an ancient artifact'),
         };
@@ -11,23 +11,23 @@ describe('SiduriRuntime Facade Methods & Delegation', () => {
             current: jest.fn().mockReturnValue([{ observationId: 'obs-1' }]),
             clearExpired: jest.fn().mockReturnValue(1),
         };
-        const runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test' }, {
+        const container = new container_1.CompanionContainer('test-comp', { name: 'Test' }, {
             vision: mockVision,
             observation: mockObservation,
         });
-        const visionResult = await runtime.analyzeVision('http://example.com/img.png', 'describe');
+        const visionResult = await container.vision.analyze('http://example.com/img.png', 'describe');
         expect(visionResult).toBe('an ancient artifact');
         expect(mockVision.analyze).toHaveBeenCalledWith('http://example.com/img.png', 'describe');
         const frame = new Uint8Array([1, 2, 3]);
-        const obsResult = await runtime.ingestObservation(frame, 'camera-1', 'provider-x');
+        const obsResult = await container.observation.ingest(frame, 'camera-1', 'provider-x');
         expect(obsResult.duplicate).toBe(false);
         expect(mockObservation.ingest).toHaveBeenCalledWith(frame, 'camera-1', 'provider-x');
-        const cur = runtime.getCurrentObservations();
+        const cur = container.observation.current();
         expect(cur).toEqual([{ observationId: 'obs-1' }]);
-        const cleared = runtime.clearExpiredObservations();
+        const cleared = container.observation.clearExpired();
         expect(cleared).toBe(1);
     });
-    test('delegates memory operations cleanly through facade methods', async () => {
+    test('delegates memory operations directly on the memory organ', async () => {
         const mockMemory = {
             initialize: jest.fn().mockResolvedValue(undefined),
             getClaims: jest.fn().mockResolvedValue([{ id: 'claim-1' }]),
@@ -42,39 +42,39 @@ describe('SiduriRuntime Facade Methods & Delegation', () => {
             disableDirective: jest.fn().mockResolvedValue(undefined),
             resetMemory: jest.fn().mockResolvedValue(undefined),
         };
-        const runtime = new runtime_1.SiduriRuntime('test-comp', { name: 'Test' }, {
+        const container = new container_1.CompanionContainer('test-comp', { name: 'Test' }, {
             memory: mockMemory,
         });
-        expect(await runtime.getClaims(10)).toEqual([{ id: 'claim-1' }]);
+        expect(await container.memory.getClaims(10)).toEqual([{ id: 'claim-1' }]);
         expect(mockMemory.getClaims).toHaveBeenCalledWith(10);
-        expect(await runtime.getPendingClaims()).toEqual([{ id: 'claim-pending-1' }]);
-        expect(await runtime.getDirectives()).toEqual([{ id: 'dir-1' }]);
-        await runtime.approveClaim('c-1');
+        expect(await container.memory.getPendingClaims()).toEqual([{ id: 'claim-pending-1' }]);
+        expect(await container.memory.getDirectives()).toEqual([{ id: 'dir-1' }]);
+        await container.memory.approveClaim('c-1');
         expect(mockMemory.approveClaim).toHaveBeenCalledWith('c-1');
-        await runtime.rejectClaim('c-2');
+        await container.memory.rejectClaim('c-2');
         expect(mockMemory.rejectClaim).toHaveBeenCalledWith('c-2');
-        await runtime.updateClaim('c-1', { value: 'new' });
-        expect(mockMemory.updateClaim).toHaveBeenCalledWith('c-1', { value: 'new' });
-        await runtime.approveDirective('d-1');
+        await container.memory.updateClaim('c-1', { value: 'updated' });
+        expect(mockMemory.updateClaim).toHaveBeenCalledWith('c-1', { value: 'updated' });
+        await container.memory.approveDirective('d-1');
         expect(mockMemory.approveDirective).toHaveBeenCalledWith('d-1');
-        await runtime.rejectDirective('d-2');
+        await container.memory.rejectDirective('d-2');
         expect(mockMemory.rejectDirective).toHaveBeenCalledWith('d-2');
-        await runtime.revokeDirective('d-3');
+        await container.memory.revokeDirective('d-3');
         expect(mockMemory.revokeDirective).toHaveBeenCalledWith('d-3');
-        await runtime.disableDirective('d-4');
+        await container.memory.disableDirective('d-4');
         expect(mockMemory.disableDirective).toHaveBeenCalledWith('d-4');
-        await runtime.resetMemory();
+        await container.memory.resetMemory();
         expect(mockMemory.resetMemory).toHaveBeenCalled();
     });
     test('configures SqliteActionStore when actionStore is sqlite', () => {
-        const runtime = new runtime_1.SiduriRuntime('comp-sqlite', {
+        const container = new container_1.CompanionContainer('comp-sqlite', {
             id: 'comp-sqlite',
             name: 'Sqlite Test',
             actionStore: 'sqlite',
         });
-        expect(runtime.actionPolicy.getStore()).toBeDefined();
+        expect(container.actionPolicy.getStore()).toBeDefined();
         // Verify it is an instance of SqliteActionStore
-        expect(runtime.actionPolicy.getStore().constructor.name).toBe('SqliteActionStore');
+        expect(container.actionPolicy.getStore().constructor.name).toBe('SqliteActionStore');
     });
     test('accepts custom actionStore via RuntimeOrgans', () => {
         const customStore = {
@@ -87,9 +87,9 @@ describe('SiduriRuntime Facade Methods & Delegation', () => {
             getAuditLog: jest.fn(),
             verifyAuditChain: jest.fn(),
         };
-        const runtime = new runtime_1.SiduriRuntime('comp-custom', { id: 'comp-custom', name: 'Custom' }, {
+        const container = new container_1.CompanionContainer('comp-custom', { id: 'comp-custom', name: 'Custom' }, {
             actionStore: customStore,
         });
-        expect(runtime.actionPolicy.getStore()).toBe(customStore);
+        expect(container.actionPolicy.getStore()).toBe(customStore);
     });
 });

package/dist/runtime.d.ts

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