@siduri-x/core 1.0.5 → 1.0.7

package/dist/evidence.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const evidence_1 = require("./evidence");
+describe('T4 Evidence & Disclosure Core Contract', () => {
+    const baseRecord = {
+        evidenceId: 'ev-1',
+        sourceId: 'src-1',
+        origin: 'knowledge',
+        trust: 'configured',
+        sensitivity: 'public',
+        allowedAudiences: ['audience-public'],
+        companionId: 'companion-a',
+        correlationId: 'corr-1',
+        createdAt: new Date(Date.now() - 5000).toISOString(),
+    };
+    test('companion isolation excludes foreign companion evidence', () => {
+        const records = [
+            { ...baseRecord, evidenceId: 'ev-mine', companionId: 'companion-a' },
+            { ...baseRecord, evidenceId: 'ev-foreign', companionId: 'companion-b' },
+        ];
+        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']);
+        expect(excluded).toEqual([
+            expect.objectContaining({
+                record: expect.objectContaining({ evidenceId: 'ev-foreign' }),
+                reason: 'companion_isolation_mismatch',
+            }),
+        ]);
+    });
+    test('expired evidence is excluded', () => {
+        const records = [
+            { ...baseRecord, evidenceId: 'ev-valid', expiresAt: new Date(Date.now() + 60000).toISOString() },
+            { ...baseRecord, evidenceId: 'ev-expired', expiresAt: new Date(Date.now() - 1000).toISOString() },
+        ];
+        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']);
+        expect(excluded).toEqual([
+            expect.objectContaining({
+                record: expect.objectContaining({ evidenceId: 'ev-expired' }),
+                reason: 'evidence_expired',
+            }),
+        ]);
+    });
+    test('audience intersection excludes non-matching audiences', () => {
+        const records = [
+            { ...baseRecord, evidenceId: 'ev-public', allowedAudiences: ['audience-public'] },
+            { ...baseRecord, evidenceId: 'ev-direct-only', allowedAudiences: ['audience-direct-a'] },
+        ];
+        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']);
+    });
+    test('direct channel permits private sensitivity but excludes restricted', () => {
+        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'] },
+        ];
+        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']);
+    });
+});

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

@@ -0,0 +1,57 @@
+import { ResponseCitation } from './evidence';
+export type ExperienceEventKind = 'voice' | 'caption' | 'avatar' | 'platform_action';
+export type ExperienceEventLifecycle = 'STARTED' | 'PROGRESS' | 'COMPLETED' | 'FAILED';
+export interface ExperienceEvent {
+    eventId: string;
+    companionId: string;
+    responseId: string;
+    correlationId: string;
+    channel?: string;
+    audienceId?: string;
+    approval: 'APPROVED';
+    kind: ExperienceEventKind;
+    lifecycle: ExperienceEventLifecycle;
+    evidenceIds: string[];
+    citations?: ResponseCitation[];
+    text?: string;
+    language?: string;
+    action?: string;
+    expression?: string;
+    createdAt: string;
+    expiresAt?: string;
+    [key: string]: unknown;
+}
+export interface ExperienceAdapterResult {
+    accepted: boolean;
+    eventId: string;
+    lifecycle: ExperienceEventLifecycle;
+    error?: string;
+    reason?: string;
+    audioBuffer?: Uint8Array;
+    metadata?: Record<string, unknown>;
+}
+export interface ExperienceAdapter {
+    readonly kind: ExperienceEventKind;
+    handleEvent(event: ExperienceEvent): Promise<ExperienceAdapterResult>;
+}
+export interface CreateExperienceEventsOptions {
+    responseId: string;
+    companionId: string;
+    correlationId: string;
+    channel?: string;
+    audienceId?: string;
+    speech: string;
+    language?: string;
+    evidenceIds?: string[];
+    citations?: ResponseCitation[];
+    expression?: string;
+    action?: string;
+    expiresAt?: string;
+    now?: string | Date;
+    [key: string]: unknown;
+}
+export declare function createExperienceEvents(options: CreateExperienceEventsOptions): ExperienceEvent[];
+export declare function validateExperienceEvent(event: unknown): {
+    valid: boolean;
+    error?: string;
+};

