@siduri-x/core 2.0.1 → 2.0.2

package/dist/runtime.js

@@ -1,431 +1,86 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SiduriRuntime = void 0;
-const index_1 = require("./index");
-const input_normalizer_1 = require("./input-normalizer");
-const intent_classifier_1 = require("./intent-classifier");
-const context_retriever_1 = require("./context-retriever");
-const prompt_compiler_1 = require("./prompt-compiler");
-const cognition_planner_1 = require("./cognition-planner");
-const memory_settler_1 = require("./memory-settler");
-const action_executor_1 = require("./action-executor");
-const experience_emitter_1 = require("./experience-emitter");
-const response_envelope_1 = require("./response-envelope");
-const session_history_1 = require("./session-history");
+const perception_pipeline_1 = require("./perception-pipeline");
+const container_1 = require("./container");
 /**
- * SiduriRuntime coordinates companion lifecycle, sensory perception,
- * context retrieval, cognition planning, safety gating, action execution,
- * and experience emission across decoupled organs.
+ * SiduriRuntime coordinates companion perception and cognition execution.
+ * Lifecycle management and organ storage are handled by CompanionContainer.
+ * The 12-stage perception cycle is executed via PerceptionPipeline.
  */
 class SiduriRuntime {
     id;
     config;
-    brain;
-    memory;
-    voice;
-    knowledge;
-    vision;
-    behavior;
-    body;
-    hands;
-    ear;
-    observation;
-    mouth;
-    self;
-    externalKnowledge;
-    gating;
-    actionPolicy;
-    dispatcher;
-    sessionHistory = new session_history_1.SessionHistoryManager();
-    // Backward-compatible getter/setter for conversation history
+    container;
+    pipeline;
+    constructor(id, config, containerOrOrgans = {}, pipeline) {
+        this.id = id;
+        this.config = config;
+        if (containerOrOrgans instanceof container_1.CompanionContainer) {
+            this.container = containerOrOrgans;
+        }
+        else {
+            this.container = new container_1.CompanionContainer(id, config, containerOrOrgans);
+        }
+        this.pipeline = pipeline || (0, perception_pipeline_1.createDefaultPerceptionPipeline)();
+    }
+    // Direct organ accessors through container
+    get organs() { return this.container.organs; }
+    get brain() { return this.container.brain; }
+    get memory() { return this.container.memory; }
+    get voice() { return this.container.voice; }
+    get knowledge() { return this.container.knowledge; }
+    get vision() { return this.container.vision; }
+    get behavior() { return this.container.behavior; }
+    get body() { return this.container.body; }
+    get hands() { return this.container.hands; }
+    get ear() { return this.container.ear; }
+    get observation() { return this.container.observation; }
+    set observation(org) { this.container.observation = org; }
+    get mouth() { return this.container.mouth; }
+    get self() { return this.container.self; }
+    get externalKnowledge() { return this.container.externalKnowledge; }
+    get gating() { return this.container.gating; }
+    get actionPolicy() { return this.container.actionPolicy; }
+    get dispatcher() { return this.container.dispatcher; }
+    get sessionHistory() { return this.container.sessionHistory; }
+    // Conversation history accessors
     get conversationHistory() {
-        return this.sessionHistory.getHistory('default');
+        return this.container.sessionHistory.getHistory('default');
     }
     set conversationHistory(messages) {
-        this.sessionHistory.setHistory('default', messages);
-    }
-    constructor(id, config, organs = {}) {
-        this.id = id;
-        this.config = config;
-        this.brain = organs.brain;
-        this.memory = organs.memory;
-        this.voice = organs.voice;
-        this.knowledge = organs.knowledge;
-        this.vision = organs.vision;
-        this.behavior = organs.behavior;
-        this.body = organs.body;
-        this.hands = organs.hands;
-        this.ear = organs.ear;
-        this.observation = organs.observation;
-        this.mouth = organs.mouth;
-        this.self = organs.self;
-        this.externalKnowledge = organs.externalKnowledge;
-        this.gating = new index_1.ResponseGatingEngine();
-        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);
-        }
-        if (this.body && typeof this.body.handleEvent === 'function') {
-            this.dispatcher.registerAdapter(this.body);
-        }
-        if (this.mouth && typeof this.mouth.handleEvent === 'function') {
-            this.dispatcher.registerAdapter(this.mouth);
-        }
+        this.container.sessionHistory.setHistory('default', messages);
     }
     async initialize() {
-        if (this.memory && typeof this.memory.initialize === 'function') {
-            await this.memory.initialize(this.id);
-        }
-        if (this.hands && typeof this.hands.listTools === 'function') {
-            const tools = await this.hands.listTools();
-            for (const tool of tools) {
-                this.actionPolicy.registerToolDefinition(tool);
-            }
-        }
+        return this.container.initialize();
     }
