@siduri-x/core 2.0.0 → 2.0.2

package/dist/siduri-db.js

@@ -114,7 +114,9 @@ class SiduriDatabase {
         valid_from TEXT,
         valid_until TEXT,
         evidence TEXT,
-        asserted_at TEXT DEFAULT (datetime('now'))
+        asserted_at TEXT DEFAULT (datetime('now')),
+        supersedes TEXT,
+        source_event_id TEXT
       );
 
       -- FTS5 Virtual Table for Memory Claims
@@ -145,6 +147,18 @@ class SiduriDatabase {
       END;
     `;
         this.db.exec(schema);
+        try {
+            this.db.exec("ALTER TABLE memory_claims ADD COLUMN supersedes TEXT");
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.db.exec("ALTER TABLE memory_claims ADD COLUMN source_event_id TEXT");
+        }
+        catch {
+            // Column already exists
+        }
     }
     close() {
         this.db.close();
@@ -228,9 +242,106 @@ class SiduriDatabase {
     `);
         stmt.run(directive.id, directive.companionId, directive.priority, directive.directive, directive.status, directive.category, directive.supersedesId || null, directive.createdAt || new Date().toISOString());
     }
-    disableDirective(id) {
-        const stmt = this.db.prepare("UPDATE self_directives SET status = 'DISABLED' WHERE id = ?");
-        stmt.run(id);
+    getDirective(id, companionId) {
+        const stmt = companionId
+            ? this.db.prepare('SELECT * FROM self_directives WHERE id = ? AND companion_id = ?')
+            : this.db.prepare('SELECT * FROM self_directives WHERE id = ?');
+        const row = (companionId ? stmt.get(id, companionId) : stmt.get(id));
+        if (!row)
+            return undefined;
+        return {
+            id: row.id,
+            companionId: row.companion_id,
+            priority: row.priority,
+            directive: row.directive,
+            status: row.status,
+            category: row.category,
+            supersedesId: row.supersedes_id || undefined,
+            createdAt: row.created_at,
+        };
+    }
+    approveDirective(id, companionId) {
+        const findStmt = companionId
+            ? this.db.prepare("SELECT id, companion_id, status, supersedes_id FROM self_directives WHERE id = ? AND companion_id = ?")
+            : this.db.prepare("SELECT id, companion_id, status, supersedes_id FROM self_directives WHERE id = ?");
+        const row = (companionId ? findStmt.get(id, companionId) : findStmt.get(id));
+        if (!row) {
+            return;
+        }
+        if (row.status !== 'PENDING') {
+            throw new Error(`Cannot approve directive '${id}': invalid transition from status '${row.status}' to 'ACTIVE' (only PENDING directives can be approved)`);
+        }
+        // If this directive supersedes an earlier directive, transition that prior directive to SUPERSEDED
+        if (row.supersedes_id) {
+            const supersededId = row.supersedes_id;
+            const effectiveCompanionId = companionId || row.companion_id;
+            if (effectiveCompanionId) {
+                const supersedeStmt = this.db.prepare("UPDATE self_directives SET status = 'SUPERSEDED' WHERE id = ? AND companion_id = ?");
+                supersedeStmt.run(supersededId, effectiveCompanionId);
+            }
+            else {
+                const supersedeStmt = this.db.prepare("UPDATE self_directives SET status = 'SUPERSEDED' WHERE id = ?");
+                supersedeStmt.run(supersededId);
+            }
+        }
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'ACTIVE' WHERE id = ? AND companion_id = ? AND status = 'PENDING'");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'ACTIVE' WHERE id = ? AND status = 'PENDING'");
+            stmt.run(id);
+        }
+    }
+    rejectDirective(id, companionId) {
+        const findStmt = companionId
+            ? this.db.prepare("SELECT id, companion_id, status FROM self_directives WHERE id = ? AND companion_id = ?")
+            : this.db.prepare("SELECT id, companion_id, status FROM self_directives WHERE id = ?");
+        const row = (companionId ? findStmt.get(id, companionId) : findStmt.get(id));
+        if (!row) {
+            return;
+        }
+        if (row.status !== 'PENDING') {
+            throw new Error(`Cannot reject directive '${id}': invalid transition from status '${row.status}' to 'REJECTED' (only PENDING directives can be rejected)`);
+        }
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'REJECTED' WHERE id = ? AND companion_id = ? AND status = 'PENDING'");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'REJECTED' WHERE id = ? AND status = 'PENDING'");
+            stmt.run(id);
+        }
+    }
+    revokeDirective(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'REVOKED' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'REVOKED' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    expireDirective(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'EXPIRED' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'EXPIRED' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    disableDirective(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'DISABLED' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE self_directives SET status = 'DISABLED' WHERE id = ?");
+            stmt.run(id);
+        }
     }
     getRelationship(companionId, entityId) {
         const stmt = this.db.prepare('SELECT * FROM self_relationships WHERE companion_id = ? AND entity_id = ?');
@@ -380,33 +491,116 @@ class SiduriDatabase {
             payload: JSON.parse(row.payload)
         }));
     }
