@siduri-x/core 2.0.0 → 2.0.1

package/dist/siduri-db.test.js

@@ -72,6 +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)', () => {
+            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);
+        });
         it('stores and retrieves companion identity', () => {
             db = new siduri_db_1.SiduriDatabase({ dbPath });
             const identity = {
@@ -465,6 +474,91 @@ describe('SiduriDatabase', () => {
             // More occurrences of "dark" → better BM25 rank (lower rank value = better match)
             expect(results[0].id).toBe(c1.id);
         });
+        it('excludes pending and rejected claims from searchClaims in SiduriDatabase', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const pending = db.proposeClaim({
+                id: crypto.randomUUID(),
+                companionId: 'siduri-test',
+                subject: 'SecretProject',
+                predicate: 'status',
+                value: 'unapproved draft specification',
+                confidence: 0.9,
+                assertedAt: new Date().toISOString(),
+            });
+            // Must not match while pending
+            let results = db.searchClaims('siduri-test', 'unapproved');
+            expect(results.some((r) => r.id === pending.id)).toBe(false);
+            // Approve: now it matches
+            db.approveClaim(pending.id, 'siduri-test');
+            results = db.searchClaims('siduri-test', 'unapproved');
+            expect(results.some((r) => r.id === pending.id)).toBe(true);
+            // Revoke: must no longer match
+            db.revokeClaim(pending.id, 'siduri-test');
+            results = db.searchClaims('siduri-test', 'unapproved');
+            expect(results.some((r) => r.id === pending.id)).toBe(false);
+            // Explicitly rejected claims must also not match
+            const rejected = db.proposeClaim({
+                id: crypto.randomUUID(),
+                companionId: 'siduri-test',
+                subject: 'RejectedFact',
+                predicate: 'status',
+                value: 'unapproved rejection draft',
+                confidence: 0.1,
+            });
+            db.rejectClaim(rejected.id, 'siduri-test');
+            results = db.searchClaims('siduri-test', 'rejection');
+            expect(results.some((r) => r.id === rejected.id)).toBe(false);
+        });
+        it('bounds approveClaim to specific companionId when provided', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const claim = db.proposeClaim({
+                id: crypto.randomUUID(),
+                companionId: 'companion-target',
+                subject: 'ProtectedFact',
+                predicate: 'belongsTo',
+                value: 'Target',
+                confidence: 1.0,
+                assertedAt: new Date().toISOString(),
+            });
+            // Attempting to approve for a different companion must not affect it
+            db.approveClaim(claim.id, 'companion-intruder');
+            expect(db.getApprovedClaims('companion-target')).toHaveLength(0);
+            // Approving with the correct companionId succeeds
+            db.approveClaim(claim.id, 'companion-target');
+            expect(db.getApprovedClaims('companion-target')).toHaveLength(1);
+        });
+        it('resets memory for the specified companion only', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const c1 = db.proposeClaim({
+                id: crypto.randomUUID(),
+                companionId: 'comp-1',
+                subject: 'Fact1',
+                predicate: 'is',
+                value: 'One',
+                confidence: 1.0,
+            });
+            const c2 = db.proposeClaim({
+                id: crypto.randomUUID(),
+                companionId: 'comp-2',
+                subject: 'Fact2',
+                predicate: 'is',
+                value: 'Two',
+                confidence: 1.0,
+            });
+            db.approveClaim(c1.id, 'comp-1');
+            db.approveClaim(c2.id, 'comp-2');
+            db.recordEvent({
+                id: crypto.randomUUID(),
+                companionId: 'comp-1',
+                sourceType: 'chat_turn',
+                occurredAt: new Date().toISOString(),
+                payload: { text: 'Hello' },
+            });
+            db.resetMemory('comp-1');
+            expect(db.getApprovedClaims('comp-1')).toHaveLength(0);
+            expect(db.getRecentEvents('comp-1')).toHaveLength(0);
+            expect(db.getApprovedClaims('comp-2')).toHaveLength(1);
+        });
     });
     // ==========================================
     // Cross-Domain & Persistence Tests
