@siduri-x/core 1.0.7 → 1.0.9

package/dist/action-policy.test.js

@@ -22,7 +22,6 @@ describe('ActionPolicyEngine Boundary', () => {
             },
             conversation: {
                 channel: 'direct',
-                audienceId: 'audience-direct',
                 correlationId: 'corr-1',
             },
         };

package/dist/adversarial.test.js

@@ -14,7 +14,6 @@ describe('Adversarial Hardening Verification Suite (Phase 3)', () => {
         },
         conversation: {
             channel: 'private',
-            audienceId: 'audience-owner',
             correlationId: 'corr-adv-1',
         },
     };
@@ -29,7 +28,6 @@ describe('Adversarial Hardening Verification Suite (Phase 3)', () => {
         },
         conversation: {
             channel: 'public',
-            audienceId: 'audience-public',
             correlationId: 'corr-adv-2',
         },
     };
@@ -86,7 +84,7 @@ describe('Adversarial Hardening Verification Suite (Phase 3)', () => {
                 ...baseOwnerContext,
                 companionId: 'companion-A',
             });
-            expect(mockMemory.searchClaims).toHaveBeenCalledWith('Query', expect.objectContaining({ channel: 'private', audienceId: 'audience-owner' }), 5);
+            expect(mockMemory.searchClaims).toHaveBeenCalledWith('Query', expect.objectContaining({ limit: 5 }), 5);
         });
     });
     // INVARIANT 2: Authority & Request Boundary