-    // --- Session History Accessors ---
     getSessionHistory(sessionKey) {
-        return this.sessionHistory.getHistory(sessionKey);
+        return this.container.sessionHistory.getHistory(sessionKey);
     }
     clearHistory(sessionKey) {
-        this.sessionHistory.clear(sessionKey);
-    }
-    // --- Observation & Vision Facades ---
-    async analyzeVision(imageUrl, prompt) {
-        if (!this.vision || typeof this.vision.analyze !== 'function') {
-            throw new Error('Vision organ is not configured on this runtime');
-        }
-        return this.vision.analyze(imageUrl, prompt);
-    }
-    async ingestObservation(frame, sourceName, providerId) {
-        if (!this.observation || typeof this.observation.ingest !== 'function') {
-            return { duplicate: false, reason: 'provider_failure' };
-        }
-        return this.observation.ingest(frame, sourceName, providerId);
-    }
-    getCurrentObservations(now) {
-        if (!this.observation || typeof this.observation.current !== 'function') {
-            return [];
-        }
-        return this.observation.current(now);
-    }
-    clearExpiredObservations(now) {
-        if (!this.observation || typeof this.observation.clearExpired !== 'function') {
-            return 0;
-        }
-        return this.observation.clearExpired(now);
+        this.container.sessionHistory.clear(sessionKey);
     }
