@siduri-x/core 1.0.4 → 1.0.7

package/dist/evidence.d.ts

@@ -1,3 +1,4 @@
+import { MemoryProposal, BehaviorProposal } from './proposals';
 export type EvidenceOrigin = 'knowledge' | 'observation' | 'ocr' | 'platform' | 'conversation';
 export type EvidenceTrust = 'configured' | 'provider' | 'untrusted';
 export type EvidenceSensitivity = 'public' | 'private' | 'restricted';
@@ -14,10 +15,11 @@ export interface EvidenceRecord {
     createdAt: string;
     expiresAt?: string;
     trust: EvidenceTrust;
-    sensitivity: EvidenceSensitivity;
-    allowedAudiences: string[];
+    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';
@@ -32,8 +34,8 @@ export interface StagedResponsePlan {
     responseId: string;
     companionId: string;
     correlationId: string;
-    channel: 'public' | 'direct' | 'private' | 'operator';
-    audienceId: string;
+    channel?: string;
+    audienceId?: string;
     speech: string;
     language: string;
     evidenceIds: string[];
@@ -44,9 +46,10 @@ export interface StagedResponsePlan {
     status: ResponseApprovalStatus;
     createdAt: string;
     expiresAt?: string;
-    memoryProposals?: any[];
-    behaviorProposals?: any[];
+    memoryProposals?: MemoryProposal[];
+    behaviorProposals?: BehaviorProposal[];
     internalMonologue?: string;
+    [key: string]: unknown;
 }
 export interface ResponseGateEvaluation {
     admissible: boolean;
@@ -59,9 +62,10 @@ export interface ResponseGateEvaluation {
 }
 export interface EvidenceFilterOptions {
     companionId: string;
-    channel: 'public' | 'direct' | 'private' | 'operator';
-    audienceId: string;
+    channel?: string;
+    audienceId?: string;
     now?: string | Date;
+    [key: string]: unknown;
 }
 export declare function filterEvidenceRecords(records: EvidenceRecord[], options: EvidenceFilterOptions): {
     admitted: EvidenceRecord[];

package/dist/evidence.js

@@ -19,16 +19,18 @@ function filterEvidenceRecords(records, options) {
                 continue;
             }
         }
-        // 3. Audience intersection
-        if (record.allowedAudiences &&
+        // 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. Sensitivity policy based on channel
+        // 4. Optional channel sensitivity policy (if channel explicitly specified)
         if (options.channel === 'public') {
-            if (record.sensitivity !== 'public') {
+            if (record.sensitivity && record.sensitivity !== 'public') {
                 excluded.push({ record, reason: 'sensitivity_private_in_public_channel' });
                 continue;
             }

package/dist/experience-emitter.d.ts

@@ -0,0 +1,21 @@
+import { RequestContext, StagedResponsePlan, ResponseGateEvaluation, ExperienceDispatcher, ExperienceEvent, ExperienceAdapter, VoiceOrgan, BodyOrgan } from './index';
+export interface ExperienceEmissionParams {
+    companionId: string;
+    requestContext: RequestContext;
+    stagedPlan: StagedResponsePlan;
+    gateEval: ResponseGateEvaluation;
+    speech: string;
+    language: string;
+    dispatcher: ExperienceDispatcher;
+    voice?: VoiceOrgan | ExperienceAdapter;
+    body?: BodyOrgan | ExperienceAdapter;
+}
+export interface ExperienceEmissionResult {
+    experienceEvents: ExperienceEvent[];
+    speechId?: string;
+}
+/**
+ * Creates ExperienceEvents, dispatches them through the ExperienceDispatcher,
+ * and coordinates backward-compatible fallbacks for legacy Voice/Body adapters.
+ */
+export declare function emitExperienceEvents(params: ExperienceEmissionParams): Promise<ExperienceEmissionResult>;

package/dist/experience-emitter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitExperienceEvents = emitExperienceEvents;
+const index_1 = require("./index");
+/**
+ * Creates ExperienceEvents, dispatches them through the ExperienceDispatcher,
+ * and coordinates backward-compatible fallbacks for legacy Voice/Body adapters.
+ */
+async function emitExperienceEvents(params) {
+    const { companionId, requestContext, stagedPlan, gateEval, speech, language, dispatcher, voice, body, } = params;
+    const experienceEvents = (0, index_1.createExperienceEvents)({
+        responseId: stagedPlan.responseId,
+        companionId,
+        correlationId: requestContext.conversation.correlationId,
+        channel: requestContext.conversation?.channel,
+        audienceId: requestContext.conversation?.audienceId,
+        speech,
+        language: language || 'ja',
+        evidenceIds: gateEval.filteredEvidenceIds,
+        citations: gateEval.filteredCitations,
+        expression: 'neutral',
+        action: 'talk',
+        expiresAt: stagedPlan.expiresAt,
+    });
+    const dispatchResult = await dispatcher.dispatchEvents(experienceEvents);
+    let speechId;
+    const voiceResult = dispatchResult.eventResults.find((r) => r.event.kind === 'voice');
+    if (voiceResult?.result?.metadata?.speechId) {
+        speechId = voiceResult.result.metadata.speechId;
+    }
+    else if (voice &&
+        typeof voice.handleEvent !== 'function' &&
+        typeof voice.enqueueSpeech === 'function') {
+        speechId = voice.enqueueSpeech(speech, language || 'ja', 1);
+    }
+    if (body && typeof body.handleEvent !== 'function') {
+        if (typeof body.setExpression === 'function') {
+            body.setExpression('neutral');
+        }
+        if (typeof body.act === 'function') {
+            body.act('talk');
+        }
+    }
+    return {
+        experienceEvents,
+        speechId,
+    };
+}

package/dist/experience.d.ts

@@ -1,4 +1,3 @@
-import { Channel } from './context';
 import { ResponseCitation } from './evidence';
 export type ExperienceEventKind = 'voice' | 'caption' | 'avatar' | 'platform_action';
 export type ExperienceEventLifecycle = 'STARTED' | 'PROGRESS' | 'COMPLETED' | 'FAILED';
@@ -7,8 +6,8 @@ export interface ExperienceEvent {
     companionId: string;
     responseId: string;
     correlationId: string;
-    channel: Channel;
-    audienceId: string;
+    channel?: string;
+    audienceId?: string;
     approval: 'APPROVED';
     kind: ExperienceEventKind;
     lifecycle: ExperienceEventLifecycle;
@@ -20,6 +19,7 @@ export interface ExperienceEvent {
     expression?: string;
     createdAt: string;
     expiresAt?: string;
+    [key: string]: unknown;
 }
 export interface ExperienceAdapterResult {
     accepted: boolean;
@@ -38,8 +38,8 @@ export interface CreateExperienceEventsOptions {
     responseId: string;
     companionId: string;
     correlationId: string;
-    channel: Channel;
-    audienceId: string;
+    channel?: string;
+    audienceId?: string;
     speech: string;
     language?: string;
     evidenceIds?: string[];
@@ -48,6 +48,7 @@ export interface CreateExperienceEventsOptions {
     action?: string;
     expiresAt?: string;
     now?: string | Date;
+    [key: string]: unknown;
 }
 export declare function createExperienceEvents(options: CreateExperienceEventsOptions): ExperienceEvent[];
 export declare function validateExperienceEvent(event: unknown): {

package/dist/experience.js

@@ -62,8 +62,9 @@ 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 || typeof e.audienceId !== 'string')
-        return { valid: false, error: 'Missing or invalid audienceId' };
+    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

@@ -50,9 +50,10 @@ describe('T5 Experience Event Contract Suite', () => {
         const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
         const missingCompanion = { ...events[0], companionId: '' };
         expect((0, experience_1.validateExperienceEvent)(missingCompanion).valid).toBe(false);
-        const missingCorr = { ...events[0], correlationId: '' };
-        expect((0, experience_1.validateExperienceEvent)(missingCorr).valid).toBe(false);
-        const missingAudience = { ...events[0], audienceId: '' };
-        expect((0, experience_1.validateExperienceEvent)(missingAudience).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

@@ -1,12 +1,13 @@
 import { RequestContext } from './context';
+import { MemoryProposal, BehaviorProposal } from './proposals';
 import { EvidenceRecord, StagedResponsePlan, ResponseGateEvaluation, ResponseCitation } from './evidence';
 export interface StageResponseOptions {
     requestContext: RequestContext;
     candidateSpeech: string;
     candidateLanguage: string;
     internalMonologue?: string;
-    memoryProposals?: any[];
-    behaviorProposals?: any[];
+    memoryProposals?: MemoryProposal[];
+    behaviorProposals?: BehaviorProposal[];
     evidenceRecords?: EvidenceRecord[];
     citations?: ResponseCitation[];
     requiresApproval?: boolean;

package/dist/gating.js

@@ -34,14 +34,13 @@ class ResponseGatingEngine {
         }
         const requiresApproval = options.requiresApproval !== undefined
             ? options.requiresApproval
-            : requestContext.conversation.channel === 'operator' ||
-                evidenceRecords.some((e) => e.origin === 'ocr' || e.trust === 'untrusted');
+            : evidenceRecords.some((e) => e.origin === 'ocr' || e.trust === 'untrusted');
         const staged = {
             responseId: generateId('resp'),
             companionId: requestContext.companionId,
             correlationId: requestContext.conversation.correlationId,
-            channel: requestContext.conversation.channel,
-            audienceId: requestContext.conversation.audienceId,
+            channel: requestContext.conversation?.channel,
+            audienceId: requestContext.conversation?.audienceId,
             speech: options.candidateSpeech,
             language: options.candidateLanguage,
             evidenceIds,
@@ -118,7 +117,7 @@ class ResponseGatingEngine {
                 filteredEvidenceIds: admittedEvidenceIds,
                 filteredCitations,
                 diagnostics: {
-                    detail: 'Response plan requires operator approval before external emission',
+                    detail: 'Response plan requires approval before external emission',
                     excludedEvidenceCount: String(excluded.length),
                 },
             };
@@ -147,9 +146,6 @@ class ResponseGatingEngine {
         if (plan.correlationId !== options.correlationId) {
             return { success: false, reason: 'APPROVAL_ID_MISMATCH' };
         }
-        if (options.audienceId && plan.audienceId !== options.audienceId) {
-            return { success: false, reason: 'AUDIENCE_MISMATCH' };
-        }
         if (plan.status === 'EXPIRED') {
             return { success: false, reason: 'EVIDENCE_EXPIRED' };
         }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './context';
+export * from './proposals';
 export * from './evidence';
 export * from './gating';
 export * from './experience';
@@ -7,14 +8,28 @@ export * from './action';
 export * from './action-policy';
 export * from './ear-types';
 export * from './capability';
+export * from './sqlite-action-store';
 export * from './teaching';
 export * from './runtime';
 export * from './chat-contract';
+export * from './input-normalizer';
+export * from './intent-classifier';
+export * from './context-retriever';
+export * from './prompt-compiler';
+export * from './cognition-planner';
+export * from './memory-settler';
+export * from './action-executor';
+export * from './experience-emitter';
+export * from './response-envelope';
+export * from './session-history';
+import { EvidenceRecord } from './evidence';
 import { ActionIntent } from './action';
+import { RequestContext } from './context';
 import { EarIngestOptions } from './ear-types';
+import { ClaimType, ClaimAuthority, ClaimStatus, SourceEvent, MemoryProposal, BehaviorProposal } from './proposals';
 export interface OrganConfig {
     provider: string;
-    [key: string]: any;
+    [key: string]: unknown;
 }
 export interface CompanionConfig {
     id: string;
@@ -38,36 +53,6 @@ export interface BrainContext {
     recentMessages: Message[];
     recipient?: MemoryScope;
 }
-export type ClaimType = 'semantic' | 'preference' | 'episodic' | 'relationship';
-export type ClaimAuthority = 'user_explicit' | 'user_correction' | 'import' | 'repeated_dialogue' | 'inference' | 'observation';
-export type ClaimStatus = 'PENDING' | 'APPROVED' | 'REJECTED' | 'SESSION_ONLY' | 'EXPIRED' | 'SUPERSEDED' | 'REVOKED';
-export interface SourceEvent {
-    id: string;
-    sourceType: string;
-    occurredAt: string;
-    payload: Record<string, unknown>;
-    schemaVersion?: number;
-}
-export interface MemoryProposal {
-    subject: string;
-    predicate: string;
-    value: string;
-    content?: string;
-    provenance?: string;
-    claimType?: ClaimType;
-    sensitivity?: string;
-    allowedAudiences?: string[];
-    sourceEventId?: string;
-}
-export interface BehaviorProposal {
-    directive: string;
-    priority: number;
-    subject?: string;
-    predicate?: string;
-    value?: string;
-    memoryClass?: 'identity' | 'relationship' | 'behavioral' | 'semantic' | 'episodic';
-    sourceEventId?: string;
-}
 export interface ResponsePlan {
     speech: string;
     language: string;
@@ -79,7 +64,7 @@ export interface ResponsePlan {
 export interface BrainOrgan {
     generatePlan(context: BrainContext): Promise<ResponsePlan>;
 }
-export type MemoryScope = 'OWNER' | 'VIEWER' | 'OPERATOR' | 'PUBLIC';
+export type MemoryScope = 'companion' | 'user' | string;
 export interface Claim {
     id: string;
     subject: string;
@@ -87,7 +72,7 @@ export interface Claim {
     value: string;
     status: ClaimStatus;
     evidence?: string[];
-    scope: MemoryScope;
+    scope?: MemoryScope;
     companionId: string;
     provenance?: string;
     sourceEventId?: string;
@@ -95,19 +80,18 @@ export interface Claim {
     authority?: ClaimAuthority;
     userConfirmation?: 'explicit' | 'implied' | 'none';
     sensitivity?: string;
-    allowedAudiences?: string[];
     confidence?: number;
     assertedAt?: string;
     validFrom?: string;
     validUntil?: string;
     supersedes?: string;
     replaces?: string;
+    [key: string]: unknown;
 }
 export interface BehaviorDirective {
     id: string;
     companionId: string;
     directive: string;
-    scopeMatcher: string[];
     priority: number;
     status: 'PENDING' | 'ACTIVE' | 'DISABLED' | 'SUPERSEDED' | 'REJECTED' | 'REVOKED' | 'EXPIRED';
     supersedesId?: string;
@@ -115,22 +99,21 @@ export interface BehaviorDirective {
     subject?: string;
     predicate?: string;
     value?: string;
-    allowedAudiences?: string[];
     validFrom?: string;
     validUntil?: string;
+    [key: string]: unknown;
 }
 export interface MemoryQueryOptions {
-    channel?: 'public' | 'direct' | 'private' | 'operator';
-    audienceId?: string;
     sensitivity?: string;
     limit?: number;
     minConfidence?: number;
     now?: string | Date;
+    [key: string]: unknown;
 }
 export interface MemoryOrgan {
     initialize(companionId: string): Promise<void>;
     proposeClaim(claim: Omit<Claim, 'id' | 'status' | 'companionId'>): Promise<Claim>;
-    searchClaims(query: string, scopeOrOptions: MemoryScope | MemoryQueryOptions, limit?: number): Promise<Claim[]>;
+    searchClaims(query: string, scopeOrOptions?: MemoryScope | MemoryQueryOptions, limit?: number): Promise<Claim[]>;
     getClaims(limit?: number): Promise<Claim[]>;
     getPendingClaims(limit?: number): Promise<Claim[]>;
     approveClaim(id: string): Promise<void>;
@@ -146,7 +129,7 @@ export interface MemoryOrgan {
     disableDirective(id: string): Promise<void>;
     expireDirective?(id: string): Promise<void>;
     supersedeClaim?(id: string, replacement: Omit<Claim, 'id' | 'status' | 'companionId'>): Promise<Claim>;
-    updateClaim?(id: string, updates: Partial<Pick<Claim, 'subject' | 'predicate' | 'value' | 'scope' | 'sensitivity' | 'confidence' | 'validFrom' | 'validUntil' | 'allowedAudiences'>>): Promise<Claim>;
+    updateClaim?(id: string, updates: Partial<Pick<Claim, 'subject' | 'predicate' | 'value' | 'scope' | 'sensitivity' | 'confidence' | 'validFrom' | 'validUntil'>>): Promise<Claim>;
     resetMemory?(): Promise<void>;
     addSourceEvent?(event: SourceEvent): Promise<SourceEvent>;
     getSourceEvent?(id: string): Promise<SourceEvent | undefined>;
@@ -179,14 +162,12 @@ export interface ActiveSelfProjection {
     render(): string;
 }
 export interface BehaviorContext {
-    activeRole: string;
     directives: BehaviorDirective[];
     companionId?: string;
-    channel?: 'public' | 'direct' | 'private' | 'operator';
-    audienceId?: string;
     actorId?: string;
     sessionId?: string;
     now?: string;
+    [key: string]: unknown;
 }
 export interface BehaviorOrgan {
     compile(context: BehaviorContext): Promise<string>;
@@ -197,6 +178,7 @@ export interface KnowledgeItem {
     provenance: string;
     revision: string;
     citations: KnowledgeCitation[];
+    evidenceRecord?: EvidenceRecord;
 }
 export interface KnowledgeCitation {
     sourceId: string;
@@ -218,6 +200,7 @@ export interface EarPerception {
 export interface EarOrgan {
     listen(source: string, payload: unknown, options?: EarIngestOptions): Promise<EarPerception>;
     transcribeAudio?(audio: Uint8Array): Promise<string>;
+    classifyIntent?(text: string, context?: RequestContext): Promise<Record<string, unknown>> | Record<string, unknown>;
 }
 export interface BodyOrgan {
     setExpression(expression: string): void;
@@ -264,3 +247,4 @@ export interface HealthProbeResult {
     details?: Record<string, unknown>;
 }
 export type HealthProbeFn = (context: HealthProbeContext) => Promise<HealthProbeResult> | HealthProbeResult;
+export * from './mouth-types';

package/dist/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // Export neutral context types and validator
 __exportStar(require("./context"), exports);
+__exportStar(require("./proposals"), exports);
 __exportStar(require("./evidence"), exports);
 __exportStar(require("./gating"), exports);
 __exportStar(require("./experience"), exports);
@@ -24,6 +25,19 @@ __exportStar(require("./action"), exports);
 __exportStar(require("./action-policy"), exports);
 __exportStar(require("./ear-types"), exports);
 __exportStar(require("./capability"), exports);
+__exportStar(require("./sqlite-action-store"), exports);
 __exportStar(require("./teaching"), exports);
 __exportStar(require("./runtime"), exports);
 __exportStar(require("./chat-contract"), exports);
+__exportStar(require("./input-normalizer"), exports);
+__exportStar(require("./intent-classifier"), exports);
+__exportStar(require("./context-retriever"), exports);
+__exportStar(require("./prompt-compiler"), exports);
+__exportStar(require("./cognition-planner"), exports);
+__exportStar(require("./memory-settler"), exports);
+__exportStar(require("./action-executor"), exports);
+__exportStar(require("./experience-emitter"), exports);
+__exportStar(require("./response-envelope"), exports);
+__exportStar(require("./session-history"), exports);
+// Mouth (Communication & Output Delivery)
+__exportStar(require("./mouth-types"), exports);

package/dist/input-normalizer.d.ts

@@ -0,0 +1,14 @@
+import { Message, RequestContext, EarOrgan } from './index';
+export interface NormalizedInput {
+    perceivedText: string;
+    sanitizedText: string;
+    requestContext: RequestContext;
+    role: 'OWNER' | 'VIEWER' | 'OPERATOR';
+    isContextObject: boolean;
+    boundedHistory: Message[];
+}
+/**
+ * Validates raw user input, synthesizes RequestContext, normalizes history,
+ * and routes input through EarOrgan if available.
+ */
+export declare function normalizeUserInput(message: string, roleOrContext: ("OWNER" | "VIEWER" | "OPERATOR" | RequestContext | string) | undefined, history: Message[] | undefined, companionId: string, ear?: EarOrgan): Promise<NormalizedInput>;

package/dist/input-normalizer.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeUserInput = normalizeUserInput;
+/**
+ * Validates raw user input, synthesizes RequestContext, normalizes history,
+ * and routes input through EarOrgan if available.
+ */
+async function normalizeUserInput(message, roleOrContext = 'OWNER', history = [], companionId, ear) {
+    if (typeof message !== 'string' || !message.trim() || message.length > 4000) {
+        throw new Error('message must be a non-empty string of at most 4000 characters');
+    }
+    if (!Array.isArray(history) ||
+        history.length > 20 ||
+        history.some((item) => !item || !['user', 'assistant'].includes(item.role) || typeof item.content !== 'string')) {
+        throw new Error('history must contain at most 20 user/assistant messages');
+    }
+    const isContextObject = typeof roleOrContext === 'object' && roleOrContext !== null;
+    const role = isContextObject
+        ? (roleOrContext.actor?.authorizationRole === 'viewer' ? 'VIEWER' : 'OWNER')
+        : roleOrContext;
+    const requestContext = isContextObject
+        ? roleOrContext
+        : {
+            companionId,
+            actor: {
+                actorId: role === 'VIEWER' ? 'anonymous-session' : 'owner-user',
+                sessionId: `sess-${companionId}`,
+                authorizationRole: role === 'VIEWER' ? 'viewer' : 'administrator',
+                capabilities: role === 'VIEWER' ? ['chat'] : ['chat', 'memory:approve', 'action:execute'],
+                authenticated: role !== 'VIEWER',
+            },
+            conversation: {
+                channel: 'direct',
+                correlationId: `corr-${Date.now()}`,
+            },
+            source: 'local',
+        };
+    // Universal Perception: Route user input through EarOrgan if available
+    let perceivedText = message;
+    if (ear && typeof ear.listen === 'function') {
+        const perception = await ear.listen('text_chat', message, {
+            context: requestContext,
+        });
+        perceivedText = perception.text || message;
+    }
+    const boundedHistory = history.map((item) => ({
+        role: item.role,
+        content: item.content.slice(0, 2000).replace(/\0/g, ''),
+    }));
+    return {
+        perceivedText,
+        sanitizedText: message,
+        requestContext,
+        role,
+        isContextObject,
+        boundedHistory,
+    };
+}

package/dist/input-normalizer.test.d.ts

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

package/dist/input-normalizer.test.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const input_normalizer_1 = require("./input-normalizer");
+describe('InputNormalizer', () => {
+    test('rejects empty or oversized messages', async () => {
+        await expect((0, input_normalizer_1.normalizeUserInput)('', 'OWNER', [], 'comp-1')).rejects.toThrow('message must be a non-empty string of at most 4000 characters');
+        await expect((0, input_normalizer_1.normalizeUserInput)('   ', 'OWNER', [], 'comp-1')).rejects.toThrow('message must be a non-empty string of at most 4000 characters');
+        const oversized = 'a'.repeat(4001);
+        await expect((0, input_normalizer_1.normalizeUserInput)(oversized, 'OWNER', [], 'comp-1')).rejects.toThrow('message must be a non-empty string of at most 4000 characters');
+    });
+    test('rejects oversized history or invalid message roles', async () => {
+        const invalidHistory = Array(21).fill({ role: 'user', content: 'hi' });
+        await expect((0, input_normalizer_1.normalizeUserInput)('hi', 'OWNER', invalidHistory, 'comp-1')).rejects.toThrow('history must contain at most 20 user/assistant messages');
+        const malformedRole = [{ role: 'bad_role', content: 'test' }];
+        await expect((0, input_normalizer_1.normalizeUserInput)('hi', 'OWNER', malformedRole, 'comp-1')).rejects.toThrow('history must contain at most 20 user/assistant messages');
+    });
+    test('normalizes role string into full RequestContext and strips null bytes from history', async () => {
+        const historyWithNulls = [{ role: 'user', content: 'hello\0world' }];
+        const result = await (0, input_normalizer_1.normalizeUserInput)('hello', 'OWNER', historyWithNulls, 'comp-1');
+        expect(result.role).toBe('OWNER');
+        expect(result.requestContext.companionId).toBe('comp-1');
+        expect(result.requestContext.actor.authorizationRole).toBe('administrator');
+        expect(result.requestContext.actor.authenticated).toBe(true);
+        expect(result.boundedHistory[0].content).toBe('helloworld');
+    });
+    test('routes input through EarOrgan when present', async () => {
+        const mockEar = {
+            listen: jest.fn().mockResolvedValue({
+                id: 'perc-1',
+                source: 'text_chat',
+                text: 'transcribed text',
+                timestamp: new Date().toISOString(),
+            }),
+        };
+        const result = await (0, input_normalizer_1.normalizeUserInput)('raw text', 'VIEWER', [], 'comp-1', mockEar);
+        expect(mockEar.listen).toHaveBeenCalledWith('text_chat', 'raw text', expect.anything());
+        expect(result.perceivedText).toBe('transcribed text');
+    });
+});

package/dist/intent-classifier.d.ts

@@ -0,0 +1,24 @@
+import { RequestContext } from './index';
+import { extractDeterministicTeaching } from './teaching';
+export interface IntentClassification {
+    normalizedMessage: string;
+    explicitTeaching: ReturnType<typeof extractDeterministicTeaching>;
+    isTeachingLike: boolean;
+    isSelfIdentityRequest: boolean;
+    isGreeting: boolean;
+    shouldQueryKnowledge: boolean;
+    confidence?: number;
+    classifierOrigin?: 'heuristic' | 'cognitive' | 'ear';
+}
+export type CognitiveIntentClassifier = (text: string, context: RequestContext) => Promise<Partial<IntentClassification>> | Partial<IntentClassification>;
+/**
+ * Evaluates domain heuristics and intent classification for user messages.
+ * Determines if deterministic teaching is present and whether external knowledge
+ * retrieval is appropriate.
+ */
+export declare function classifyInputIntent(text: string, context: RequestContext, overrides?: Partial<IntentClassification>): IntentClassification;
+/**
+ * Asynchronously classifies intent, allowing an EarOrgan or cognitive model
+ * to provide semantic classification before falling back to heuristics.
+ */
+export declare function classifyInputIntentAsync(text: string, context: RequestContext, classifier?: CognitiveIntentClassifier): Promise<IntentClassification>;