+    getEvent(id) {
+        const stmt = this.db.prepare('SELECT * FROM memory_events WHERE id = ?');
+        const row = stmt.get(id);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id,
+            companionId: row.companion_id,
+            sourceType: row.source_type,
+            occurredAt: row.occurred_at,
+            payload: JSON.parse(row.payload)
+        };
+    }
     proposeClaim(claim) {
         const id = claim.id || crypto.randomUUID();
         const status = 'PENDING';
+        const confidence = claim.confidence ?? 1.0;
+        const assertedAt = claim.assertedAt || new Date().toISOString();
         const stmt = this.db.prepare(`
-      INSERT INTO memory_claims (id, companion_id, subject, predicate, value, status, confidence, valid_from, valid_until, evidence, asserted_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, coalesce(?, datetime('now')))
+      INSERT INTO memory_claims (id, companion_id, subject, predicate, value, status, confidence, valid_from, valid_until, evidence, asserted_at, supersedes, source_event_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, coalesce(?, datetime('now')), ?, ?)
     `);
-        stmt.run(id, claim.companionId, claim.subject, claim.predicate, claim.value, status, claim.confidence ?? 1.0, claim.validFrom || null, claim.validUntil || null, claim.evidence ? JSON.stringify(claim.evidence) : null, claim.assertedAt || null);
+        stmt.run(id, claim.companionId, claim.subject, claim.predicate, claim.value, status, confidence, claim.validFrom || null, claim.validUntil || null, claim.evidence ? JSON.stringify(claim.evidence) : null, assertedAt || null, claim.supersedes || null, claim.sourceEventId || null);
         return {
             ...claim,
             id,
-            status
+            status,
+            confidence,
+            assertedAt,
+            supersedes: claim.supersedes,
+            sourceEventId: claim.sourceEventId,
         };
     }
-    approveClaim(id) {
-        const stmt = this.db.prepare("UPDATE memory_claims SET status = 'APPROVED' WHERE id = ?");
-        stmt.run(id);
+    approveClaim(id, companionId) {
+        const findClaim = companionId
+            ? this.db.prepare("SELECT id, status, supersedes FROM memory_claims WHERE id = ? AND companion_id = ?")
+            : this.db.prepare("SELECT id, status, supersedes FROM memory_claims WHERE id = ?");
+        const row = (companionId ? findClaim.get(id, companionId) : findClaim.get(id));
+        if (!row) {
+            return;
+        }
+        if (row.status !== 'PENDING') {
+            throw new Error(`Cannot approve claim '${id}': invalid transition from status '${row.status}' to 'APPROVED' (only PENDING claims can be approved)`);
+        }
+        // If this claim supersedes an earlier claim, transition that prior claim to SUPERSEDED
+        if (row.supersedes) {
+            const supersededId = row.supersedes;
+            if (companionId) {
+                const supersedeStmt = this.db.prepare("UPDATE memory_claims SET status = 'SUPERSEDED' WHERE id = ? AND companion_id = ?");
+                supersedeStmt.run(supersededId, companionId);
+            }
+            else {
+                const supersedeStmt = this.db.prepare("UPDATE memory_claims SET status = 'SUPERSEDED' WHERE id = ?");
+                supersedeStmt.run(supersededId);
+            }
+        }
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'APPROVED' WHERE id = ? AND companion_id = ? AND status = 'PENDING'");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'APPROVED' WHERE id = ? AND status = 'PENDING'");
+            stmt.run(id);
+        }
     }