@@ -576,5 +670,194 @@ describe('SiduriDatabase', () => {
             expect(db.searchClaims(cId, 'anything')).toHaveLength(0);
             expect(db.getApprovedClaims(cId)).toHaveLength(0);
         });
+        it('enforces directive state transitions (pending -> active -> disabled/rejected/revoked)', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const cId = 'directive-state-test';
+            const dId = 'dir-lifecycle-1';
+            // 1. Commit directive in PENDING state
+            db.commitDirective({
+                id: dId,
+                companionId: cId,
+                priority: 60,
+                directive: 'Always verify claims',
+                status: 'PENDING',
+                category: 'behavioral',
+            });
+            // Pending directives must not be returned by getActiveDirectives
+            expect(db.getActiveDirectives(cId)).toHaveLength(0);
+            // 2. Approve directive
+            db.approveDirective(dId);
+            const active = db.getActiveDirectives(cId);
+            expect(active).toHaveLength(1);
+            expect(active[0].id).toBe(dId);
+            expect(active[0].status).toBe('ACTIVE');
+            // 3. Revoke directive
+            db.revokeDirective(dId);
+            expect(db.getActiveDirectives(cId)).toHaveLength(0);
+            // 4. Reject directive
+            const d2Id = 'dir-lifecycle-2';
+            db.commitDirective({
+                id: d2Id,
+                companionId: cId,
+                priority: 50,
+                directive: 'Unsafe rule',
+                status: 'PENDING',
+                category: 'behavioral',
+            });
+            db.rejectDirective(d2Id);
+            expect(db.getActiveDirectives(cId)).toHaveLength(0);
+        });
+        it('rejects invalid directive state transitions (throws when approving non-PENDING directive)', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const cId = 'directive-invalid-transition-test';
+            // 1. Commit directive in REJECTED state
+            db.commitDirective({
+                id: 'dir-rejected-1',
+                companionId: cId,
+                priority: 50,
+                directive: 'Rejected directive',
+                status: 'REJECTED',
+                category: 'behavioral',
+            });
+            expect(() => db.approveDirective('dir-rejected-1')).toThrow(/invalid transition from status 'REJECTED' to 'ACTIVE'/);
+            // 2. Commit directive in ACTIVE state
+            db.commitDirective({
+                id: 'dir-active-1',
+                companionId: cId,
+                priority: 50,
+                directive: 'Already active directive',
+                status: 'ACTIVE',
+                category: 'behavioral',
+            });
+            expect(() => db.approveDirective('dir-active-1')).toThrow(/invalid transition from status 'ACTIVE' to 'ACTIVE'/);
+            // 3. Rejecting an already ACTIVE directive throws
+            expect(() => db.rejectDirective('dir-active-1')).toThrow(/invalid transition from status 'ACTIVE' to 'REJECTED'/);
+        });
+        it('automatically marks prior directive as SUPERSEDED when approving superseding directive', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const cId = 'directive-supersede-test';
+            // 1. Initial directive active
+            db.commitDirective({
+                id: 'dir-original-1',
+                companionId: cId,
+                priority: 50,
+                directive: 'Original rule',
+                status: 'ACTIVE',
+                category: 'behavioral',
+            });
+            expect(db.getActiveDirectives(cId)).toHaveLength(1);
+            // 2. Propose a superseding directive
+            db.commitDirective({
+                id: 'dir-replacement-1',
+                companionId: cId,
+                priority: 55,
+                directive: 'Updated replacement rule',
+                status: 'PENDING',
+                category: 'behavioral',
+                supersedesId: 'dir-original-1',
+            });
+            // Original is still active, replacement is pending
+            expect(db.getActiveDirectives(cId)).toHaveLength(1);
+            expect(db.getActiveDirectives(cId)[0].id).toBe('dir-original-1');
+            // 3. Approve replacement directive
+            db.approveDirective('dir-replacement-1', cId);
+            const active = db.getActiveDirectives(cId);
+            expect(active).toHaveLength(1);
+            expect(active[0].id).toBe('dir-replacement-1');
+            const original = db.getDirective('dir-original-1', cId);
+            expect(original?.status).toBe('SUPERSEDED');
+        });
+        it('enforces companion isolation on directive approval', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const cIdA = 'companion-alpha';
+            const cIdB = 'companion-beta';
+            db.commitDirective({
+                id: 'dir-beta-1',
+                companionId: cIdB,
+                priority: 50,
+                directive: 'Beta private rule',
+                status: 'PENDING',
+                category: 'behavioral',
+            });
+            // Alpha attempts to approve Beta's directive scoped to Alpha
+            db.approveDirective('dir-beta-1', cIdA);
+            // Beta's directive must remain PENDING and unapproved
+            const betaDirective = db.getDirective('dir-beta-1', cIdB);
+            expect(betaDirective?.status).toBe('PENDING');
+            expect(db.getActiveDirectives(cIdB)).toHaveLength(0);
+            // Beta approves its own directive successfully
+            db.approveDirective('dir-beta-1', cIdB);
+            expect(db.getActiveDirectives(cIdB)).toHaveLength(1);
+        });
+        it('enforces claim state transitions (pending -> approved -> revoked/expired/session_only)', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const cId = 'claim-state-test';
+            const claim = db.proposeClaim({
+                id: 'claim-1',
+                companionId: cId,
+                subject: 'user',
+                predicate: 'likes',
+                value: 'matcha',
+            });
+            expect(claim.status).toBe('PENDING');
+            expect(db.getApprovedClaims(cId)).toHaveLength(0);
+            // Approve
+            db.approveClaim('claim-1');
+            expect(db.getApprovedClaims(cId)).toHaveLength(1);
+            // Revoke
+            db.revokeClaim('claim-1');
+            expect(db.getApprovedClaims(cId)).toHaveLength(0);
+            // Session only
+            const claim2 = db.proposeClaim({
+                id: 'claim-2',
+                companionId: cId,
+                subject: 'session',
+                predicate: 'topic',
+                value: 'investigation',
+            });
+            db.markClaimSessionOnly('claim-2');
+            expect(db.getApprovedClaims(cId)).toHaveLength(0);
+            // Expire
+            db.expireClaim('claim-2');
+            expect(db.getApprovedClaims(cId)).toHaveLength(0);
+        });
+        it('strictly rejects illegal claim state transitions in approveClaim', () => {
+            db = new siduri_db_1.SiduriDatabase({ dbPath });
+            const cId = 'claim-transition-test';
+            // 1. Propose and reject claim
+            const rejectedClaim = db.proposeClaim({
+                id: 'claim-rejected',
+                companionId: cId,
+                subject: 'fact',
+                predicate: 'is',
+                value: 'false',
+            });
+            db.rejectClaim(rejectedClaim.id);
+            // Attempting to approve a REJECTED claim must throw
+            expect(() => db.approveClaim(rejectedClaim.id)).toThrow(/invalid transition from status 'REJECTED' to 'APPROVED'/);
+            // 2. Propose and approve claim, then revoke
+            const revokedClaim = db.proposeClaim({
+                id: 'claim-revoked',
+                companionId: cId,
+                subject: 'fact',
+                predicate: 'is',
+                value: 'outdated',
+            });
+            db.approveClaim(revokedClaim.id);
+            db.revokeClaim(revokedClaim.id);
+            // Attempting to approve a REVOKED claim must throw
+            expect(() => db.approveClaim(revokedClaim.id)).toThrow(/invalid transition from status 'REVOKED' to 'APPROVED'/);
+            // 3. Propose and expire claim
+            const expiredClaim = db.proposeClaim({
+                id: 'claim-expired',
+                companionId: cId,
+                subject: 'fact',
+                predicate: 'is',
+                value: 'temporary',
+            });
+            db.expireClaim(expiredClaim.id);
+            // Attempting to approve an EXPIRED claim must throw
+            expect(() => db.approveClaim(expiredClaim.id)).toThrow(/invalid transition from status 'EXPIRED' to 'APPROVED'/);
+        });
     });
 });

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