package/dist/experience.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExperienceEvents = createExperienceEvents;
+exports.validateExperienceEvent = validateExperienceEvent;
+function generateEventId(kind) {
+    return `evt-${kind}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function createExperienceEvents(options) {
+    const nowStr = options.now
+        ? new Date(options.now).toISOString()
+        : new Date().toISOString();
+    const events = [];
+    // 1. Voice event
+    events.push({
+        eventId: generateEventId('voice'),
+        companionId: options.companionId,
+        responseId: options.responseId,
+        correlationId: options.correlationId,
+        channel: options.channel,
+        audienceId: options.audienceId,
+        approval: 'APPROVED',
+        kind: 'voice',
+        lifecycle: 'STARTED',
+        evidenceIds: options.evidenceIds ?? [],
+        citations: options.citations,
+        text: options.speech,
+        language: options.language || 'ja',
+        createdAt: nowStr,
+        expiresAt: options.expiresAt,
+    });
+    // 2. Avatar/Body event
+    events.push({
+        eventId: generateEventId('avatar'),
+        companionId: options.companionId,
+        responseId: options.responseId,
+        correlationId: options.correlationId,
+        channel: options.channel,
+        audienceId: options.audienceId,
+        approval: 'APPROVED',
+        kind: 'avatar',
+        lifecycle: 'STARTED',
+        evidenceIds: options.evidenceIds ?? [],
+        text: options.speech,
+        language: options.language || 'ja',
+        expression: options.expression || 'neutral',
+        action: options.action || 'talk',
+        createdAt: nowStr,
+        expiresAt: options.expiresAt,
+    });
+    return events;
+}
+function validateExperienceEvent(event) {
+    if (!event || typeof event !== 'object') {
+        return { valid: false, error: 'Event must be an object' };
+    }
+    const e = event;
+    if (!e.eventId || typeof e.eventId !== 'string')
+        return { valid: false, error: 'Missing or invalid eventId' };
+    if (!e.companionId || typeof e.companionId !== 'string')
+        return { valid: false, error: 'Missing or invalid companionId' };
+    if (!e.responseId || typeof e.responseId !== 'string')
+        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)) {
+        return { valid: false, error: `Invalid kind: ${e.kind}` };
+    }
+    if (!['STARTED', 'PROGRESS', 'COMPLETED', 'FAILED'].includes(e.lifecycle)) {
+        return { valid: false, error: `Invalid lifecycle: ${e.lifecycle}` };
+    }
+    if (!Array.isArray(e.evidenceIds))
+        return { valid: false, error: 'Missing or invalid evidenceIds array' };
+    return { valid: true };
+}

package/dist/experience.test.d.ts

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

package/dist/experience.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const experience_1 = require("./experience");
+describe('T5 Experience Event Contract Suite', () => {
+    const baseEventOptions = {
+        responseId: 'resp-123',
+        companionId: 'companion-a',
+        correlationId: 'corr-123',
+        channel: 'public',
+        audienceId: 'audience-public',
+        speech: 'Hello world',
+        language: 'en',
+        evidenceIds: ['ev-1'],
+        expression: 'happy',
+        action: 'wave',
+    };
+    test('creates structured voice and avatar experience events from approved response options', () => {
+        const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
+        expect(events.length).toBe(2);
+        const voiceEvent = events.find((e) => e.kind === 'voice');
+        expect(voiceEvent).toBeDefined();
+        expect(voiceEvent?.approval).toBe('APPROVED');
+        expect(voiceEvent?.companionId).toBe('companion-a');
+        expect(voiceEvent?.correlationId).toBe('corr-123');
+        expect(voiceEvent?.text).toBe('Hello world');
+        expect(voiceEvent?.language).toBe('en');
+        expect(voiceEvent?.evidenceIds).toEqual(['ev-1']);
+        const avatarEvent = events.find((e) => e.kind === 'avatar');
+        expect(avatarEvent).toBeDefined();
+        expect(avatarEvent?.approval).toBe('APPROVED');
+        expect(avatarEvent?.expression).toBe('happy');
+        expect(avatarEvent?.action).toBe('wave');
+    });
+    test('validates experience event envelope correctly', () => {
+        const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
+        for (const e of events) {
+            const val = (0, experience_1.validateExperienceEvent)(e);
+            expect(val.valid).toBe(true);
+            expect(val.error).toBeUndefined();
+        }
+    });
+    test('rejects unapproved experience event', () => {
+        const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
+        const unapproved = { ...events[0], approval: 'STAGED' };
+        const val = (0, experience_1.validateExperienceEvent)(unapproved);
+        expect(val.valid).toBe(false);
+        expect(val.error).toContain('Event approval must be APPROVED');
+    });
+    test('rejects missing metadata (companionId, responseId, etc.)', () => {
+        const events = (0, experience_1.createExperienceEvents)(baseEventOptions);
+        const missingCompanion = { ...events[0], companionId: '' };
+        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

@@ -0,0 +1,46 @@
+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?: MemoryProposal[];
+    behaviorProposals?: BehaviorProposal[];
+    evidenceRecords?: EvidenceRecord[];
+    citations?: ResponseCitation[];
+    requiresApproval?: boolean;
+    ttlMs?: number;
+    now?: string | Date;
+}
+export interface ApproveResponseOptions {
+    responseId: string;
+    companionId: string;
+    correlationId: string;
+    audienceId?: string;
+}
+export interface RejectResponseOptions {
+    responseId: string;
+    companionId: string;
+    correlationId: string;
+    reason?: string;
+}
+export declare class ResponseGatingEngine {
+    private readonly stagedPlans;
+    private readonly consumedApprovals;
+    stageResponse(options: StageResponseOptions): StagedResponsePlan;
+    evaluateGate(staged: StagedResponsePlan, allEvidence?: EvidenceRecord[], now?: string | Date): ResponseGateEvaluation;
+    approveResponse(options: ApproveResponseOptions): {
+        success: boolean;
+        reason?: string;
+        plan?: StagedResponsePlan;
+    };
+    rejectResponse(options: RejectResponseOptions): {
+        success: boolean;
+        reason?: string;
+        plan?: StagedResponsePlan;
+    };
+    getStagedPlan(responseId: string): StagedResponsePlan | undefined;
+    findStagedPlanByCorrelation(companionId: string, correlationId: string): StagedResponsePlan | undefined;
+}

package/dist/gating.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseGatingEngine = void 0;
+const evidence_1 = require("./evidence");
+function generateId(prefix) {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+class ResponseGatingEngine {
+    stagedPlans = new Map();
+    consumedApprovals = new Set();
+    stageResponse(options) {
+        const { requestContext } = options;
+        const nowTime = options.now ? new Date(options.now).getTime() : Date.now();
+        const ttlMs = options.ttlMs ?? 60_000;
+        const expiresAt = new Date(nowTime + ttlMs).toISOString();
+        const evidenceRecords = options.evidenceRecords ?? [];
+        const evidenceIds = evidenceRecords.map((e) => e.evidenceId);
+        // Calculate aggregate confidence from evidence records if present
+        let confidenceSummary = 1.0;
+        let uncertaintySummary;
+        if (evidenceRecords.length > 0) {
+            const confidences = evidenceRecords
+                .map((e) => e.confidence)
+                .filter((c) => typeof c === 'number' && !isNaN(c));
+            if (confidences.length > 0) {
+                confidenceSummary = confidences.reduce((sum, c) => sum + c, 0) / confidences.length;
+            }
+            const uncertainties = evidenceRecords
+                .map((e) => e.uncertainty)
+                .filter((u) => typeof u === 'string' && u.trim() !== '');
+            if (uncertainties.length > 0) {
+                uncertaintySummary = uncertainties.join('; ');
+            }
+        }
+        const requiresApproval = options.requiresApproval !== undefined
+            ? options.requiresApproval
+            : 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,
+            speech: options.candidateSpeech,
+            language: options.candidateLanguage,
+            evidenceIds,
+            citations: options.citations ?? [],
+            confidenceSummary,
+            uncertaintySummary,
+            requiresApproval,
+            status: 'STAGED',
+            createdAt: new Date(nowTime).toISOString(),
+            expiresAt,
+            memoryProposals: options.memoryProposals,
+            behaviorProposals: options.behaviorProposals,
+            internalMonologue: options.internalMonologue,
+        };
+        this.stagedPlans.set(staged.responseId, staged);
+        return staged;
+    }
+    evaluateGate(staged, allEvidence = [], now = new Date()) {
+        const nowTime = new Date(now).getTime();
+        // 1. Check if empty speech
+        if (!staged.speech || staged.speech.trim() === '') {
+            return {
+                admissible: false,
+                disposition: 'REJECTED',
+                reasonCode: 'EMPTY_SPEECH',
+                stagedPlan: staged,
+                filteredEvidenceIds: [],
+                filteredCitations: [],
+                diagnostics: { detail: 'Speech content is empty' },
+            };
+        }
+        // 2. Check if expired
+        if (staged.expiresAt && new Date(staged.expiresAt).getTime() <= nowTime) {
+            staged.status = 'EXPIRED';
+            return {
+                admissible: false,
+                disposition: 'EXPIRED',
+                reasonCode: 'EVIDENCE_EXPIRED',
+                stagedPlan: staged,
+                filteredEvidenceIds: [],
+                filteredCitations: [],
+                diagnostics: { detail: 'Staged response plan expired' },
+            };
+        }
+        // 3. Disclosure filter on attached evidence
+        const attachedEvidence = allEvidence.filter((e) => staged.evidenceIds.includes(e.evidenceId));
+        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
+        const admittedEvidenceIds = admitted.map((e) => e.evidenceId);
+        const filteredCitations = staged.citations.filter((c) => admitted.some((e) => e.sourceId === c.sourceId || (e.documentId && e.documentId === c.documentId)));
+        // 4. Explicitly rejected or status check
+        if (staged.status === 'REJECTED') {
+            return {
+                admissible: false,
+                disposition: 'REJECTED',
+                reasonCode: 'EXPLICITLY_REJECTED',
+                stagedPlan: staged,
+                filteredEvidenceIds: admittedEvidenceIds,
+                filteredCitations,
+            };
+        }
+        // 5. Staged approval check
+        if (staged.requiresApproval && staged.status !== 'APPROVED') {
+            return {
+                admissible: false,
+                disposition: staged.status,
+                reasonCode: 'APPROVAL_REQUIRED',
+                stagedPlan: staged,
+                filteredEvidenceIds: admittedEvidenceIds,
+                filteredCitations,
+                diagnostics: {
+                    detail: 'Response plan requires approval before external emission',
+                    excludedEvidenceCount: String(excluded.length),
+                },
+            };
+        }
+        // 6. Direct approval / Admissible
+        return {
+            admissible: true,
+            disposition: staged.status === 'APPROVED' ? 'APPROVED' : 'APPROVED',
+            reasonCode: 'APPROVED_DIRECT',
+            stagedPlan: staged,
+            filteredEvidenceIds: admittedEvidenceIds,
+            filteredCitations,
+        };
+    }
+    approveResponse(options) {
+        const plan = this.stagedPlans.get(options.responseId);
+        if (!plan) {
+            return { success: false, reason: 'UNKNOWN_APPROVAL_ID' };
+        }
+        if (this.consumedApprovals.has(options.responseId) || plan.status === 'APPROVED') {
+            return { success: false, reason: 'APPROVAL_ALREADY_CONSUMED' };
+        }
+        if (plan.companionId !== options.companionId) {
+            return { success: false, reason: 'COMPANION_MISMATCH' };
+        }
+        if (plan.correlationId !== options.correlationId) {
+            return { success: false, reason: 'APPROVAL_ID_MISMATCH' };
+        }
+        if (plan.status === 'EXPIRED') {
+            return { success: false, reason: 'EVIDENCE_EXPIRED' };
+        }
+        if (plan.status === 'REJECTED') {
+            return { success: false, reason: 'EXPLICITLY_REJECTED' };
+        }
+        plan.status = 'APPROVED';
+        this.consumedApprovals.add(options.responseId);
+        return { success: true, plan };
+    }
+    rejectResponse(options) {
+        const plan = this.stagedPlans.get(options.responseId);
+        if (!plan) {
+            return { success: false, reason: 'UNKNOWN_APPROVAL_ID' };
+        }
+        if (plan.companionId !== options.companionId) {
+            return { success: false, reason: 'COMPANION_MISMATCH' };
+        }
+        if (plan.correlationId !== options.correlationId) {
+            return { success: false, reason: 'APPROVAL_ID_MISMATCH' };
+        }
+        plan.status = 'REJECTED';
+        return { success: true, plan };
+    }
+    getStagedPlan(responseId) {
+        return this.stagedPlans.get(responseId);
+    }
+    findStagedPlanByCorrelation(companionId, correlationId) {
+        for (const plan of this.stagedPlans.values()) {
+            if (plan.companionId === companionId && plan.correlationId === correlationId) {
+                return plan;
+            }
+        }
+        return undefined;
+    }
+}
+exports.ResponseGatingEngine = ResponseGatingEngine;

package/dist/gating.test.d.ts

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