@@ -378,41 +376,39 @@ describe('Adversarial Hardening Verification Suite (Phase 3)', () => {
     describe('Invariant 8: Response Gating Evidence Admissibility Semantics', () => {
         test('gate strictly enforces evidence admissibility and disclosure without claiming unverified factuality', () => {
             const gating = new index_1.ResponseGatingEngine();
-            const publicEvidence = {
+            const validEvidence = {
                 evidenceId: 'ev-pub-1',
                 sourceId: 'src-facts',
                 origin: 'knowledge',
                 trust: 'configured',
                 sensitivity: 'public',
-                allowedAudiences: ['audience-public'],
                 companionId: 'companion-adv',
                 correlationId: 'corr-adv-1',
                 createdAt: new Date().toISOString(),
             };
-            const privateEvidence = {
-                evidenceId: 'ev-priv-1',
+            const foreignCompanionEvidence = {
+                evidenceId: 'ev-foreign-1',
                 sourceId: 'src-secrets',
                 origin: 'knowledge',
                 trust: 'configured',
                 sensitivity: 'restricted',
-                allowedAudiences: ['audience-owner'],
-                companionId: 'companion-adv',
+                companionId: 'foreign-companion',
                 correlationId: 'corr-adv-1',
                 createdAt: new Date().toISOString(),
             };
-            // Staged for public channel with both public and restricted evidence attached
+            // Staged for companion-adv with both valid and foreign-companion evidence attached
             const staged = gating.stageResponse({
-                requestContext: baseViewerContext, // Public channel
+                requestContext: baseOwnerContext,
                 candidateSpeech: 'Siduri was created in 1840 by aliens.',
                 candidateLanguage: 'en',
-                evidenceRecords: [publicEvidence, privateEvidence],
+                evidenceRecords: [validEvidence, foreignCompanionEvidence],
             });
-            const evaluation = gating.evaluateGate(staged, [publicEvidence, privateEvidence]);
+            const evaluation = gating.evaluateGate(staged, [validEvidence, foreignCompanionEvidence]);
             expect(evaluation.admissible).toBe(true);
             expect(evaluation.reasonCode).toBe('APPROVED_DIRECT');
-            // Public evidence admitted, restricted private evidence excluded from public emission
+            // Valid companion evidence admitted, foreign companion evidence excluded by isolation boundary
             expect(evaluation.filteredEvidenceIds).toEqual(['ev-pub-1']);
-            expect(evaluation.filteredEvidenceIds).not.toContain('ev-priv-1');
+            expect(evaluation.filteredEvidenceIds).not.toContain('ev-foreign-1');
         });
     });
     // INVARIANT 9: Full-Field Tamper-Evident Audit Trail

package/dist/capability.test.js

@@ -24,7 +24,6 @@ describe('AuthorizationCapability Cryptographic & Tamper Review', () => {
             },
             conversation: {
                 channel: 'direct',
-                audienceId: 'aud-alpha',
                 correlationId: 'corr-999',
             },
         };

package/dist/context-retriever.js

@@ -9,8 +9,6 @@ async function retrieveRuntimeContext(params) {
     const { companionId, perceivedText, requestContext, role, isContextObject, shouldQueryKnowledge, knowledge, memory, } = params;
     const queryOptions = isContextObject
         ? {
-            channel: requestContext.conversation.channel,
-            audienceId: requestContext.conversation.audienceId,
             limit: 5,
         }
         : role;

package/dist/context.d.ts

@@ -9,7 +9,6 @@ export interface ConversationContext {
     correlationId: string;
     sessionId?: string;
     channel?: string;
-    audienceId?: string;
     [key: string]: unknown;
 }
 export type SubjectKind = 'actor' | 'companion' | 'configured';
@@ -27,7 +26,7 @@ export interface RequestContext {
     metadata?: Record<string, unknown>;
 }
 export type DiagnosticCode = 'legacy_role_removed' | 'anonymous_session_generated' | 'companion_default_mapped_for_bootstrap' | 'actor_scoped_subject_mapped';
-export type ContextErrorCode = 'MISSING_CONTEXT' | 'INVALID_CONTEXT' | 'FORBIDDEN_CONTEXT' | 'LEGACY_PERSONAL_AUDIENCE' | 'AMBIGUOUS_CONTEXT' | 'UNAUTHORIZED_CAPABILITY';
+export type ContextErrorCode = 'MISSING_CONTEXT' | 'INVALID_CONTEXT' | 'FORBIDDEN_CONTEXT' | 'AMBIGUOUS_CONTEXT' | 'UNAUTHORIZED_CAPABILITY';
 export interface ContextError {
     code: ContextErrorCode;
     message?: string;

package/dist/dispatcher.test.js

@@ -33,7 +33,6 @@ describe('T5 ExperienceDispatcher Contract Suite', () => {
             companionId: 'companion-a',
             correlationId: 'corr-1',
             channel: 'public',
-            audienceId: 'audience-public',
             speech: 'Hello dispatch',
             language: 'en',
         });
@@ -50,7 +49,6 @@ describe('T5 ExperienceDispatcher Contract Suite', () => {
             companionId: 'companion-a',
             correlationId: 'corr-1',
             channel: 'public',
-            audienceId: 'audience-public',
             speech: 'Hello empty',
         });
         const summary = await emptyDispatcher.dispatchEvents(events);

package/dist/evidence.d.ts

@@ -16,13 +16,12 @@ export interface EvidenceRecord {
     expiresAt?: string;
     trust: EvidenceTrust;
     sensitivity?: EvidenceSensitivity;
-    allowedAudiences?: string[];
     companionId: string;
     correlationId: string;
     [key: string]: unknown;
 }
 export type ResponseApprovalStatus = 'STAGED' | 'APPROVED' | 'REJECTED' | 'EXPIRED' | 'EMITTED';
-export type ResponseGateReasonCode = 'APPROVED_DIRECT' | 'APPROVAL_REQUIRED' | 'UNKNOWN_APPROVAL_ID' | 'APPROVAL_ID_MISMATCH' | 'COMPANION_MISMATCH' | 'AUDIENCE_MISMATCH' | 'EVIDENCE_EXPIRED' | 'EVIDENCE_SENSITIVITY_EXCLUDED' | 'UNRESOLVED_LOW_CONFIDENCE' | 'EMPTY_SPEECH' | 'PROPOSAL_VALIDATION_FAILED' | 'EXPLICITLY_REJECTED';
+export type ResponseGateReasonCode = 'APPROVED_DIRECT' | 'APPROVAL_REQUIRED' | 'UNKNOWN_APPROVAL_ID' | 'APPROVAL_ID_MISMATCH' | 'COMPANION_MISMATCH' | 'EVIDENCE_EXPIRED' | 'EVIDENCE_SENSITIVITY_EXCLUDED' | 'UNRESOLVED_LOW_CONFIDENCE' | 'EMPTY_SPEECH' | 'PROPOSAL_VALIDATION_FAILED' | 'EXPLICITLY_REJECTED';
 export interface ResponseCitation {
     sourceId: string;
     documentId?: string;
@@ -35,7 +34,6 @@ export interface StagedResponsePlan {
     companionId: string;
     correlationId: string;
     channel?: string;
-    audienceId?: string;
     speech: string;
     language: string;
     evidenceIds: string[];
@@ -63,7 +61,6 @@ export interface ResponseGateEvaluation {
 export interface EvidenceFilterOptions {
     companionId: string;
     channel?: string;
-    audienceId?: string;
     now?: string | Date;
     [key: string]: unknown;
 }

package/dist/evidence.js

@@ -19,28 +19,8 @@ function filterEvidenceRecords(records, options) {
                 continue;
             }
         }
-        // 3. Optional audience intersection (audience-public is accessible everywhere)
-        if (options.audienceId &&
-            record.allowedAudiences &&
-            record.allowedAudiences.length > 0 &&
-            !record.allowedAudiences.includes('audience-public') &&
-            !record.allowedAudiences.includes(options.audienceId)) {
-            excluded.push({ record, reason: 'audience_not_allowed' });
-            continue;
-        }
-        // 4. Optional channel sensitivity policy (if channel explicitly specified)
-        if (options.channel === 'public') {
-            if (record.sensitivity && record.sensitivity !== 'public') {
-                excluded.push({ record, reason: 'sensitivity_private_in_public_channel' });
-                continue;
-            }
-        }
-        else if (options.channel === 'direct') {
-            if (record.sensitivity === 'restricted') {
-                excluded.push({ record, reason: 'sensitivity_restricted_in_direct_channel' });
-                continue;
-            }
-        }
+        // In single-owner architecture, memory and evidence are partitioned strictly
+        // by companion boundary (companionId) and temporal expiration.
         admitted.push(record);
     }
     return { admitted, excluded };

package/dist/evidence.test.js

@@ -8,7 +8,6 @@ describe('T4 Evidence & Disclosure Core Contract', () => {
         origin: 'knowledge',
         trust: 'configured',
         sensitivity: 'public',
-        allowedAudiences: ['audience-public'],
         companionId: 'companion-a',
         correlationId: 'corr-1',
         createdAt: new Date(Date.now() - 5000).toISOString(),
@@ -21,7 +20,6 @@ describe('T4 Evidence & Disclosure Core Contract', () => {
         const options = {
             companionId: 'companion-a',
             channel: 'public',
-            audienceId: 'audience-public',
         };
         const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, options);
         expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-mine']);
@@ -40,7 +38,6 @@ describe('T4 Evidence & Disclosure Core Contract', () => {
         const options = {
             companionId: 'companion-a',
             channel: 'public',
-            audienceId: 'audience-public',
         };
         const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, options);
         expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-valid']);
@@ -51,51 +48,28 @@ describe('T4 Evidence & Disclosure Core Contract', () => {
             }),
         ]);
     });
-    test('audience intersection excludes non-matching audiences', () => {
+    test('single-owner companion admits valid evidence without multi-audience filtering', () => {
         const records = [
-            { ...baseRecord, evidenceId: 'ev-public', allowedAudiences: ['audience-public'] },
-            { ...baseRecord, evidenceId: 'ev-direct-only', allowedAudiences: ['audience-direct-a'] },
+            { ...baseRecord, evidenceId: 'ev-public' },
+            { ...baseRecord, evidenceId: 'ev-direct-only' },
         ];
         const options = {
             companionId: 'companion-a',
-            channel: 'public',
-            audienceId: 'audience-public',
         };
         const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, options);
-        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-public']);
-        expect(excluded).toEqual([
-            expect.objectContaining({
-                record: expect.objectContaining({ evidenceId: 'ev-direct-only' }),
-                reason: 'audience_not_allowed',
-            }),
-        ]);
-    });
-    test('sensitivity policy excludes private and restricted evidence from public channels', () => {
-        const records = [
-            { ...baseRecord, evidenceId: 'ev-pub', sensitivity: 'public', allowedAudiences: ['audience-public'] },
-            { ...baseRecord, evidenceId: 'ev-priv', sensitivity: 'private', allowedAudiences: ['audience-public'] },
-            { ...baseRecord, evidenceId: 'ev-rest', sensitivity: 'restricted', allowedAudiences: ['audience-public'] },
-        ];
-        const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, {
-            companionId: 'companion-a',
-            channel: 'public',
-            audienceId: 'audience-public',
-        });
-        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-pub']);
-        expect(excluded.map((e) => e.record.evidenceId)).toEqual(['ev-priv', 'ev-rest']);
+        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-public', 'ev-direct-only']);
+        expect(excluded).toEqual([]);
     });
-    test('direct channel permits private sensitivity but excludes restricted', () => {
+    test('single-owner companion admits private and restricted sensitivity for companion owner', () => {
         const records = [
-            { ...baseRecord, evidenceId: 'ev-pub', sensitivity: 'public', allowedAudiences: ['audience-direct-a'] },
-            { ...baseRecord, evidenceId: 'ev-priv', sensitivity: 'private', allowedAudiences: ['audience-direct-a'] },
-            { ...baseRecord, evidenceId: 'ev-rest', sensitivity: 'restricted', allowedAudiences: ['audience-direct-a'] },
+            { ...baseRecord, evidenceId: 'ev-pub', sensitivity: 'public' },
+            { ...baseRecord, evidenceId: 'ev-priv', sensitivity: 'private' },
+            { ...baseRecord, evidenceId: 'ev-rest', sensitivity: 'restricted' },
         ];
         const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, {
             companionId: 'companion-a',
-            channel: 'direct',
-            audienceId: 'audience-direct-a',
         });
-        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-pub', 'ev-priv']);
-        expect(excluded.map((e) => e.record.evidenceId)).toEqual(['ev-rest']);
+        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-pub', 'ev-priv', 'ev-rest']);
+        expect(excluded).toEqual([]);
     });
 });

package/dist/experience-emitter.js

@@ -13,7 +13,6 @@ async function emitExperienceEvents(params) {
         companionId,
         correlationId: requestContext.conversation.correlationId,
         channel: requestContext.conversation?.channel,
-        audienceId: requestContext.conversation?.audienceId,
         speech,
         language: language || 'ja',
         evidenceIds: gateEval.filteredEvidenceIds,

package/dist/experience.d.ts

@@ -7,7 +7,6 @@ export interface ExperienceEvent {
     responseId: string;
     correlationId: string;
     channel?: string;
-    audienceId?: string;
     approval: 'APPROVED';
     kind: ExperienceEventKind;
     lifecycle: ExperienceEventLifecycle;
@@ -39,7 +38,6 @@ export interface CreateExperienceEventsOptions {
     companionId: string;
     correlationId: string;
     channel?: string;
-    audienceId?: string;
     speech: string;
     language?: string;
     evidenceIds?: string[];

package/dist/experience.js

@@ -17,7 +17,6 @@ function createExperienceEvents(options) {
         responseId: options.responseId,
         correlationId: options.correlationId,
         channel: options.channel,
-        audienceId: options.audienceId,
         approval: 'APPROVED',
         kind: 'voice',
         lifecycle: 'STARTED',
@@ -35,7 +34,6 @@ function createExperienceEvents(options) {
         responseId: options.responseId,
         correlationId: options.correlationId,
         channel: options.channel,
-        audienceId: options.audienceId,
         approval: 'APPROVED',
         kind: 'avatar',
         lifecycle: 'STARTED',
@@ -62,9 +60,6 @@ function validateExperienceEvent(event) {
         return { valid: false, error: 'Missing or invalid responseId' };
     if (!e.correlationId || typeof e.correlationId !== 'string')
         return { valid: false, error: 'Missing or invalid correlationId' };
-    if (e.audienceId !== undefined && typeof e.audienceId !== 'string') {
-        return { valid: false, error: 'Invalid audienceId: must be a string' };
-    }
     if (e.approval !== 'APPROVED')
         return { valid: false, error: 'Event approval must be APPROVED' };
     if (!['voice', 'caption', 'avatar', 'platform_action'].includes(e.kind)) {

package/dist/experience.test.js

@@ -7,7 +7,6 @@ describe('T5 Experience Event Contract Suite', () => {
         companionId: 'companion-a',
         correlationId: 'corr-123',
         channel: 'public',
-        audienceId: 'audience-public',
         speech: 'Hello world',
         language: 'en',
         evidenceIds: ['ev-1'],
@@ -52,8 +51,5 @@ describe('T5 Experience Event Contract Suite', () => {
         expect((0, experience_1.validateExperienceEvent)(missingCompanion).valid).toBe(false);
         const missingResponseId = { ...events[0], responseId: '' };
         expect((0, experience_1.validateExperienceEvent)(missingResponseId).valid).toBe(false);
-        const withoutAudience = { ...events[0] };
-        delete withoutAudience.audienceId;
-        expect((0, experience_1.validateExperienceEvent)(withoutAudience).valid).toBe(true);
     });
 });

package/dist/gating.d.ts

@@ -18,7 +18,6 @@ export interface ApproveResponseOptions {
     responseId: string;
     companionId: string;
     correlationId: string;
-    audienceId?: string;
 }
 export interface RejectResponseOptions {
     responseId: string;

package/dist/gating.js

@@ -40,7 +40,6 @@ class ResponseGatingEngine {
             companionId: requestContext.companionId,
             correlationId: requestContext.conversation.correlationId,
             channel: requestContext.conversation?.channel,
-            audienceId: requestContext.conversation?.audienceId,
             speech: options.candidateSpeech,
             language: options.candidateLanguage,
             evidenceIds,
@@ -90,7 +89,6 @@ class ResponseGatingEngine {
         const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(attachedEvidence, {
             companionId: staged.companionId,
             channel: staged.channel,
-            audienceId: staged.audienceId,
             now,
         });
         // If any evidence attached to this plan violated disclosure in this channel, exclude it

package/dist/gating.test.js

@@ -14,7 +14,6 @@ describe('T4 Response Gating & Staged Approval Suite', () => {
         },
         conversation: {
             channel: 'public',
-            audienceId: 'audience-public',
             correlationId: 'corr-gate-1',
         },
     };
@@ -28,7 +27,6 @@ describe('T4 Response Gating & Staged Approval Suite', () => {
             origin: 'knowledge',
             trust: 'configured',
             sensitivity: 'public',
-            allowedAudiences: ['audience-public'],
             companionId: 'companion-a',
             correlationId: 'corr-gate-1',
             createdAt: new Date().toISOString(),
@@ -56,7 +54,6 @@ describe('T4 Response Gating & Staged Approval Suite', () => {
             origin: 'ocr',
             trust: 'untrusted',
             sensitivity: 'public',
-            allowedAudiences: ['audience-public'],
             companionId: 'companion-a',
             correlationId: 'corr-gate-2',
             createdAt: new Date().toISOString(),
@@ -162,28 +159,27 @@ describe('T4 Response Gating & Staged Approval Suite', () => {
         expect(approveRes.success).toBe(false);
         expect(approveRes.reason).toBe('EVIDENCE_EXPIRED');
     });
-    test('private evidence is filtered out and absent from public citations/evidence list', () => {
-        const privateEvidence = {
-            evidenceId: 'ev-priv-1',
+    test('foreign companion evidence is filtered out and absent from citations/evidence list', () => {
+        const foreignEvidence = {
+            evidenceId: 'ev-foreign-1',
             sourceId: 'src-secret',
             origin: 'knowledge',
             trust: 'configured',
             sensitivity: 'private',
-            allowedAudiences: ['audience-direct-a'],
-            companionId: 'companion-a',
+            companionId: 'companion-b',
             correlationId: 'corr-gate-1',
             createdAt: new Date().toISOString(),
         };
         const staged = engine.stageResponse({
-            requestContext: validPublicContext, // public channel
-            candidateSpeech: 'Public response text',
+            requestContext: validPublicContext, // companion-a
+            candidateSpeech: 'Response text',
             candidateLanguage: 'en',
-            evidenceRecords: [privateEvidence],
+            evidenceRecords: [foreignEvidence],
             citations: [{ sourceId: 'src-secret' }],
         });
-        const evalRes = engine.evaluateGate(staged, [privateEvidence]);
+        const evalRes = engine.evaluateGate(staged, [foreignEvidence]);
         expect(evalRes.admissible).toBe(true);
-        // Private evidence and its citation must be stripped from public output metadata
+        // Foreign companion evidence and its citation must be stripped due to companion isolation
         expect(evalRes.filteredEvidenceIds).toEqual([]);
         expect(evalRes.filteredCitations).toEqual([]);
     });

package/dist/index.d.ts

@@ -22,6 +22,7 @@ export * from './action-executor';
 export * from './experience-emitter';
 export * from './response-envelope';
 export * from './session-history';
+export * from './schema-validator';
 import { EvidenceRecord } from './evidence';
 import { ActionIntent } from './action';
 import { RequestContext } from './context';

package/dist/index.js

@@ -39,5 +39,6 @@ __exportStar(require("./action-executor"), exports);
 __exportStar(require("./experience-emitter"), exports);
 __exportStar(require("./response-envelope"), exports);
 __exportStar(require("./session-history"), exports);
+__exportStar(require("./schema-validator"), exports);
 // Mouth (Communication & Output Delivery)
 __exportStar(require("./mouth-types"), exports);

package/dist/intent-classifier.test.js

@@ -13,7 +13,6 @@ describe('IntentClassifier', () => {
         },
         conversation: {
             channel: 'direct',
-            audienceId: 'aud-1',
             correlationId: 'corr-1',
         },
     };

package/dist/memory-settler.js

@@ -26,7 +26,6 @@ async function settleMemoryProposals(params) {
                 companionId,
                 actorId: requestContext.actor.actorId,
                 channel: requestContext.conversation.channel,
-                audienceId: requestContext.conversation.audienceId,
             },
         };
         await memory.addSourceEvent(sourceEvent);
@@ -47,7 +46,6 @@ async function settleMemoryProposals(params) {
                 userConfirmation: 'none',
                 sensitivity: claim.sensitivity ||
                     (requestContext.conversation?.channel === 'public' ? 'public' : 'private'),
-                allowedAudiences: claim.allowedAudiences || (requestContext.conversation?.audienceId ? [requestContext.conversation.audienceId] : undefined),
             });
             createdMemoryProposals.push(proposal);
         }
@@ -63,7 +61,6 @@ async function settleMemoryProposals(params) {
                     sourceEventId: sourceEventId || p.sourceEventId,
                     claimType: p.claimType || 'semantic',
                     sensitivity: p.sensitivity || 'private',
-                    allowedAudiences: p.allowedAudiences || (requestContext.conversation?.audienceId ? [requestContext.conversation.audienceId] : undefined),
                 });
                 createdMemoryProposals.push(proposal);
             }

package/dist/perception-cycle.test.js

@@ -23,7 +23,6 @@ describe('SiduriRuntime Unified Perception Cycle & Session History', () => {
             },
             conversation: {
                 channel: 'direct',
-                audienceId: 'aud-direct',
                 correlationId: 'corr-perc-1',
             },
         };
@@ -89,7 +88,7 @@ describe('SiduriRuntime Unified Perception Cycle & Session History', () => {
                 capabilities: ['chat:public'],
                 authenticated: true,
             },
-            conversation: { channel: 'direct', audienceId: 'aud-alice', correlationId: 'c1' },
+            conversation: { channel: 'direct', correlationId: 'c1' },
         };
         const bobContext = {
             companionId: 'comp-multi',
@@ -100,7 +99,7 @@ describe('SiduriRuntime Unified Perception Cycle & Session History', () => {
                 capabilities: ['chat:public'],
                 authenticated: false,
             },
-            conversation: { channel: 'public', audienceId: 'aud-public', correlationId: 'c2' },
+            conversation: { channel: 'public', correlationId: 'c2' },
         };
         await runtime.handleUserMessage('Alice secret message', aliceContext);
         await runtime.handleUserMessage('Bob public query', bobContext);
@@ -122,7 +121,6 @@ describe('SiduriRuntime Unified Perception Cycle & Session History', () => {
             origin: 'knowledge',
             trust: 'configured',
             sensitivity: 'public',
-            allowedAudiences: ['audience-public'],
             companionId: 'comp-native-ev',
             correlationId: 'corr-test',
             createdAt: new Date().toISOString(),

package/dist/prompt-compiler.js

@@ -32,11 +32,8 @@ async function compilePrompts(params) {
     // Compile Behavior with neutral context metadata
     const behaviorInjections = behavior && typeof behavior.compile === 'function'
         ? await behavior.compile({
-            activeRole: role,
             directives: activeDirectives,
             companionId,
-            channel: requestContext.conversation.channel,
-            audienceId: requestContext.conversation.audienceId,
             actorId: requestContext.actor.actorId,
         })
         : '';

package/dist/prompt-compiler.test.js

@@ -13,7 +13,6 @@ describe('PromptCompiler', () => {
         },
         conversation: {
             channel: 'direct',
-            audienceId: 'aud-1',
             correlationId: 'corr-1',
         },
     };

package/dist/proposals.d.ts

@@ -16,7 +16,6 @@ export interface MemoryProposal {
     provenance?: string;
     claimType?: ClaimType;
     sensitivity?: string;
-    allowedAudiences?: string[];
     sourceEventId?: string;
 }
 export interface BehaviorProposal {

package/dist/runtime-facades.test.js

@@ -66,4 +66,30 @@ describe('SiduriRuntime Facade Methods & Delegation', () => {
         await runtime.resetMemory();
         expect(mockMemory.resetMemory).toHaveBeenCalled();
     });
+    test('configures SqliteActionStore when actionStore is sqlite', () => {
+        const runtime = new runtime_1.SiduriRuntime('comp-sqlite', {
+            id: 'comp-sqlite',
+            name: 'Sqlite Test',
+            actionStore: 'sqlite',
+        });
+        expect(runtime.actionPolicy.getStore()).toBeDefined();
+        // Verify it is an instance of SqliteActionStore
+        expect(runtime.actionPolicy.getStore().constructor.name).toBe('SqliteActionStore');
+    });
+    test('accepts custom actionStore via RuntimeOrgans', () => {
+        const customStore = {
+            recordExecution: jest.fn(),
+            getExecution: jest.fn(),
+            updateExecution: jest.fn(),
+            recordApproval: jest.fn(),
+            getApproval: jest.fn(),
+            recordAudit: jest.fn(),
+            getAuditLog: jest.fn(),
+            verifyAuditChain: jest.fn(),
+        };
+        const runtime = new runtime_1.SiduriRuntime('comp-custom', { id: 'comp-custom', name: 'Custom' }, {
+            actionStore: customStore,
+        });
+        expect(runtime.actionPolicy.getStore()).toBe(customStore);
+    });
 });

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, ObservationResult, Observation, Message, RequestContext, ActionPolicyEngine, ResponseGatingEngine, StageResponseOptions, ApproveResponseOptions, RejectResponseOptions, ExperienceDispatcher, ExperienceAdapter, OrganConfig, Claim, BehaviorDirective, StagedResponsePlan, ResponseGateEvaluation, EvidenceRecord, MouthOrgan, MouthUtterance, MouthMedium, FormattedMouthOutput, MouthStreamChunk, MouthChannel } from './index';
+import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, ObservationResult, Observation, Message, RequestContext, ActionPolicyEngine, ActionStore, ResponseGatingEngine, StageResponseOptions, ApproveResponseOptions, RejectResponseOptions, ExperienceDispatcher, ExperienceAdapter, OrganConfig, Claim, BehaviorDirective, StagedResponsePlan, ResponseGateEvaluation, EvidenceRecord, MouthOrgan, MouthUtterance, MouthMedium, FormattedMouthOutput, MouthStreamChunk, MouthChannel } from './index';
 export interface SiduriRuntimeConfig {
     name: string;
     brain?: OrganConfig | Record<string, unknown>;
@@ -13,6 +13,11 @@ export interface SiduriRuntimeConfig {
     observation?: OrganConfig | Record<string, unknown>;
     mouth?: 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 {
@@ -27,6 +32,7 @@ export interface RuntimeOrgans {
     ear?: EarOrgan;
     observation?: ObservationOrgan;
     mouth?: MouthOrgan;
+    actionStore?: ActionStore;
     actionPolicy?: ActionPolicyEngine;
 }
 export interface CompanionPerception {

package/dist/runtime.js

@@ -57,7 +57,17 @@ class SiduriRuntime {
         this.observation = organs.observation;
         this.mouth = organs.mouth;
         this.gating = new index_1.ResponseGatingEngine();
-        this.actionPolicy = organs.actionPolicy || new index_1.ActionPolicyEngine();
+        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.voice && typeof this.voice.handleEvent === 'function') {
             this.dispatcher.registerAdapter(this.voice);
@@ -214,7 +224,7 @@ class SiduriRuntime {
         // 1. Input validation, RequestContext synthesis, and Ear perception routing
         const input = await (0, input_normalizer_1.normalizeUserInput)(rawText, roleOrContext, history, this.id, this.ear);
         const sessionKey = input.requestContext.actor.sessionId ||
-            input.requestContext.conversation.audienceId ||
+            input.requestContext.conversation.correlationId ||
             'default';
         const currentMessage = { role: 'user', content: input.perceivedText };
         const boundedSessionHistory = [...input.boundedHistory, currentMessage].slice(-20);

package/dist/schema-validator.d.ts

@@ -0,0 +1,9 @@
+export declare class ConfigValidationError extends Error {
+    errors: string[];
+    constructor(errors: string[]);
+}
+/**
+ * Validates a companion configuration object against a JSON schema (draft-07 compatible).
+ * Throws ConfigValidationError if validation errors are detected.
+ */
+export declare function validateCompanionConfig(config: unknown, schema: any, path?: string): void;

package/dist/schema-validator.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidationError = void 0;
+exports.validateCompanionConfig = validateCompanionConfig;
+class ConfigValidationError extends Error {
+    errors;
+    constructor(errors) {
+        super(`Siduri configuration validation failed:\n${errors.map((e) => `  - ${e}`).join('\n')}`);
+        this.name = 'ConfigValidationError';
+        this.errors = errors;
+    }
+}
+exports.ConfigValidationError = ConfigValidationError;
+/**
+ * Validates a companion configuration object against a JSON schema (draft-07 compatible).
+ * Throws ConfigValidationError if validation errors are detected.
+ */
+function validateCompanionConfig(config, schema, path = '$') {
+    const errors = [];
+    function validateNode(value, nodeSchema, curPath) {
+        if (!nodeSchema || typeof nodeSchema !== 'object')
+            return;
+        // Type validation
+        if (nodeSchema.type !== undefined) {
+            const type = nodeSchema.type;
+            if (type === 'object') {
+                if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                    errors.push(`${curPath}: expected object, received ${value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'array') {
+                if (!Array.isArray(value)) {
+                    errors.push(`${curPath}: expected array, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'string') {
+                if (typeof value !== 'string') {
+                    errors.push(`${curPath}: expected string, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'number') {
+                if (typeof value !== 'number' || Number.isNaN(value)) {
+                    errors.push(`${curPath}: expected number, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'integer') {
+                if (typeof value !== 'number' || !Number.isInteger(value)) {
+                    errors.push(`${curPath}: expected integer, received ${typeof value}`);
+                    return;
+                }
+            }
+            else if (type === 'boolean') {
+                if (typeof value !== 'boolean') {
+                    errors.push(`${curPath}: expected boolean, received ${typeof value}`);
+                    return;
+                }
+            }
+        }
+        // Enum validation
+        if (Array.isArray(nodeSchema.enum)) {
+            if (!nodeSchema.enum.includes(value)) {
+                errors.push(`${curPath}: invalid value ${JSON.stringify(value)}, expected one of: ${nodeSchema.enum.map((v) => JSON.stringify(v)).join(', ')}`);
+                return;
+            }
+        }
+        // Object properties validation
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            if (Array.isArray(nodeSchema.required)) {
+                for (const reqKey of nodeSchema.required) {
+                    if (value[reqKey] === undefined) {
+                        errors.push(`${curPath}.${reqKey}: is required`);
+                    }
+                }
+            }
+            const definedProps = nodeSchema.properties || {};
+            if (nodeSchema.additionalProperties === false) {
+                for (const key of Object.keys(value)) {
+                    // Allow $schema property at root level
+                    if (curPath === '$' && key === '$schema')
+                        continue;
+                    if (!(key in definedProps)) {
+                        errors.push(`${curPath}.${key}: unexpected property is not allowed`);
+                    }
+                }
+            }
+            for (const [propName, propSchema] of Object.entries(definedProps)) {
+                if (value[propName] !== undefined) {
+                    validateNode(value[propName], propSchema, `${curPath}.${propName}`);
+                }
+            }
+        }
+        // Array items validation
+        if (Array.isArray(value) && nodeSchema.items) {
+            value.forEach((item, index) => {
+                validateNode(item, nodeSchema.items, `${curPath}[${index}]`);
+            });
+        }
+    }
+    validateNode(config, schema, path);
+    if (errors.length > 0) {
+        throw new ConfigValidationError(errors);
+    }
+}

package/dist/schema-validator.test.d.ts

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

package/dist/schema-validator.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_validator_1 = require("./schema-validator");
+describe('validateCompanionConfig', () => {
+    const sampleSchema = {
+        type: 'object',
+        required: ['id', 'name', 'organs'],
+        additionalProperties: false,
+        properties: {
+            $schema: { type: 'string' },
+            id: { type: 'string' },
+            name: { type: 'string' },
+            organs: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    brain: {
+                        type: 'object',
+                        required: ['provider', 'model'],
+                        properties: {
+                            provider: {
+                                type: 'string',
+                                enum: ['openrouter', 'openai-compatible'],
+                            },
+                            model: { type: 'string' },
+                        },
+                    },
+                    memory: {
+                        type: 'object',
+                        required: ['provider'],
+                        properties: {
+                            provider: {
+                                type: 'string',
+                                enum: ['postgres', 'in-memory', 'none'],
+                            },
+                            maxConnections: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    test('accepts valid configuration matching schema', () => {
+        const validConfig = {
+            $schema: './siduri.schema.json',
+            id: 'companion-1',
+            name: 'Test Companion',
+            organs: {
+                brain: {
+                    provider: 'openrouter',
+                    model: 'gpt-4o',
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(validConfig, sampleSchema)).not.toThrow();
+    });
+    test('throws ConfigValidationError if missing required root field', () => {
+        const invalidConfig = {
+            name: 'Missing Id and Organs',
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.id: is required');
+            expect(err.errors).toContain('$.organs: is required');
+        }
+    });
+    test('throws ConfigValidationError on unexpected property when additionalProperties is false', () => {
+        const invalidConfig = {
+            id: 'c-1',
+            name: 'Test',
+            organs: {},
+            extraField: 'not allowed',
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.extraField: unexpected property is not allowed');
+        }
+    });
+    test('throws ConfigValidationError on invalid enum value', () => {
+        const invalidConfig = {
+            id: 'c-1',
+            name: 'Test',
+            organs: {
+                brain: {
+                    provider: 'invalid-brain-provider',
+                    model: 'gpt-4',
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors.some((e) => e.includes('invalid value "invalid-brain-provider"'))).toBe(true);
+        }
+    });
+    test('throws ConfigValidationError on invalid type', () => {
+        const invalidConfig = {
+            id: 12345, // should be string
+            name: 'Test',
+            organs: {
+                memory: {
+                    provider: 'postgres',
+                    maxConnections: 'ten', // should be number
+                },
+            },
+        };
+        expect(() => (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema)).toThrow(schema_validator_1.ConfigValidationError);
+        try {
+            (0, schema_validator_1.validateCompanionConfig)(invalidConfig, sampleSchema);
+        }
+        catch (err) {
+            expect(err.errors).toContain('$.id: expected string, received number');
+            expect(err.errors).toContain('$.organs.memory.maxConnections: expected number, received string');
+        }
+    });
+});

package/dist/sqlite-action-store.test.js

@@ -210,7 +210,6 @@ describe('SqliteActionStore Implementation & Durability', () => {
             },
             conversation: {
                 channel: 'direct',
-                audienceId: 'aud-local',
                 correlationId: 'corr-1',
             },
         };

package/dist/teaching.d.ts

@@ -4,12 +4,12 @@ export interface ExtractedTeaching {
     behaviorProposals: BehaviorProposal[];
 }
 /**
- * Deterministically extracts teaching candidates from user messages according to neutral T1/T2 contracts.
+ * Deterministically extracts teaching candidates from user messages according to single-owner model.
  *
  * Rules:
  * - Scoped to the requesting actor context (subject: `actor:${actorId}`), NEVER `primary_user`.
  * - Candidates are pending proposals only, never active/approved.
- * - Allowed audiences derive from the request conversation or policy context (e.g. direct audience).
+ * - In a single-owner companion, preferences apply across the companion instance without audience partitioning.
  * - Companion identity is isolated.
  */
 export declare function extractDeterministicTeaching(message: string, context?: RequestContext, sourceEventId?: string): ExtractedTeaching;

package/dist/teaching.js

@@ -5,12 +5,12 @@ function cleanValue(value, limit = 160) {
     return value.replace(/\s+/g, ' ').replace(/^[ .,!?:;"']+|[ .,!?:;"']+$/g, '').slice(0, limit);
 }
 /**
- * Deterministically extracts teaching candidates from user messages according to neutral T1/T2 contracts.
+ * Deterministically extracts teaching candidates from user messages according to single-owner model.
  *
  * Rules:
  * - Scoped to the requesting actor context (subject: `actor:${actorId}`), NEVER `primary_user`.
  * - Candidates are pending proposals only, never active/approved.
- * - Allowed audiences derive from the request conversation or policy context (e.g. direct audience).
+ * - In a single-owner companion, preferences apply across the companion instance without audience partitioning.
  * - Companion identity is isolated.
  */
 function extractDeterministicTeaching(message, context, sourceEventId) {
@@ -23,7 +23,6 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
     const actorId = context?.actor?.actorId;
     const actorSubject = actorId ? `actor:${actorId}` : 'actor:anonymous';
     const companionId = context?.companionId || 'default';
-    const defaultAudience = context?.conversation?.audienceId || (context?.conversation?.channel === 'direct' ? `audience-direct-${actorId}` : 'audience-public');
     const sensitivity = context?.conversation?.channel === 'public' ? 'public' : 'private';
     // 1. Companion's Name: "your name is X" / "you are called X"
     const companionNameMatch = text.match(/\b(?:your name is|you are called)\s+(.+?)(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
@@ -37,7 +36,6 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             claimType: 'semantic',
             provenance: 'deterministic_teaching',
             sensitivity: 'public',
-            allowedAudiences: ['audience-public'],
             sourceEventId,
         });
         behaviorProposals.push({
@@ -62,36 +60,14 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             claimType: 'preference',
             provenance: 'deterministic_teaching',
             sensitivity,
-            allowedAudiences: [defaultAudience],
             sourceEventId,
         });
     }
     // 3. Preferred Address / Call me X: "call me X"
-    const callMeMatch = text.match(/\b(?:(?:from now on|only),?\s*)?call me\s+(.+?)(?:\s+(in private|privately|in public|publicly|everywhere|in direct conversations))?(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
+    const callMeMatch = text.match(/\b(?:(?:from now on|only),?\s*)?call me\s+(.+?)(?:\s+(?:in private|privately|in public|publicly|everywhere|in direct conversations))?(?=\s+and\s+(?:i\b|my\b|you\b)|[.;,]|$)/i);
     if (callMeMatch) {
         const address = cleanValue(callMeMatch[1], 80);
-        const scopePhrase = (callMeMatch[2] || '').toLowerCase();
-        let claimAudiences = [defaultAudience];
-        let claimSensitivity = sensitivity;
-        let directiveInstruction = `Address ${actorSubject} as ${address}`;
-        if (scopePhrase.includes('private') || scopePhrase.includes('privately')) {
-            claimSensitivity = 'private';
-            claimAudiences = [context?.conversation?.audienceId || `audience-private-${actorId}`];
-            directiveInstruction += ' in private conversations';
-        }
-        else if (scopePhrase.includes('public') || scopePhrase.includes('publicly')) {
-            claimSensitivity = 'public';
-            claimAudiences = ['audience-public'];
-            directiveInstruction += ' in public conversations';
-        }
-        else if (scopePhrase.includes('direct')) {
-            claimSensitivity = 'private';
-            claimAudiences = [context?.conversation?.audienceId || `audience-direct-${actorId}`];
-            directiveInstruction += ' in direct conversations';
-        }
-        else {
-            directiveInstruction += ' when addressing the actor';
-        }
+        const directiveInstruction = `Address ${actorSubject} as ${address}`;
         claims.push({
             subject: actorSubject,
             predicate: 'preferred_address',
@@ -99,8 +75,7 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             content: `The actor's preferred address is ${address}.`,
             claimType: 'relationship',
             provenance: 'deterministic_teaching',
-            sensitivity: claimSensitivity,
-            allowedAudiences: claimAudiences,
+            sensitivity,
             sourceEventId,
         });
         behaviorProposals.push({
@@ -125,7 +100,6 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             claimType: 'relationship',
             provenance: 'deterministic_teaching',
             sensitivity: 'private',
-            allowedAudiences: [defaultAudience],
             sourceEventId,
         });
         behaviorProposals.push({
@@ -151,7 +125,6 @@ function extractDeterministicTeaching(message, context, sourceEventId) {
             claimType: 'preference',
             provenance: 'deterministic_teaching',
             sensitivity,
-            allowedAudiences: [defaultAudience],
             sourceEventId,
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siduri-x/core",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Core runtime types, evidence protocol, action dispatcher, capability validation, and SiduriRuntime protocol",
   "license": "Apache-2.0",
   "repository": {