@@ -1,5 +1,5 @@
 import { ActionAuditEvent } from './action';
-import { ActionStore, PersistentExecutionRecord } from './capability';
+import { ActionStore, PersistentExecutionRecord, ActionApprovalRecord } from './capability';
 export interface SqliteActionStoreOptions {
     dbPath?: string;
 }
@@ -12,8 +12,9 @@ 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): Promise<void>;
+    saveApproval(executionId: string, approverActorId: string, reason?: string, approverRole?: string): Promise<void>;
     isActionApproved(executionId: string): Promise<boolean>;
+    getApproval(executionId: string): Promise<ActionApprovalRecord | undefined>;
     appendAudit(event: ActionAuditEvent): Promise<void>;
     getAuditLog(executionId?: string): Promise<ActionAuditEvent[]>;
     close(): void;

package/dist/sqlite-action-store.js

@@ -36,6 +36,7 @@ class SqliteActionStore {
         execution_id TEXT PRIMARY KEY,
         approver_actor_id TEXT NOT NULL,
         reason TEXT,
+        approver_role TEXT,
         approved_at TEXT NOT NULL
       );
 
@@ -62,6 +63,12 @@ class SqliteActionStore {
         timestamp TEXT NOT NULL
       );
     `);
+        try {
+            this.db.exec('ALTER TABLE action_approvals ADD COLUMN approver_role TEXT;');
+        }
+        catch {
+            // Column already exists or table freshly created
+        }
     }
     initLastAuditHash() {
         const row = this.db.prepare('SELECT event_hash FROM action_audit_log ORDER BY id DESC LIMIT 1').get();
@@ -127,22 +134,37 @@ class SqliteActionStore {
             updatedAt: row.updated_at,
         };
     }
-    async saveApproval(executionId, approverActorId, reason) {
+    async saveApproval(executionId, approverActorId, reason, approverRole) {
         const stmt = this.db.prepare(`
