@sidurijs/core 1.0.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 VXNUS Creative Technology Studio
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/container.d.ts

@@ -1,11 +1,11 @@
-import { BrainOrgan, MemoryOrgan, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, MouthOrgan, SelfRepository, EKnowledgeOrgan, OrganConfig, ActionStore, ActionPolicyEngine, ResponseGatingEngine, ExperienceDispatcher, ExperienceAdapter } from './index';
+import { BrainOrgan, ArchiveLedger, VoiceOrgan, KnowledgeOrgan, VisionOrgan, BehaviorOrgan, BodyOrgan, HandsOrgan, EarOrgan, ObservationOrgan, MouthOrgan, SelfRepository, EKnowledgeOrgan, OrganConfig, ActionStore, ActionPolicyEngine, ResponseGatingEngine, ExperienceDispatcher, ExperienceAdapter } from './index';
 import { SessionHistoryManager } from './session-history';
 import { SiduriRuntime } from './runtime';
 export interface SiduriRuntimeConfig {
     name: string;
     brain?: OrganConfig | Record<string, unknown>;
     voice?: OrganConfig | Record<string, unknown>;
-    memory?: OrganConfig | Record<string, unknown>;
+    archive?: OrganConfig | Record<string, unknown>;
     knowledge?: OrganConfig | Record<string, unknown>;
     behavior?: OrganConfig | Record<string, unknown>;
     body?: OrganConfig | Record<string, unknown>;
@@ -26,7 +26,7 @@ export interface SiduriRuntimeConfig {
 }
 export interface RuntimeOrgans {
     brain?: BrainOrgan;
-    memory?: MemoryOrgan;
+    archive?: ArchiveLedger;
     voice?: VoiceOrgan | ExperienceAdapter;
     knowledge?: KnowledgeOrgan;
     vision?: VisionOrgan;
@@ -40,6 +40,8 @@ export interface RuntimeOrgans {
     externalKnowledge?: EKnowledgeOrgan;
     actionStore?: ActionStore;
     actionPolicy?: ActionPolicyEngine;
+    memory?: any;
+    [key: string]: unknown;
 }
 /**
  * CompanionContainer manages the lifecycle, discovery, wiring, and dependency injection
@@ -56,7 +58,7 @@ export declare class CompanionContainer {
     private _runtime?;
     constructor(id: string, config: SiduriRuntimeConfig, organs?: RuntimeOrgans);
     get brain(): BrainOrgan | undefined;
-    get memory(): MemoryOrgan | undefined;
+    get archive(): ArchiveLedger | undefined;
     get voice(): ExperienceAdapter | VoiceOrgan | undefined;
     get knowledge(): KnowledgeOrgan | undefined;
     get vision(): VisionOrgan | undefined;

package/dist/container.js

@@ -47,7 +47,7 @@ class CompanionContainer {
     }
     // Direct organ accessors
     get brain() { return this.organs.brain; }
-    get memory() { return this.organs.memory; }
+    get archive() { return this.organs.archive; }
     get voice() { return this.organs.voice; }
     get knowledge() { return this.organs.knowledge; }
     get vision() { return this.organs.vision; }
@@ -61,9 +61,6 @@ class CompanionContainer {
     get self() { return this.organs.self; }
     get externalKnowledge() { return this.organs.externalKnowledge; }
     async initialize() {
-        if (this.organs.memory && typeof this.organs.memory.initialize === 'function') {
-            await this.organs.memory.initialize(this.id);
-        }
         if (this.organs.hands && typeof this.organs.hands.listTools === 'function') {
             const tools = await this.organs.hands.listTools();
             for (const tool of tools) {

package/dist/context-retriever.d.ts

@@ -1,4 +1,4 @@
-import { KnowledgeOrgan, MemoryOrgan, KnowledgeItem, Claim, BehaviorDirective, EvidenceRecord, ResponseCitation, RequestContext, SelfRepository, LifeDatabase, EpisodicMemoryStore, EKnowledgeOrgan } from './index';
+import { KnowledgeOrgan, KnowledgeItem, Claim, BehaviorDirective, EvidenceRecord, ResponseCitation, RequestContext, SelfRepository, LifeDatabase, ArchiveLedger, EpisodicMemoryStore, EKnowledgeOrgan } from './index';
 export interface ContextRetrievalParams {
     companionId: string;
     perceivedText: string;
@@ -10,7 +10,8 @@ export interface ContextRetrievalParams {
     memoryQueries?: string[];
     isSelfIdentityRequest?: boolean;
     knowledge?: KnowledgeOrgan | LifeDatabase;
-    memory?: MemoryOrgan | EpisodicMemoryStore;
+    archive?: ArchiveLedger;
+    memory?: EpisodicMemoryStore;
     self?: SelfRepository;
     externalKnowledge?: EKnowledgeOrgan | KnowledgeOrgan;
 }

package/dist/context-retriever.js

@@ -7,7 +7,7 @@ const intent_classifier_1 = require("./intent-classifier");
  * in a single parallel pass with graceful degradation.
  */
 async function retrieveRuntimeContext(params) {
-    const { companionId, perceivedText, requestContext, role, isContextObject, shouldQueryKnowledge, knowledgeQueries, memoryQueries, isSelfIdentityRequest, knowledge, memory, self, externalKnowledge, } = params;
+    const { companionId, perceivedText, requestContext, role, isContextObject, shouldQueryKnowledge, knowledgeQueries, memoryQueries, isSelfIdentityRequest, knowledge, archive, memory, self, externalKnowledge, } = params;
     const queryOptions = isContextObject
         ? {
             limit: 5,
@@ -59,7 +59,7 @@ async function retrieveRuntimeContext(params) {
                 return merged;
             })
             : Promise.resolve([]),
-        // Stream B: Episodic Memory / Verified Claims (SQLite FTS5 with Identity Fallback)
+        // Stream B: Interaction Archive / Verified Claims (FTS5 search with fallback)
         memory && typeof memory.searchClaims === 'function'
             ? (async () => {
                 try {
@@ -93,7 +93,28 @@ async function retrieveRuntimeContext(params) {
                     return [];
                 }
             })()
-            : Promise.resolve([]),
+            : archive && typeof archive.searchEvents === 'function'
+                ? (async () => {
+                    try {
+                        const events = await archive.searchEvents(companionId, memoryQueryToRun, 5);
+                        return (events || []).map((evt) => ({
+                            id: evt.id,
+                            companionId: evt.companionId,
+                            subject: evt.sourceType,
+                            predicate: 'event',
+                            value: typeof evt.payload === 'string' ? evt.payload : JSON.stringify(evt.payload),
+                            status: 'approved',
+                            provenance: 'archive_ledger',
+                            claimType: 'event',
+                        }));
+                    }
+                    catch (e) {
+                        console.error('[SiduriRuntime] Archive search failed:', e.message);
+                        subsystemDiagnostics['archive'] = `UNAVAILABLE: ${e.message}`;
+                        return [];
+                    }
+                })()
+                : Promise.resolve([]),
         // Stream C: Active Directives from Self (or fallback Memory)
         self && typeof self.getActiveDirectives === 'function'
             ? self.getActiveDirectives(companionId).catch((e) => {

package/dist/conversational-teach.test.js

@@ -81,18 +81,31 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         };
     }
     /**
-     * Helper to build a MemoryOrgan wrapping a SiduriDatabase
+     * Helper to build a MemoryOrgan wrapping a SiduriDatabase & local claim mock
      */
     function createMemoryOrgan(db) {
+        const claims = [];
         return {
             initialize: async () => { },
-            proposeClaim: async (claim) => db.proposeClaim(claim),
+            proposeClaim: async (claim) => {
+                const c = { id: claim.id || `claim-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`, status: 'pending', ...claim };
+                claims.push(c);
+                return c;
+            },
             searchClaims: async () => [],
-            getApprovedClaims: async (companionId, limit) => db.getApprovedClaims(companionId || 'default', limit || 50),
-            getClaims: async (limit) => db.getAllClaims(undefined, limit || 500),
-            getPendingClaims: async (limit) => db.getAllClaims(undefined, limit || 500).filter((c) => c.status === 'pending'),
-            approveClaim: async (id) => db.approveClaim(id),
-            rejectClaim: async (id) => db.rejectClaim(id),
+            getApprovedClaims: async (companionId, limit) => claims.filter((c) => c.status === 'approved').slice(0, limit || 50),
+            getClaims: async (limit) => claims.slice(0, limit || 500),
+            getPendingClaims: async (limit) => claims.filter((c) => c.status === 'pending').slice(0, limit || 500),
+            approveClaim: async (id) => {
+                const found = claims.find((c) => c.id === id);
+                if (found)
+                    found.status = 'approved';
+            },
+            rejectClaim: async (id) => {
+                const found = claims.find((c) => c.id === id);
+                if (found)
+                    found.status = 'rejected';
+            },
             getDirectives: async (companionId) => db.getActiveDirectives(companionId || 'default'),
             proposeDirective: async (dir) => {
                 const id = `dir-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
@@ -376,7 +389,6 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         const mockBrain = createCognitiveMockBrain(companionId);
         const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
             brain: mockBrain,
-            memory,
             self,
             behavior,
         });
@@ -426,7 +438,6 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         };
         const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
             brain: mockBrain,
-            memory,
             self,
         });
         await runtime.initialize();
@@ -459,7 +470,6 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         const mockBrain = createCognitiveMockBrain(companionId);
         const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
             brain: mockBrain,
-            memory,
             self,
         });
         await runtime.initialize();
@@ -841,48 +851,47 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
             initialMode: 'teach',
         }, {
             self,
-            memory,
             knowledge: mockKnowledge,
         });
-        // 1. Propose knowledge claims in memory store (quarantined as PENDING)
-        const entityClaim = await memory.proposeClaim({
+        // 1. Propose knowledge claims (quarantined as PENDING)
+        const entityClaim = {
+            id: 'claim-ent-1',
             companionId,
             subject: 'entity:Workstation Rig',
             predicate: 'inventory',
             value: 'Threadripper 64-core',
             claimType: 'life_entity',
             evidence: { domain: 'hardware', properties: { cores: 64, ram: '256GB' } },
-        });
-        const eventClaim = await memory.proposeClaim({
+        };
+        const eventClaim = {
+            id: 'claim-evt-1',
             companionId,
             subject: 'finance:expense',
             predicate: 'expense',
             value: '45.00',
             claimType: 'life_event',
             evidence: { metricValue: -45.0, stream: 'finance', category: 'dining' },
-        });
-        const taskClaim = await memory.proposeClaim({
+        };
+        const taskClaim = {
+            id: 'claim-task-1',
             companionId,
             subject: 'task:Review PR',
             predicate: 'todo',
             value: 'Review PR #42 for Life DB',
             claimType: 'life_task',
             evidence: { status: 'in_progress' },
-        });
+        };
         // Before approval, Life DB tables in sqlite are empty
         expect(db.getEntities(companionId)).toHaveLength(0);
         expect(db.getEvents(companionId)).toHaveLength(0);
         expect(db.getTasks(companionId)).toHaveLength(0);
         // 2. Truth Gate Approval
-        const resEntity = await runtime.approveProposal(entityClaim.id, { companionId });
-        expect(resEntity.success).toBe(true);
-        expect(resEntity.target).toBe('knowledge');
-        const resEvent = await runtime.approveProposal(eventClaim.id, { companionId });
-        expect(resEvent.success).toBe(true);
-        expect(resEvent.target).toBe('knowledge');
-        const resTask = await runtime.approveProposal(taskClaim.id, { companionId });
-        expect(resTask.success).toBe(true);
-        expect(resTask.target).toBe('knowledge');
+        const resEntity = await (0, index_1.promoteApprovedClaimToKnowledge)(entityClaim, mockKnowledge, companionId);
+        expect(resEntity).toBe(true);
+        const resEvent = await (0, index_1.promoteApprovedClaimToKnowledge)(eventClaim, mockKnowledge, companionId);
+        expect(resEvent).toBe(true);
+        const resTask = await (0, index_1.promoteApprovedClaimToKnowledge)(taskClaim, mockKnowledge, companionId);
+        expect(resTask).toBe(true);
         // 3. Verify persistent commit to sovereign Life DB in SQLite
         const entities = db.getEntities(companionId);
         expect(entities).toHaveLength(1);
@@ -901,10 +910,8 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
     it('updates companion identity name dynamically when companion naming claim or directive is approved', async () => {
         const companionId = 'dynamic-companion';
         const db = new index_1.SiduriDatabase({ dbPath: ':memory:' });
-        const memory = createMemoryOrgan(db);
         const self = createSelfRepository(db);
         const runtime = new index_1.SiduriRuntime(companionId, { name: 'Siduri' }, {
-            memory,
             self,
         });
         await runtime.initialize();
@@ -912,14 +919,15 @@ describe('Conversational Teach Mode End-to-End Lifecycle', () => {
         const initialIdentity = await self.getIdentity(companionId);
         expect(initialIdentity?.name || 'Siduri').toBe('Siduri');
         // 1. Propose and approve claim with subject "assistant" and predicate "name"
-        const nameClaim = await memory.proposeClaim({
+        const nameClaim = {
+            id: 'claim-name-1',
             companionId,
             subject: 'assistant',
             predicate: 'name',
             value: 'Athena',
             claimType: 'semantic',
-        });
-        await runtime.approveProposal(nameClaim.id, { companionId });
+        };
+        await (0, index_1.promoteApprovedClaimToSelf)(nameClaim, self, companionId);
         const identityAfterClaim = await self.getIdentity(companionId);
         expect(identityAfterClaim?.name).toBe('Athena');
         // 2. Propose and approve behavioral directive "Address companion as Athena Prime"

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export * from './intent-classifier';
 export * from './context-retriever';
 export * from './prompt-compiler';
 export * from './cognition-planner';
+export * from './interaction-settler';
 export * from './memory-settler';
 export * from './action-executor';
 export * from './experience-emitter';
@@ -41,7 +42,7 @@ export interface CompanionConfig {
     name: string;
     brain: OrganConfig;
     voice: OrganConfig;
-    memory: OrganConfig;
+    archive: OrganConfig;
     knowledge: OrganConfig;
     behavior: OrganConfig;
     body: OrganConfig;
@@ -172,32 +173,41 @@ export interface MemoryQueryOptions {
     now?: string | Date;
     [key: string]: unknown;
 }
-export interface MemoryOrgan {
-    initialize(companionId: string): Promise<void>;
-    proposeClaim(claim: Omit<Claim, 'id' | 'status' | 'companionId'>): Promise<Claim>;
-    searchClaims(query: string, scopeOrOptions?: MemoryScope | MemoryQueryOptions, limit?: number): Promise<Claim[]>;
-    getClaims(limit?: number): Promise<Claim[]>;
-    getPendingClaims(limit?: number): Promise<Claim[]>;
-    getApprovedClaims?(companionId?: string, limit?: number): Promise<any[]>;
-    approveClaim(id: string): Promise<void>;
-    rejectClaim(id: string): Promise<void>;
-    markClaimSessionOnly?(id: string): Promise<void>;
-    expireClaim?(id: string): Promise<void>;
-    revokeClaim?(id: string, reason?: string): Promise<void>;
-    getDirectives(companionId?: string): Promise<BehaviorDirective[]>;
-    proposeDirective(directiveData: Omit<BehaviorDirective, 'id' | 'status' | 'companionId'> & {
-        companionId?: string;
-    }): Promise<BehaviorDirective>;
-    approveDirective(id: string, companionId?: string): Promise<void>;
-    rejectDirective(id: string, companionId?: string): Promise<void>;
-    revokeDirective(id: string, companionId?: string): Promise<void>;
-    disableDirective(id: string, companionId?: string): Promise<void>;
-    expireDirective?(id: string, companionId?: string): Promise<void>;
-    supersedeClaim?(id: string, replacement: Omit<Claim, 'id' | 'status' | 'companionId'>): Promise<Claim>;
-    updateClaim?(id: string, updates: Partial<Pick<Claim, 'subject' | 'predicate' | 'value' | 'scope' | 'sensitivity' | 'confidence' | 'validFrom' | 'validUntil'>>): Promise<Claim>;
-    resetMemory?(): Promise<void>;
-    addSourceEvent?(event: SourceEvent): Promise<SourceEvent>;
-    getSourceEvent?(id: string): Promise<SourceEvent | undefined>;
+export interface ArchiveEvent {
+    id: string;
+    companionId: string;
+    sourceType: string;
+    occurredAt: string;
+    payload: Record<string, unknown>;
+}
+export interface ArchiveQueryOptions {
+    limit?: number;
+    sourceType?: string;
+    since?: string;
+    until?: string;
+    [key: string]: unknown;
+}
+/**
+ * Sovereign interaction archive: cold, append-only interaction audit ledger and full-text search.
+ * Replaces the overloaded 'Memory' metaphor for audit trails, past tool runs, and historical interaction logs.
+ */
+export interface ArchiveLedger {
+    recordEvent(event: ArchiveEvent | SourceEvent): Promise<ArchiveEvent | SourceEvent>;
+    getRecentEvents(companionId: string, limit?: number): Promise<ArchiveEvent[]>;
+    getEvent?(id: string): Promise<ArchiveEvent | undefined>;
+    searchEvents?(companionId: string, query: string, limit?: number): Promise<ArchiveEvent[]>;
+    close?(): void;
+}
+export type ArchiveStore = ArchiveLedger;
+export type EpisodicLedger = ArchiveLedger;
+/**
+ * Active dialogue continuity interface for working conversational context.
+ */
+export interface DialogueHistory {
+    getHistory(sessionKey?: string): Message[];
+    setHistory(sessionKey: string, history: Message[]): void;
+    append(sessionKey: string, message: Message): void;
+    clear(sessionKey?: string): void;
 }
 export interface AudioEvent {
     type: 'STARTED' | 'COMPLETED' | 'FAILED';

package/dist/index.js

@@ -35,6 +35,7 @@ __exportStar(require("./intent-classifier"), exports);
 __exportStar(require("./context-retriever"), exports);
 __exportStar(require("./prompt-compiler"), exports);
 __exportStar(require("./cognition-planner"), exports);
+__exportStar(require("./interaction-settler"), exports);
 __exportStar(require("./memory-settler"), exports);
 __exportStar(require("./action-executor"), exports);
 __exportStar(require("./experience-emitter"), exports);

package/dist/interaction-settler.d.ts

@@ -0,0 +1,58 @@
+import { ArchiveLedger, SelfRepository, Claim, BehaviorDirective, ResponsePlan, RequestContext, InteractionMode } from './index';
+import { extractDeterministicTeaching } from './teaching';
+export interface InteractionSettlementParams {
+    companionId: string;
+    perceivedText: string;
+    role: 'OWNER' | 'VIEWER' | 'OPERATOR';
+    requestContext: RequestContext;
+    archive?: ArchiveLedger;
+    self?: SelfRepository;
+    explicitTeaching: ReturnType<typeof extractDeterministicTeaching>;
+    plan: ResponsePlan;
+    effectiveMode?: InteractionMode;
+    /** @deprecated Legacy memory organ reference. Direct domain routing routes to self or archive directly. */
+    memory?: any;
+}
+export interface ProposalReceipt {
+    proposal_id: string;
+    subject: string;
+    predicate: string;
+    value: string;
+    status: string;
+    claim_type?: string;
+    content?: string;
+}
+export type MemoryProposalReceipt = ProposalReceipt;
+export interface BehavioralProposalReceipt {
+    directive_id: string;
+    domain?: string;
+    knowledge_domain?: string;
+    memory_class?: string;
+    runtime_effect?: string;
+    subject?: string;
+    predicate?: string;
+    value?: string;
+    status: string;
+    behavior?: {
+        instruction: string;
+        frequency?: string;
+        preferred_positions?: string[];
+    };
+}
+export interface InteractionSettlementResult {
+    createdMemoryProposals: Claim[];
+    memoryProposalReceipts: ProposalReceipt[];
+    createdBehavioralProposals?: BehaviorDirective[];
+    behavioralProposalReceipts?: BehavioralProposalReceipt[];
+}
+export type MemorySettlementParams = InteractionSettlementParams;
+export type MemorySettlementResult = InteractionSettlementResult;
+/**
+ * Persists source events to ArchiveLedger and behavioral directive proposals directly to SelfRepository.
+ * Direct Domain Routing under RFC VX-26-13: Deconstructing Memory into Sovereign Primitives.
+ */
+export declare function settleInteractionProposals(params: InteractionSettlementParams): Promise<InteractionSettlementResult>;
+/**
+ * @deprecated Use `settleInteractionProposals` instead. RFC VX-26-13.
+ */
+export declare const settleMemoryProposals: typeof settleInteractionProposals;