-    // --- Memory Facades ---
-    async getClaims(limit) {
-        if (!this.memory || typeof this.memory.getClaims !== 'function') {
-            return [];
-        }
-        return this.memory.getClaims(limit);
-    }
-    async getPendingClaims(limit) {
-        if (!this.memory || typeof this.memory.getPendingClaims !== 'function') {
-            return [];
-        }
-        return this.memory.getPendingClaims(limit);
-    }
-    async getDirectives() {
-        if (!this.memory || typeof this.memory.getDirectives !== 'function') {
-            return [];
-        }
-        return this.memory.getDirectives();
-    }
-    async approveClaim(id) {
-        if (!this.memory || typeof this.memory.approveClaim !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return this.memory.approveClaim(id);
-    }
-    async rejectClaim(id) {
-        if (!this.memory || typeof this.memory.rejectClaim !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return this.memory.rejectClaim(id);
-    }
-    async updateClaim(id, updates) {
-        if (!this.memory || typeof this.memory.updateClaim !== 'function') {
-            throw new Error('Memory organ updateClaim not supported');
-        }
-        return this.memory.updateClaim(id, updates);
-    }
-    async approveDirective(id, companionId) {
-        if (!this.memory || typeof this.memory.approveDirective !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return companionId !== undefined
-            ? this.memory.approveDirective(id, companionId)
-            : this.memory.approveDirective(id);
-    }
-    async rejectDirective(id, companionId) {
-        if (!this.memory || typeof this.memory.rejectDirective !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return companionId !== undefined
-            ? this.memory.rejectDirective(id, companionId)
-            : this.memory.rejectDirective(id);
-    }
-    async revokeDirective(id, companionId) {
-        if (!this.memory || typeof this.memory.revokeDirective !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return companionId !== undefined
-            ? this.memory.revokeDirective(id, companionId)
-            : this.memory.revokeDirective(id);
-    }
-    async disableDirective(id, companionId) {
-        if (!this.memory || typeof this.memory.disableDirective !== 'function') {
-            throw new Error('Memory organ not configured');
-        }
-        return companionId !== undefined
-            ? this.memory.disableDirective(id, companionId)
-            : this.memory.disableDirective(id);
-    }
-    async resetMemory() {
-        if (!this.memory || typeof this.memory.resetMemory !== 'function') {
-            throw new Error('Memory organ does not support reset');
-        }
-        return this.memory.resetMemory();
-    }
-    // --- Response Gating Facades ---
-    stageResponse(options) {
-        return this.gating.stageResponse(options);
-    }
-    evaluateGate(plan, evidenceRecords) {
-        return this.gating.evaluateGate(plan, evidenceRecords);
-    }
-    approveResponse(options) {
-        return this.gating.approveResponse(options);
-    }
-    rejectResponse(options) {
-        return this.gating.rejectResponse(options);
-    }
-    async approveAction(options) {
-        return this.actionPolicy.approveAction(options);
-    }
-    getStagedPlan(responseId) {
-        return this.gating.getStagedPlan(responseId);
-    }
-    findStagedPlanByCorrelation(companionId, correlationId) {
-        return this.gating.findStagedPlanByCorrelation(companionId, correlationId);
-    }
-    // --- Universal Perception & Cognition Cycle ---
     /**
      * Processes an incoming perception (sensory audio, text, platform event, or observation alert)
-     * through the perception -> retrieval -> cognition -> gating -> action -> experience cycle.
+     * through the decoupled PerceptionPipeline.
      */
     async processPerception(perception) {
-        let rawText = perception.text || '';
-        // If audio buffer is provided and Ear supports transcription, transcribe it
-        if (!rawText && perception.audioBuffer && this.ear && typeof this.ear.transcribeAudio === 'function') {
-            rawText = await this.ear.transcribeAudio(perception.audioBuffer);
-        }
-        const roleOrContext = perception.context || perception.roleOrContext || 'OWNER';
-        const history = perception.history || [];
-        // 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.correlationId ||
-            'default';
-        const currentMessage = { role: 'user', content: input.perceivedText };
-        const boundedSessionHistory = [...input.boundedHistory, currentMessage].slice(-20);
-        this.sessionHistory.setHistory(sessionKey, boundedSessionHistory);
-        this.sessionHistory.setHistory('default', boundedSessionHistory);
-        // 2. Intent classification (delegating to Ear if available, else heuristics)
-        const intent = await (0, intent_classifier_1.classifyInputIntentAsync)(input.perceivedText, input.requestContext, this.ear?.classifyIntent
-            ? (t, c) => this.ear.classifyIntent(t, c)
-            : undefined);
-        // 3. Concurrent Knowledge & Memory retrieval with diagnostics & evidence handling
-        const contextRetrieval = await (0, context_retriever_1.retrieveRuntimeContext)({
+        const context = {
             companionId: this.id,
-            perceivedText: input.perceivedText,
-            requestContext: input.requestContext,
-            role: input.role,
-            isContextObject: input.isContextObject,
-            shouldQueryKnowledge: intent.shouldQueryKnowledge,
-            knowledge: this.knowledge,
-            memory: this.memory,
-            self: this.self,
-            externalKnowledge: this.externalKnowledge,
-        });
-        // 4. Neutral system prompt and contextual prompt compilation
-        const prompts = await (0, prompt_compiler_1.compilePrompts)({
-            companionName: this.config.name,
-            companionId: this.id,
-            role: input.role,
-            requestContext: input.requestContext,
-            behavior: this.behavior,
-            activeDirectives: contextRetrieval.activeDirectives,
-            subsystemDiagnostics: contextRetrieval.subsystemDiagnostics,
-            knowledgeData: contextRetrieval.knowledgeData,
-            memoryData: contextRetrieval.memoryData,
-            lifeContext: contextRetrieval.lifeContext,
-        });
-        // 5. Cognition planning via BrainOrgan
-        const plan = await (0, cognition_planner_1.generateCognitionPlan)({
             companionName: this.config.name,
-            brain: this.brain,
-            systemPrompt: prompts.systemPrompt,
-            contextPrompt: prompts.contextPrompt,
-            recentMessages: this.sessionHistory.getHistory(sessionKey).slice(-10),
-            recipient: input.role,
-            perceivedText: input.perceivedText,
-        });
-        // 6. Stage response and evaluate safety gating boundary
-        const stagedPlan = this.gating.stageResponse({
-            requestContext: input.requestContext,
-            candidateSpeech: plan.speech,
-            candidateLanguage: plan.language || 'ja',
-            internalMonologue: plan.internalMonologue,
-            memoryProposals: plan.memoryProposals,
-            behaviorProposals: plan.behaviorProposals,
-            evidenceRecords: contextRetrieval.collectedEvidence,
-            citations: contextRetrieval.citations,
-        });
-        const gateEval = this.gating.evaluateGate(stagedPlan, contextRetrieval.collectedEvidence);
-        if (!gateEval.admissible) {
-            return (0, response_envelope_1.createGateRejectionEnvelope)(stagedPlan, gateEval);
-        }
-        this.sessionHistory.append(sessionKey, { role: 'assistant', content: plan.speech });
-        this.sessionHistory.append('default', { role: 'assistant', content: plan.speech });
-        // 7. Settle memory proposals and persist source events
-        const memorySettlement = await (0, memory_settler_1.settleMemoryProposals)({
-            companionId: this.id,
-            perceivedText: input.perceivedText,
-            role: input.role,
-            requestContext: input.requestContext,
-            memory: this.memory,
-            explicitTeaching: intent.explicitTeaching,
-            plan,
-        });
-        // 8. Authorize and execute action intents under Primary Security Invariant
-        const actionResults = await (0, action_executor_1.executeActionIntents)({
-            actionIntents: plan.actionIntents,
-            requestContext: input.requestContext,
-            actionPolicy: this.actionPolicy,
-            hands: this.hands,
-        });
-        // 9. Dispatch ExperienceEvents to registered adapters
-        const experienceEmission = await (0, experience_emitter_1.emitExperienceEvents)({
-            companionId: this.id,
-            requestContext: input.requestContext,
-            stagedPlan,
-            gateEval,
-            speech: plan.speech,
-            language: plan.language || 'ja',
-            dispatcher: this.dispatcher,
-            voice: this.voice,
-            body: this.body,
-        });
-        // 10. Deliver utterance via Mouth organ (UI / Output Channel Decoupling)
-        let mouthDelivery;
-        if (this.mouth && typeof this.mouth.speak === 'function') {
-            try {
-                const avatarEvent = experienceEmission.experienceEvents.find((e) => e.kind === 'avatar');
-                mouthDelivery = await this.mouth.speak({
-                    utteranceId: stagedPlan.responseId,
-                    companionId: this.id,
-                    responseId: stagedPlan.responseId,
-                    correlationId: stagedPlan.correlationId,
-                    text: plan.speech,
-                    language: plan.language || 'ja',
-                    subtitleJa: plan.speech,
-                    subtitleEn: plan.speech,
-                    spokenJa: plan.speech,
-                    expression: avatarEvent?.expression,
-                    medium: perception.medium,
-                    signal: perception.signal,
-                    audioUrl: experienceEmission.speechId
-                        ? `/voice/stream?id=${experienceEmission.speechId}`
-                        : undefined,
-                    metadata: {
-                        subsystemDiagnostics: contextRetrieval.subsystemDiagnostics,
-                        internalMonologue: plan.internalMonologue,
-                    },
-                    citations: gateEval.filteredCitations,
-                    evidenceIds: gateEval.filteredEvidenceIds,
-                });
-            }
-            catch (e) {
-                console.error('[SiduriRuntime] Mouth delivery failed:', e?.message || e);
-            }
-        }
-        // 11. Assemble and return response envelope
-        return (0, response_envelope_1.assembleResponseEnvelope)({
-            stagedPlan,
-            speech: plan.speech,
-            language: plan.language,
-            speechId: experienceEmission.speechId,
-            createdMemoryProposals: memorySettlement.createdMemoryProposals,
-            memoryProposalReceipts: memorySettlement.memoryProposalReceipts,
-            actionResults,
-            filteredEvidenceIds: gateEval.filteredEvidenceIds,
-            filteredCitations: gateEval.filteredCitations,
-            subsystemDiagnostics: contextRetrieval.subsystemDiagnostics,
-            experienceEvents: experienceEmission.experienceEvents,
-            mouthDelivery,
-        });
-    }
-    // --- Mouth Facades ---
-    async speakMouth(utterance) {
-        if (!this.mouth || typeof this.mouth.speak !== 'function')
-            return undefined;
-        return this.mouth.speak(utterance);
-    }
-    formatMouth(utterance, medium) {
-        if (!this.mouth || typeof this.mouth.format !== 'function')
-            return undefined;
-        return this.mouth.format(utterance, medium);
-    }
-    registerMouthChannel(channel) {
-        if (this.mouth && typeof this.mouth.registerChannel === 'function') {
-            this.mouth.registerChannel(channel);
-        }
+            perception,
+            organs: this.container.organs,
+            gating: this.container.gating,
+            actionPolicy: this.container.actionPolicy,
+            dispatcher: this.container.dispatcher,
+            sessionHistory: this.container.sessionHistory,
+            rawText: perception.text || '',
+        };
+        return this.pipeline.execute(context);
     }
-    unregisterMouthChannel(channelId) {
-        if (this.mouth && typeof this.mouth.unregisterChannel === 'function') {
-            this.mouth.unregisterChannel(channelId);
-        }
-    }
-    async broadcastMouth(utterance) {
-        if (!this.mouth || typeof this.mouth.broadcast !== 'function')
-            return [];
-        return this.mouth.broadcast(utterance);
-    }
-    interruptMouth(reason) {
-        if (this.mouth && typeof this.mouth.interrupt === 'function') {
-            this.mouth.interrupt(reason);
-        }
-    }
-    streamMouth(utterance) {
-        if (!this.mouth || typeof this.mouth.stream !== 'function') {
-            return (async function* () {
-                yield {
-                    utteranceId: utterance.utteranceId,
-                    index: 0,
-                    deltaText: utterance.text,
-                    isComplete: true,
-                    medium: 'web',
-                };
-            })();
-        }
-        return this.mouth.stream(utterance);
-    }
-    // --- Backward-Compatible Chat Adapter ---
+    /**
+     * Primary entrypoint for text chat messages.
+     */
     async handleUserMessage(message, roleOrContext = 'OWNER', history = [], medium, signal) {
         return this.processPerception({
             source: 'text_chat',

package/dist/siduri-db.test.js

@@ -72,14 +72,15 @@ describe('SiduriDatabase', () => {
                 memDb.close();
             }).not.toThrow();
         });
-        it('initializes schema and WAL mode within the startup latency budget (<100ms in CI, typical <20ms locally)', () => {
+        it('initializes schema and WAL mode within the startup latency budget (<1000ms in CI, typical <20ms locally)', () => {
             const start = performance.now();
             const benchDb = new siduri_db_1.SiduriDatabase({ dbPath });
             const duration = performance.now() - start;
             benchDb.close();
             // In bare-metal local development, SQLite cold init is ~2-5ms.
-            // Under virtualized CI runners with concurrent Turbo tasks, allow a safe 100ms budget.
-            expect(duration).toBeLessThan(100);
+            // Under virtualized CI runners with concurrent Turbo tasks and shared I/O, allow up to 1000ms.
+            const budgetMs = process.env.CI ? 1000 : 250;
+            expect(duration).toBeLessThan(budgetMs);
         });
         it('stores and retrieves companion identity', () => {
             db = new siduri_db_1.SiduriDatabase({ dbPath });

package/dist/sqlite-action-store.d.ts

@@ -12,7 +12,7 @@ export declare class SqliteActionStore implements ActionStore {
     reserveExecution(record: PersistentExecutionRecord): Promise<boolean>;
     updateExecution(record: PersistentExecutionRecord): Promise<void>;
     getExecution(executionId: string): Promise<PersistentExecutionRecord | undefined>;
-    saveApproval(executionId: string, approverActorId: string, reason?: string, approverRole?: string): Promise<void>;
+    saveApproval(executionId: string, approverActorId: string, reason?: string, approverRole?: string, toolName?: string, parametersHash?: string, companionId?: string, actorId?: string): Promise<void>;
     isActionApproved(executionId: string): Promise<boolean>;
     getApproval(executionId: string): Promise<ActionApprovalRecord | undefined>;
     appendAudit(event: ActionAuditEvent): Promise<void>;

package/dist/sqlite-action-store.js

@@ -37,7 +37,11 @@ class SqliteActionStore {
         approver_actor_id TEXT NOT NULL,
         reason TEXT,
         approver_role TEXT,
-        approved_at TEXT NOT NULL
+        approved_at TEXT NOT NULL,
+        tool_name TEXT,
+        parameters_hash TEXT,
+        companion_id TEXT,
+        actor_id TEXT
       );
 
       CREATE TABLE IF NOT EXISTS action_audit_log (
@@ -69,6 +73,22 @@ class SqliteActionStore {
         catch {
             // Column already exists or table freshly created
         }
+        try {
+            this.db.exec('ALTER TABLE action_approvals ADD COLUMN tool_name TEXT;');
+        }
+        catch { }
+        try {
+            this.db.exec('ALTER TABLE action_approvals ADD COLUMN parameters_hash TEXT;');
+        }
+        catch { }
+        try {
+            this.db.exec('ALTER TABLE action_approvals ADD COLUMN companion_id TEXT;');
+        }
+        catch { }
+        try {
+            this.db.exec('ALTER TABLE action_approvals ADD COLUMN actor_id TEXT;');
+        }
+        catch { }
     }
     initLastAuditHash() {
         const row = this.db.prepare('SELECT event_hash FROM action_audit_log ORDER BY id DESC LIMIT 1').get();
@@ -134,17 +154,24 @@ class SqliteActionStore {
             updatedAt: row.updated_at,
         };
     }
-    async saveApproval(executionId, approverActorId, reason, approverRole) {
+    async saveApproval(executionId, approverActorId, reason, approverRole, toolName, parametersHash, companionId, actorId) {
         const stmt = this.db.prepare(`
-      INSERT INTO action_approvals (execution_id, approver_actor_id, reason, approver_role, approved_at)
-      VALUES (?, ?, ?, ?, ?)
+      INSERT INTO action_approvals (
+        execution_id, approver_actor_id, reason, approver_role, approved_at,
+        tool_name, parameters_hash, companion_id, actor_id
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(execution_id) DO UPDATE SET
         approver_actor_id = excluded.approver_actor_id,
         reason = excluded.reason,
         approver_role = excluded.approver_role,
-        approved_at = excluded.approved_at
+        approved_at = excluded.approved_at,
+        tool_name = excluded.tool_name,
+        parameters_hash = excluded.parameters_hash,
+        companion_id = excluded.companion_id,
+        actor_id = excluded.actor_id
     `);
-        stmt.run(executionId, approverActorId, reason ?? null, approverRole ?? null, new Date().toISOString());
+        stmt.run(executionId, approverActorId, reason ?? null, approverRole ?? null, new Date().toISOString(), toolName ?? null, parametersHash ?? null, companionId ?? null, actorId ?? null);
     }
     async isActionApproved(executionId) {
         const stmt = this.db.prepare('SELECT 1 FROM action_approvals WHERE execution_id = ?');
@@ -163,6 +190,10 @@ class SqliteActionStore {
             reason: row.reason ?? undefined,
             approverRole: row.approver_role ?? undefined,
             approvedAt: row.approved_at,
+            toolName: row.tool_name ?? undefined,
+            parametersHash: row.parameters_hash ?? undefined,
+            companionId: row.companion_id ?? undefined,
+            actorId: row.actor_id ?? undefined,
         };
     }
     async appendAudit(event) {

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

@@ -229,6 +229,7 @@ describe('SqliteActionStore Implementation & Durability', () => {
         await engine1.approveAction({
             executionId: 'exec-danger-1',
             approverActorId: 'local-owner',
+            approverRole: 'owner',
             reason: 'Owner confirmed cleanup',
         });
         store1.close();
@@ -247,6 +248,14 @@ describe('SqliteActionStore Implementation & Durability', () => {
         expect(eval2.decision.decisionCode).toBe('ALLOWED_POLICY');
         expect(eval2.capability).toBeDefined();
         expect((0, capability_1.verifyCapabilitySignature)(eval2.capability, secretKey)).toBe(true);
+        // 5. Tampered action after restart -> rejected due to approval parameter mismatch
+        const tamperedAction = {
+            ...action,
+            parameters: { force: true, dropDatabase: true },
+        };
+        const evalTampered = await engine2.evaluateAction(tamperedAction);
+        expect(evalTampered.decision.allowed).toBe(false);
+        expect(evalTampered.decision.decisionCode).toBe('REJECTED_APPROVAL_MISMATCH');
         store2.close();
     });
 });

package/package.json

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