-      INSERT INTO action_approvals (execution_id, approver_actor_id, reason, approved_at)
-      VALUES (?, ?, ?, ?)
+      INSERT INTO action_approvals (execution_id, approver_actor_id, reason, approver_role, approved_at)
+      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
     `);
-        stmt.run(executionId, approverActorId, reason ?? null, new Date().toISOString());
+        stmt.run(executionId, approverActorId, reason ?? null, approverRole ?? null, new Date().toISOString());
     }
     async isActionApproved(executionId) {
         const stmt = this.db.prepare('SELECT 1 FROM action_approvals WHERE execution_id = ?');
         const row = stmt.get(executionId);
         return !!row;
     }
+    async getApproval(executionId) {
+        const stmt = this.db.prepare('SELECT * FROM action_approvals WHERE execution_id = ?');
+        const row = stmt.get(executionId);
+        if (!row) {
+            return undefined;
+        }
+        return {
+            executionId: row.execution_id,
+            approverActorId: row.approver_actor_id,
+            reason: row.reason ?? undefined,
+            approverRole: row.approver_role ?? undefined,
+            approvedAt: row.approved_at,
+        };
+    }
     async appendAudit(event) {
         const prevHash = this.lastAuditHash;
         const eventPayload = {
@@ -164,6 +186,7 @@ class SqliteActionStore {
                 decisionCode: event.decision.decisionCode,
             } : null,
             parametersHash: event.parametersHash || null,
+            resultHash: event.resultHash || null,
             error: event.error || null,
             timestamp: event.timestamp,
         };

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

@@ -152,6 +152,7 @@ describe('SqliteActionStore Implementation & Durability', () => {
             lifecycle: event1.lifecycle,
             decision: null,
             parametersHash: null,
+            resultHash: null,
             error: null,
             timestamp: event1.timestamp,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siduri-x/core",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Core runtime types, evidence protocol, action dispatcher, capability validation, and SiduriRuntime protocol",
   "license": "Apache-2.0",
   "repository": {
@@ -17,7 +17,7 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22.16.0"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,11 +29,11 @@
     }
   },
   "devDependencies": {
-    "@types/jest": "^29.5.14",
-    "@types/node": "^26.2.0",
-    "jest": "^29.7.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.5.1",
+    "jest": "^30.5.1",
     "ts-jest": "^29.4.12",
-    "typescript": "^5.3.3"
+    "typescript": "^5.9.3"
   },
   "scripts": {
     "build": "tsc",