@siduri-x/core 2.0.1 → 2.0.3

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/prompt-compiler.d.ts

@@ -1,4 +1,4 @@
-import { BehaviorOrgan, BehaviorDirective, KnowledgeItem, Claim, RequestContext } from './index';
+import { BehaviorOrgan, BehaviorDirective, KnowledgeItem, Claim, RequestContext, InteractionMode } from './index';
 export interface PromptCompilationParams {
     companionName: string;
     companionId: string;
@@ -10,6 +10,7 @@ export interface PromptCompilationParams {
     knowledgeData: KnowledgeItem[];
     memoryData: Claim[];
     lifeContext?: string[];
+    effectiveMode?: InteractionMode;
 }
 export interface CompiledPrompts {
     systemPrompt: string;

package/dist/prompt-compiler.js

@@ -5,7 +5,7 @@ exports.compilePrompts = compilePrompts;
  * Compiles neutral system prompt and formatted context prompt from structured data.
  */
 async function compilePrompts(params) {
-    const { companionName, companionId, role, requestContext, behavior, activeDirectives, subsystemDiagnostics, knowledgeData, memoryData, lifeContext, } = params;
+    const { companionName, companionId, role, requestContext, behavior, activeDirectives, subsystemDiagnostics, knowledgeData, memoryData, lifeContext, effectiveMode, } = params;
     let contextPrompt = '';
     if (Object.keys(subsystemDiagnostics).length > 0) {
         contextPrompt +=
@@ -43,8 +43,14 @@ async function compilePrompts(params) {
             actorId: requestContext.actor.actorId,
         })
         : '';
+    const modeInstruction = effectiveMode === 'casual'
+        ? 'Operating Mode: Casual (Zero memory drift - do not attempt to persist personal claims or directives).'
+        : effectiveMode === 'teach'
+            ? 'Operating Mode: Teach Mode (Active learning session - accurately capture user preferences and proposed boundaries for operator review).'
+            : undefined;
     const systemPrompt = [
         `You are ${companionName}.`,
+        modeInstruction,
         'This is a neutral conversation context.',
         'Use only approved, permitted memory as factual personal context.',
         'Do not claim prior personal knowledge when no approved memory supports it.',

package/dist/proposals.d.ts

@@ -20,7 +20,10 @@ export interface MemoryProposal {
 }
 export interface BehaviorProposal {
     directive: string;
-    priority: number;
+    priority?: number;
+    category?: 'guardrail' | 'relational' | 'behavioral' | string;
+    scopeActor?: string;
+    supersedesId?: string;
     subject?: string;
     predicate?: string;
     value?: string;

package/dist/response-envelope.d.ts

@@ -1,4 +1,4 @@
-import { StagedResponsePlan, ResponseGateEvaluation, Claim, ResponseCitation, ExperienceEvent, ActionExecutionResult } from './index';
+import { StagedResponsePlan, ResponseGateEvaluation, Claim, ResponseCitation, ExperienceEvent, ActionExecutionResult, InteractionMode } from './index';
 import { MemoryProposalReceipt } from './memory-settler';
 import { FormattedMouthOutput } from './mouth-types';
 export interface AssembleResponseEnvelopeParams {
@@ -14,6 +14,7 @@ export interface AssembleResponseEnvelopeParams {
     subsystemDiagnostics: Record<string, string>;
     experienceEvents: ExperienceEvent[];
     mouthDelivery?: FormattedMouthOutput;
+    effectiveMode?: InteractionMode;
 }
 /**
  * Creates the standardized rejection envelope for responses that fail gate evaluation.

package/dist/response-envelope.js

@@ -29,7 +29,7 @@ function createGateRejectionEnvelope(stagedPlan, gateEval) {
  * Assembles the standardized response structure for approved companion responses.
  */
 function assembleResponseEnvelope(params) {
-    const { stagedPlan, speech, language, speechId, createdMemoryProposals, memoryProposalReceipts, actionResults, filteredEvidenceIds, filteredCitations, subsystemDiagnostics, experienceEvents, mouthDelivery, } = params;
+    const { stagedPlan, speech, language, speechId, createdMemoryProposals, memoryProposalReceipts, actionResults, filteredEvidenceIds, filteredCitations, subsystemDiagnostics, experienceEvents, mouthDelivery, effectiveMode, } = params;
     return {
         status: 'APPROVED',
         response_id: stagedPlan.responseId,
@@ -42,6 +42,7 @@ function assembleResponseEnvelope(params) {
         },
         delivery: mouthDelivery,
         metadata: {
+            mode: effectiveMode ?? 'hybrid',
             language,
             proposals: createdMemoryProposals,
             memory_proposals: memoryProposalReceipts,

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