-    rejectClaim(id) {
-        const stmt = this.db.prepare("UPDATE memory_claims SET status = 'REJECTED' WHERE id = ?");
-        stmt.run(id);
+    rejectClaim(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'REJECTED' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'REJECTED' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    revokeClaim(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'REVOKED' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'REVOKED' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    expireClaim(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'EXPIRED' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'EXPIRED' WHERE id = ?");
+            stmt.run(id);
+        }
+    }
+    markClaimSessionOnly(id, companionId) {
+        if (companionId) {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'SESSION_ONLY' WHERE id = ? AND companion_id = ?");
+            stmt.run(id, companionId);
+        }
+        else {
+            const stmt = this.db.prepare("UPDATE memory_claims SET status = 'SESSION_ONLY' WHERE id = ?");
+            stmt.run(id);
+        }
     }
     searchClaims(companionId, query, limit = 20) {
         const stmt = this.db.prepare(`
       SELECT c.* FROM memory_claims c
       JOIN memory_search s ON c.rowid = s.rowid
-      WHERE c.companion_id = ? AND memory_search MATCH ?
+      WHERE c.companion_id = ? AND c.status = 'APPROVED' AND memory_search MATCH ?
       ORDER BY rank
       LIMIT ?
     `);
@@ -421,7 +615,27 @@ class SiduriDatabase {
             validFrom: row.valid_from || undefined,
             validUntil: row.valid_until || undefined,
             evidence: row.evidence ? JSON.parse(row.evidence) : undefined,
-            assertedAt: row.asserted_at
+            assertedAt: row.asserted_at,
+            supersedes: row.supersedes || undefined,
+            sourceEventId: row.source_event_id || undefined,
+        }));
+    }
+    getPendingClaims(companionId, limit = 50) {
+        const stmt = this.db.prepare("SELECT * FROM memory_claims WHERE companion_id = ? AND status = 'PENDING' ORDER BY asserted_at DESC LIMIT ?");
+        return stmt.all(companionId, limit).map((row) => ({
+            id: row.id,
+            companionId: row.companion_id,
+            subject: row.subject,
+            predicate: row.predicate,
+            value: row.value,
+            status: row.status,
+            confidence: row.confidence,
+            validFrom: row.valid_from || undefined,
+            validUntil: row.valid_until || undefined,
+            evidence: row.evidence ? JSON.parse(row.evidence) : undefined,
+            assertedAt: row.asserted_at,
+            supersedes: row.supersedes || undefined,
+            sourceEventId: row.source_event_id || undefined,
         }));
     }
     getApprovedClaims(companionId, limit = 50) {
@@ -437,8 +651,37 @@ class SiduriDatabase {
             validFrom: row.valid_from || undefined,
             validUntil: row.valid_until || undefined,
             evidence: row.evidence ? JSON.parse(row.evidence) : undefined,
-            assertedAt: row.asserted_at
+            assertedAt: row.asserted_at,
+            supersedes: row.supersedes || undefined,
+            sourceEventId: row.source_event_id || undefined,
         }));
     }
+    getClaim(id) {
+        const stmt = this.db.prepare("SELECT * FROM memory_claims WHERE id = ?");
+        const row = stmt.get(id);
+        if (!row)
+            return undefined;
+        return {
+            id: row.id,
+            companionId: row.companion_id,
+            subject: row.subject,
+            predicate: row.predicate,
+            value: row.value,
+            status: row.status,
+            confidence: row.confidence,
+            validFrom: row.valid_from || undefined,
+            validUntil: row.valid_until || undefined,
+            evidence: row.evidence ? JSON.parse(row.evidence) : undefined,
+            assertedAt: row.asserted_at,
+            supersedes: row.supersedes || undefined,
+            sourceEventId: row.source_event_id || undefined,
+        };
+    }
+    resetMemory(companionId) {
+        const deleteClaims = this.db.prepare("DELETE FROM memory_claims WHERE companion_id = ?");
+        deleteClaims.run(companionId);
+        const deleteEvents = this.db.prepare("DELETE FROM memory_events WHERE companion_id = ?");
+        deleteEvents.run(companionId);
+    }
 }
 exports.SiduriDatabase = SiduriDatabase;

package/dist/siduri-db.test.js

@@ -72,6 +72,16 @@ describe('SiduriDatabase', () => {
                 memDb.close();
             }).not.toThrow();
         });
+        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 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 });
             const identity = {
@@ -465,6 +475,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 +671,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, 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>;
     getAuditLog(executionId?: string): Promise<ActionAuditEvent[]>;
     close(): void;