@siduri-x/core 1.0.4 → 1.0.7

package/dist/action-executor.d.ts

@@ -0,0 +1,12 @@
+import { ActionIntent, ActionExecutionResult, ActionPolicyEngine, HandsOrgan, RequestContext } from './index';
+export interface ActionExecutionParams {
+    actionIntents?: ActionIntent[];
+    requestContext: RequestContext;
+    actionPolicy: ActionPolicyEngine;
+    hands?: HandsOrgan;
+}
+/**
+ * Executes proposed actions under the primary security invariant:
+ * "Brain proposes; the policy layer authorizes; Hands executes; the audit layer records."
+ */
+export declare function executeActionIntents(params: ActionExecutionParams): Promise<ActionExecutionResult[]>;

package/dist/action-executor.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeActionIntents = executeActionIntents;
+/**
+ * Executes proposed actions under the primary security invariant:
+ * "Brain proposes; the policy layer authorizes; Hands executes; the audit layer records."
+ */
+async function executeActionIntents(params) {
+    const { actionIntents, requestContext, actionPolicy, hands } = params;
+    const actionResults = [];
+    if (!hands ||
+        !actionIntents ||
+        actionIntents.length === 0 ||
+        typeof hands.executeAction !== 'function') {
+        return actionResults;
+    }
+    for (const rawAction of actionIntents) {
+        // 1. Context Propagation: Attach request provenance to ActionIntent
+        const actionWithContext = {
+            ...rawAction,
+            context: requestContext,
+            executionId: rawAction.executionId ||
+                `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        };
+        // 2. Action Policy Authorization Boundary Check
+        const { decision, capability } = await actionPolicy.evaluateAction(actionWithContext, requestContext);
+        if (!decision.allowed || !capability) {
+            // Action was rejected by policy
+            actionResults.push({
+                actionId: actionWithContext.actionId,
+                executionId: decision.executionId,
+                toolName: actionWithContext.toolName,
+                lifecycle: 'REJECTED',
+                success: false,
+                error: `Action authorization rejected by policy: ${decision.reason}`,
+                decision,
+            });
+            continue;
+        }
+        // 3. Hands Execution (only authorized actions execute with AuthorizationCapability)
+        const res = await hands.executeAction(actionWithContext, capability);
+        actionResults.push({
+            ...res,
+            decision,
+        });
+        // 4. Audit recording for execution outcome
+        await actionPolicy.recordAudit(actionWithContext, requestContext, decision, res.lifecycle, res.result, res.error, res.durationMs);
+    }
+    return actionResults;
+}

package/dist/action-policy.js

@@ -15,12 +15,7 @@ class ActionPolicyEngine {
         this.defaultRiskLevel = options.defaultRiskLevel ?? 'HIGH';
         this.defaultRequireApprovalForHighRisk = options.defaultRequireApprovalForHighRisk ?? true;
         this.store = options.store ?? new capability_1.InMemoryActionStore();
-        const envSecret = typeof process !== 'undefined' && process.env ? process.env.ACTION_POLICY_SECRET : undefined;
-        const providedSecret = options.secretKey || envSecret;
-        if (!providedSecret && typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') {
-            throw new Error('FATAL: ACTION_POLICY_SECRET is required in production environment');
-        }
-        this.secretKey = providedSecret ?? 'siduri_y_action_policy_secret';
+        this.secretKey = (0, capability_1.getOrGenerateLocalActionPolicySecret)(options.secretKey);
     }
     registerToolDefinition(tool) {
         const key = tool.providerId ? `${tool.providerId}/${tool.name}` : tool.name;
@@ -75,9 +70,9 @@ class ActionPolicyEngine {
         }
         // Role check if tool restricts roles (supports administrator/owner role parity)
         if (toolDef.allowedRoles && toolDef.allowedRoles.length > 0) {
-            const actorRole = effectiveContext.actor.authorizationRole;
+            const actorRole = effectiveContext.actor.authorizationRole || effectiveContext.actor.role || 'owner';
             const normalizedActorRoles = new Set([actorRole.toLowerCase()]);
-            if (actorRole === 'administrator' || actorRole === 'owner') {
+            if (actorRole.toLowerCase() === 'administrator' || actorRole.toLowerCase() === 'owner') {
                 normalizedActorRoles.add('administrator');
                 normalizedActorRoles.add('owner');
                 normalizedActorRoles.add('admin');
@@ -98,7 +93,7 @@ class ActionPolicyEngine {
         }
         // Channel check if tool restricts channels
         if (toolDef.allowedChannels && toolDef.allowedChannels.length > 0) {
-            const channel = effectiveContext.conversation.channel;
+            const channel = effectiveContext.conversation.channel || 'direct';
             if (!toolDef.allowedChannels.includes(channel)) {
                 const decision = {
                     allowed: false,

package/dist/architecture-boundary.test.js

@@ -50,6 +50,7 @@ describe('Architecture: Core & Organ Package Boundaries (Phase 2)', () => {
         { dir: 'body', name: '@siduri-x/body', organType: 'body', configKey: 'body' },
         { dir: 'voice', name: '@siduri-x/voice', organType: 'voice', configKey: 'voice' },
         { dir: 'observation', name: '@siduri-x/observation', organType: 'observation', configKey: 'observation' },
+        { dir: 'mouth', name: '@siduri-x/mouth', organType: 'mouth', configKey: 'mouth' },
     ];
     it('package.json has zero dependencies on @siduri-x organ packages', () => {
         const pkg = JSON.parse(fs.readFileSync(corePackageJsonPath, 'utf8'));

package/dist/capability.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Resolves the action policy secret key.
+ * In production (NODE_ENV=production), ACTION_POLICY_SECRET is required.
+ * In local/development environments, if no secret is provided via environment
+ * or options, generates an ephemeral cryptographically strong secret per-process,
+ * avoiding shared hardcoded fallback secrets.
+ */
+export declare function getOrGenerateLocalActionPolicySecret(provided?: string): string;
 import { ActionRiskLevel, ActionLifecycleState, ActionAuditEvent, ActionPolicyDecision } from './action';
 export interface AuthorizationCapability {
     executionId: string;

package/dist/capability.js

@@ -3,12 +3,37 @@
 // using node's built-in crypto module dynamically or via require for universal CommonJS compatibility
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemoryActionStore = void 0;
+exports.getOrGenerateLocalActionPolicySecret = getOrGenerateLocalActionPolicySecret;
 exports.canonicalizeJson = canonicalizeJson;
 exports.computeParametersHash = computeParametersHash;
 exports.signCapabilityPayload = signCapabilityPayload;
 exports.verifyCapabilitySignature = verifyCapabilitySignature;
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const crypto = require('crypto');
+let cachedEphemeralSecret = null;
+/**
+ * Resolves the action policy secret key.
+ * In production (NODE_ENV=production), ACTION_POLICY_SECRET is required.
+ * In local/development environments, if no secret is provided via environment
+ * or options, generates an ephemeral cryptographically strong secret per-process,
+ * avoiding shared hardcoded fallback secrets.
+ */
+function getOrGenerateLocalActionPolicySecret(provided) {
+    if (provided) {
+        return provided;
+    }
+    const envSecret = typeof process !== 'undefined' && process.env ? process.env.ACTION_POLICY_SECRET : undefined;
+    if (envSecret) {
+        return envSecret;
+    }
+    if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') {
+        throw new Error('FATAL: ACTION_POLICY_SECRET is required in production environment');
+    }
+    if (!cachedEphemeralSecret) {
+        cachedEphemeralSecret = crypto.randomBytes(32).toString('hex');
+    }
+    return cachedEphemeralSecret;
+}
 class InMemoryActionStore {
     executions = new Map();
     approvals = new Map();
@@ -100,17 +125,19 @@ function computeParametersHash(params) {
     const canonical = canonicalizeJson(params || {});
     return crypto.createHash('sha256').update(canonical, 'utf8').digest('hex');
 }
-function signCapabilityPayload(payload, secretKey = 'siduri_y_action_policy_secret') {
+function signCapabilityPayload(payload, secretKey) {
+    const resolvedKey = getOrGenerateLocalActionPolicySecret(secretKey);
     const canonicalStr = canonicalizeJson(payload);
-    return crypto.createHmac('sha256', secretKey).update(canonicalStr, 'utf8').digest('hex');
+    return crypto.createHmac('sha256', resolvedKey).update(canonicalStr, 'utf8').digest('hex');
 }
-function verifyCapabilitySignature(capability, secretKey = 'siduri_y_action_policy_secret') {
+function verifyCapabilitySignature(capability, secretKey) {
     if (!capability || capability.allowed !== true || typeof capability.signature !== 'string') {
         return false;
     }
+    const resolvedKey = getOrGenerateLocalActionPolicySecret(secretKey);
     const { signature, allowed, ...rest } = capability;
     const canonicalStr = canonicalizeJson(rest);
-    const expectedSigHex = crypto.createHmac('sha256', secretKey).update(canonicalStr, 'utf8').digest('hex');
+    const expectedSigHex = crypto.createHmac('sha256', resolvedKey).update(canonicalStr, 'utf8').digest('hex');
     // Constant-time comparison to prevent timing attacks
     try {
         const sigBuffer = globalThis.Buffer

package/dist/chat-contract.d.ts

@@ -3,13 +3,16 @@ import { Message, Claim } from './index';
 import { ActionExecutionResult } from './action';
 import { ResponseCitation } from './evidence';
 import { SiduriRuntime } from './runtime';
+import { MouthMedium, FormattedMouthOutput } from './mouth-types';
 export interface ChatRequest {
     id?: string;
     companionId?: string;
     message: string;
-    role?: 'OWNER' | 'VIEWER' | 'OPERATOR';
+    role?: 'OWNER' | 'VIEWER' | 'OPERATOR' | string;
     context?: RequestContext;
     history?: Message[];
+    medium?: MouthMedium;
+    signal?: AbortSignal;
     [key: string]: any;
 }
 export interface ChatResponseMetadataEvent {
@@ -65,6 +68,7 @@ export interface ChatResponse {
     correlation_id?: string;
     response: ChatResponsePlan;
     metadata?: ChatResponseMetadata;
+    delivery?: FormattedMouthOutput;
     reply?: string;
     text?: string;
     audioUrl?: string;

package/dist/chat-contract.js

@@ -9,40 +9,42 @@ async function dispatchCompanionChat(runtime, payload) {
     const userMessage = payload.message || payload.text || '';
     const history = Array.isArray(payload.history) ? payload.history : [];
     let roleOrContext;
-    if (payload.role) {
-        roleOrContext = payload.role;
+    if (payload.context) {
+        roleOrContext = payload.context;
     }
-    else if (payload.context) {
-        // Map authorization role to legacy memory scope for backwards-compatible runtime calls
-        const authRole = payload.context.actor?.authorizationRole;
-        roleOrContext =
-            authRole === 'administrator'
-                ? 'OWNER'
-                : authRole === 'operator'
-                    ? 'OPERATOR'
-                    : (authRole === 'viewer' ? 'VIEWER' : 'OWNER');
+    else if (payload.role) {
+        roleOrContext = payload.role;
     }
     else {
         roleOrContext = 'OWNER';
     }
-    const runtimeResult = await runtime.handleUserMessage(userMessage, roleOrContext, history);
+    const runtimeResult = (payload.medium || payload.signal)
+        ? await runtime.handleUserMessage(userMessage, roleOrContext, history, payload.medium, payload.signal)
+        : await runtime.handleUserMessage(userMessage, roleOrContext, history);
+    const delivery = runtimeResult?.delivery;
     // Normalize response plan
-    const speech = runtimeResult?.response?.subtitle_ja || runtimeResult?.response?.subtitle_en || '';
-    const audioUrl = runtimeResult?.response?.audio_url;
-    // Extract avatar expression if any event was generated
-    let expression = 'neutral';
-    const events = runtimeResult?.metadata?.events || [];
-    const avatarEvent = events.find((e) => e.kind === 'avatar' || e.kind === 'body');
-    if (avatarEvent && avatarEvent.expression) {
-        expression = avatarEvent.expression;
+    const speech = delivery?.displayText ||
+        delivery?.text ||
+        runtimeResult?.response?.subtitle_ja ||
+        runtimeResult?.response?.subtitle_en ||
+        '';
+    const audioUrl = delivery?.audioUrl || runtimeResult?.response?.audio_url;
+    // Extract avatar expression if any event was generated or provided by Mouth delivery
+    let expression = delivery?.expression || 'neutral';
+    if (expression === 'neutral') {
+        const events = runtimeResult?.metadata?.events || [];
+        const avatarEvent = events.find((e) => e.kind === 'avatar' || e.kind === 'body');
+        if (avatarEvent && avatarEvent.expression) {
+            expression = avatarEvent.expression;
+        }
     }
     // Ensure both spoken_ja and subtitle_en are accessible alongside speech_id and evidence_ids
     const responsePlan = {
         speech_id: runtimeResult?.response?.speech_id,
         audio_url: audioUrl,
-        subtitle_ja: runtimeResult?.response?.subtitle_ja ?? speech,
-        subtitle_en: runtimeResult?.response?.subtitle_en ?? speech,
-        spoken_ja: runtimeResult?.response?.spoken_ja ?? runtimeResult?.response?.subtitle_ja ?? speech,
+        subtitle_ja: delivery?.subtitles?.ja ?? runtimeResult?.response?.subtitle_ja ?? speech,
+        subtitle_en: delivery?.subtitles?.en ?? runtimeResult?.response?.subtitle_en ?? speech,
+        spoken_ja: delivery?.subtitles?.spoken ?? runtimeResult?.response?.spoken_ja ?? runtimeResult?.response?.subtitle_ja ?? speech,
         evidence_ids: runtimeResult?.metadata?.evidence_ids ?? runtimeResult?.response?.evidence_ids ?? [],
     };
     const metadata = {
@@ -55,6 +57,7 @@ async function dispatchCompanionChat(runtime, payload) {
         response_id: runtimeResult?.response_id,
         correlation_id: runtimeResult?.correlation_id,
         response: responsePlan,
+        delivery,
         metadata,
         // Convenience fields for legacy/simple consumers
         reply: speech,

package/dist/cognition-planner.d.ts

@@ -0,0 +1,15 @@
+import { BrainOrgan, Message, ResponsePlan, MemoryScope } from './index';
+export interface CognitionPlanningParams {
+    companionName: string;
+    brain?: BrainOrgan;
+    systemPrompt: string;
+    contextPrompt: string;
+    recentMessages: Message[];
+    recipient?: MemoryScope;
+    perceivedText: string;
+}
+/**
+ * Invokes BrainOrgan to generate a structured ResponsePlan, or provides
+ * a graceful baseline response if Brain is absent or in headless passive mode.
+ */
+export declare function generateCognitionPlan(params: CognitionPlanningParams): Promise<ResponsePlan>;

package/dist/cognition-planner.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCognitionPlan = generateCognitionPlan;
+/**
+ * Invokes BrainOrgan to generate a structured ResponsePlan, or provides
+ * a graceful baseline response if Brain is absent or in headless passive mode.
+ */
+async function generateCognitionPlan(params) {
+    const { companionName, brain, systemPrompt, contextPrompt, recentMessages, recipient, perceivedText, } = params;
+    if (brain && typeof brain.generatePlan === 'function') {
+        return brain.generatePlan({
+            systemPrompt,
+            contextPrompt,
+            recentMessages,
+            recipient,
+        });
+    }
+    // Graceful baseline response when Brain is not configured or in headless passive mode
+    return {
+        speech: `[Siduri ${companionName}] Acknowledged: ${perceivedText}`,
+        language: 'en',
+    };
+}

package/dist/context-retriever.d.ts

@@ -0,0 +1,24 @@
+import { KnowledgeOrgan, MemoryOrgan, KnowledgeItem, Claim, BehaviorDirective, EvidenceRecord, ResponseCitation, RequestContext } from './index';
+export interface ContextRetrievalParams {
+    companionId: string;
+    perceivedText: string;
+    requestContext: RequestContext;
+    role: 'OWNER' | 'VIEWER' | 'OPERATOR';
+    isContextObject: boolean;
+    shouldQueryKnowledge: boolean;
+    knowledge?: KnowledgeOrgan;
+    memory?: MemoryOrgan;
+}
+export interface RetrievedContext {
+    knowledgeData: KnowledgeItem[];
+    memoryData: Claim[];
+    activeDirectives: BehaviorDirective[];
+    subsystemDiagnostics: Record<string, string>;
+    collectedEvidence: EvidenceRecord[];
+    citations: ResponseCitation[];
+}
+/**
+ * Concurrently queries Knowledge and Memory organs with graceful degradation,
+ * collecting diagnostics and synthesizing evidence records and citations.
+ */
+export declare function retrieveRuntimeContext(params: ContextRetrievalParams): Promise<RetrievedContext>;

package/dist/context-retriever.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveRuntimeContext = retrieveRuntimeContext;
+/**
+ * Concurrently queries Knowledge and Memory organs with graceful degradation,
+ * collecting diagnostics and synthesizing evidence records and citations.
+ */
+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;
+    const subsystemDiagnostics = {};
+    const [knowledgeData, memoryData, activeDirectives] = await Promise.all([
+        knowledge && shouldQueryKnowledge && typeof knowledge.search === 'function'
+            ? knowledge.search(perceivedText).catch((e) => {
+                console.error('[SiduriRuntime] Knowledge search failed:', e.message);
+                subsystemDiagnostics['knowledge'] = `UNAVAILABLE: ${e.message}`;
+                return [];
+            })
+            : Promise.resolve([]),
+        memory && typeof memory.searchClaims === 'function'
+            ? memory.searchClaims(perceivedText, queryOptions, 5).catch((e) => {
+                console.error('[SiduriRuntime] Memory search failed:', e.message);
+                subsystemDiagnostics['memory_claims'] = `UNAVAILABLE: ${e.message}`;
+                return [];
+            })
+            : Promise.resolve([]),
+        memory && typeof memory.getDirectives === 'function'
+            ? memory.getDirectives().catch((e) => {
+                console.error('[SiduriRuntime] Memory directives failed:', e.message);
+                subsystemDiagnostics['memory_directives'] = `UNAVAILABLE: ${e.message}`;
+                return [];
+            })
+            : Promise.resolve([]),
+    ]);
+    // Build evidence records from retrieved knowledge context
+    const collectedEvidence = [];
+    const citations = [];
+    if (knowledgeData.length > 0) {
+        for (const k of knowledgeData) {
+            if (k.evidenceRecord) {
+                const nativeRecord = {
+                    ...k.evidenceRecord,
+                };
+                collectedEvidence.push(nativeRecord);
+                citations.push({
+                    sourceId: nativeRecord.sourceId,
+                    revision: nativeRecord.revision,
+                    documentId: nativeRecord.documentId || k.citations?.[0]?.documentId,
+                    chunkId: nativeRecord.chunkId || k.citations?.[0]?.chunkId,
+                    locator: nativeRecord.locator || k.citations?.[0]?.locator,
+                });
+            }
+            else {
+                // Synthesize fallback evidence record with provenance
+                const evId = `ev-know-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+                const sourceId = k.provenance || 'configured-knowledge';
+                collectedEvidence.push({
+                    evidenceId: evId,
+                    sourceId,
+                    revision: k.revision,
+                    origin: 'knowledge',
+                    trust: 'configured',
+                    sensitivity: 'public',
+                    companionId,
+                    correlationId: requestContext.conversation.correlationId,
+                    createdAt: new Date().toISOString(),
+                });
+                citations.push({
+                    sourceId,
+                    revision: k.revision,
+                    documentId: k.citations?.[0]?.documentId,
+                    chunkId: k.citations?.[0]?.chunkId,
+                    locator: k.citations?.[0]?.locator,
+                });
+            }
+        }
+    }
+    return {
+        knowledgeData,
+        memoryData,
+        activeDirectives,
+        subsystemDiagnostics,
+        collectedEvidence,
+        citations,
+    };
+}

package/dist/context.d.ts

@@ -1,17 +1,16 @@
-export type AuthorizationRole = 'viewer' | 'operator' | 'administrator';
-export type Channel = 'public' | 'direct' | 'private' | 'operator';
 export interface ActorContext {
     actorId: string;
     sessionId: string;
-    authorizationRole: AuthorizationRole;
-    capabilities: string[];
-    authenticated: boolean;
+    authenticated?: boolean;
+    capabilities?: string[];
+    [key: string]: unknown;
 }
 export interface ConversationContext {
-    channel: Channel;
-    audienceId: string;
-    isLive?: boolean;
     correlationId: string;
+    sessionId?: string;
+    channel?: string;
+    audienceId?: string;
+    [key: string]: unknown;
 }
 export type SubjectKind = 'actor' | 'companion' | 'configured';
 export interface SubjectRef {
@@ -23,16 +22,17 @@ export interface RequestContext {
     companionId: string;
     actor: ActorContext;
     conversation: ConversationContext;
+    source?: 'local' | 'external' | string;
     subject?: SubjectRef;
+    metadata?: Record<string, unknown>;
 }
-export type DiagnosticCode = 'audience_defaulted_by_public_policy' | 'legacy_role_mapped_to_authorization' | 'anonymous_session_generated' | 'companion_default_mapped_for_bootstrap' | 'actor_scoped_subject_mapped' | 'legacy_primary_user_quarantined';
-export type ContextErrorCode = 'MISSING_CONTEXT' | 'INVALID_CONTEXT' | 'AMBIGUOUS_CONTEXT' | 'FORBIDDEN_CONTEXT' | 'LEGACY_PERSONAL_AUDIENCE' | 'UNAUTHORIZED_CHANNEL_OR_CAPABILITY';
+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 interface ContextError {
     code: ContextErrorCode;
     message?: string;
     fields?: string[];
     field?: string;
-    conflicts?: string[];
     correlationId?: string;
 }
 export interface RequestContextValidationResult {
@@ -41,7 +41,5 @@ export interface RequestContextValidationResult {
     diagnostics?: DiagnosticCode[];
     error?: ContextError;
 }
-export declare function isValidAuthorizationRole(role: unknown): role is AuthorizationRole;
-export declare function isValidChannel(channel: unknown): channel is Channel;
 export declare function isValidSubjectKind(kind: unknown): kind is SubjectKind;
 export declare function validateRequestContext(context: unknown): RequestContextValidationResult;

package/dist/context.js

@@ -1,15 +1,10 @@
 "use strict";
+// Single-owner, single-machine context model
+// Security perimeter is the local machine boundary (external vs internal).
+// No internal audience, viewer, or owner role hierarchies.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidAuthorizationRole = isValidAuthorizationRole;
-exports.isValidChannel = isValidChannel;
 exports.isValidSubjectKind = isValidSubjectKind;
 exports.validateRequestContext = validateRequestContext;
-function isValidAuthorizationRole(role) {
-    return role === 'viewer' || role === 'operator' || role === 'administrator';
-}
-function isValidChannel(channel) {
-    return channel === 'public' || channel === 'direct' || channel === 'private' || channel === 'operator';
-}
 function isValidSubjectKind(kind) {
     return kind === 'actor' || kind === 'companion' || kind === 'configured';
 }
@@ -38,26 +33,11 @@ function validateRequestContext(context) {
         if (!ctx.actor.sessionId || typeof ctx.actor.sessionId !== 'string' || ctx.actor.sessionId.trim() === '') {
             missingFields.push('actor.sessionId');
         }
-        if (!isValidAuthorizationRole(ctx.actor.authorizationRole)) {
-            missingFields.push('actor.authorizationRole');
-        }
-        if (!Array.isArray(ctx.actor.capabilities)) {
-            missingFields.push('actor.capabilities');
-        }
-        if (typeof ctx.actor.authenticated !== 'boolean') {
-            missingFields.push('actor.authenticated');
-        }
     }
     if (!ctx.conversation || typeof ctx.conversation !== 'object') {
         missingFields.push('conversation');
     }
     else {
-        if (!isValidChannel(ctx.conversation.channel)) {
-            missingFields.push('conversation.channel');
-        }
-        if (!ctx.conversation.audienceId || typeof ctx.conversation.audienceId !== 'string' || ctx.conversation.audienceId.trim() === '') {
-            missingFields.push('conversation.audienceId');
-        }
         if (!ctx.conversation.correlationId || typeof ctx.conversation.correlationId !== 'string' || ctx.conversation.correlationId.trim() === '') {
             missingFields.push('conversation.correlationId');
         }

package/dist/context.test.js

@@ -1,28 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const context_1 = require("./context");
-describe('Core Context Contract (P1)', () => {
+describe('Core Context Contract (Single-Owner Single-Machine)', () => {
     const validContext = {
         companionId: 'companion-a',
         actor: {
-            actorId: 'actor-a',
+            actorId: 'local-user',
             sessionId: 'session-a',
-            authorizationRole: 'viewer',
-            capabilities: ['chat:public'],
-            authenticated: false,
+            authenticated: true,
+            capabilities: ['chat:interact'],
         },
         conversation: {
-            channel: 'public',
-            audienceId: 'audience-public',
             correlationId: 'corr-a',
         },
         subject: {
-            subjectId: 'actor:actor-a',
+            subjectId: 'actor:local-user',
             kind: 'actor',
-            ownerActorId: 'actor-a',
+            ownerActorId: 'local-user',
         },
     };
-    test('validates a correct neutral RequestContext', () => {
+    test('validates a correct RequestContext', () => {
         const result = (0, context_1.validateRequestContext)(validContext);
         expect(result.accepted).toBe(true);
         expect(result.context).toEqual(validContext);
@@ -46,36 +43,6 @@ describe('Core Context Contract (P1)', () => {
         expect(result.error?.code).toBe('MISSING_CONTEXT');
         expect(result.error?.fields).toEqual(expect.arrayContaining(['companionId', 'actor', 'conversation']));
     });
-    test('validates authorization role constraints', () => {
-        expect((0, context_1.isValidAuthorizationRole)('viewer')).toBe(true);
-        expect((0, context_1.isValidAuthorizationRole)('operator')).toBe(true);
-        expect((0, context_1.isValidAuthorizationRole)('administrator')).toBe(true);
-        expect((0, context_1.isValidAuthorizationRole)('owner')).toBe(false);
-        expect((0, context_1.isValidAuthorizationRole)('user')).toBe(false);
-        expect((0, context_1.isValidAuthorizationRole)('MASTER')).toBe(false);
-        const invalidRoleCtx = {
-            ...validContext,
-            actor: { ...validContext.actor, authorizationRole: 'invalid_role' },
-        };
-        const result = (0, context_1.validateRequestContext)(invalidRoleCtx);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.fields).toContain('actor.authorizationRole');
-    });
-    test('validates channel constraints', () => {
-        expect((0, context_1.isValidChannel)('public')).toBe(true);
-        expect((0, context_1.isValidChannel)('direct')).toBe(true);
-        expect((0, context_1.isValidChannel)('private')).toBe(true);
-        expect((0, context_1.isValidChannel)('operator')).toBe(true);
-        expect((0, context_1.isValidChannel)('chat')).toBe(false);
-        expect((0, context_1.isValidChannel)('MASTER_PRIVATE')).toBe(false);
-        const invalidChannelCtx = {
-            ...validContext,
-            conversation: { ...validContext.conversation, channel: 'invalid_channel' },
-        };
-        const result = (0, context_1.validateRequestContext)(invalidChannelCtx);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.fields).toContain('conversation.channel');
-    });
     test('validates subject kinds and constraints', () => {
         expect((0, context_1.isValidSubjectKind)('actor')).toBe(true);
         expect((0, context_1.isValidSubjectKind)('companion')).toBe(true);