@sidurijs/core 1.0.0 → 1.0.2

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/adversarial.test.js

@@ -53,38 +53,43 @@ describe('Adversarial Hardening Verification Suite (Phase 3)', () => {
                 validFrom: pastTime,
                 validUntil: futureTime,
             };
-            const mockMemory = {
+            const mockArchive = {
                 initialize: jest.fn().mockResolvedValue(undefined),
-                searchClaims: jest.fn().mockResolvedValue([validClaim]),
-                getDirectives: jest.fn().mockResolvedValue([]),
+                searchEvents: jest.fn().mockResolvedValue([{
+                        id: 'evt-valid',
+                        companionId: 'companion-adv',
+                        sourceType: 'User',
+                        occurredAt: new Date().toISOString(),
+                        payload: 'favoriteColor Azure',
+                    }]),
             };
             const runtime = new index_1.SiduriRuntime('companion-adv', { name: 'AdvCompanion' }, {
                 brain: mockBrain,
-                memory: mockMemory,
+                archive: mockArchive,
             });
             await runtime.handleUserMessage('What is my favorite color?', baseOwnerContext);
-            expect(mockMemory.searchClaims).toHaveBeenCalled();
+            expect(mockArchive.searchEvents).toHaveBeenCalled();
             const brainCall = mockBrain.generatePlan.mock.calls[0][0];
-            expect(brainCall.contextPrompt).toContain('User favoriteColor Azure');
+            expect(brainCall.contextPrompt).toContain('ARCHIVE:');
+            expect(brainCall.contextPrompt).toContain('favoriteColor Azure');
         });
         test('companion isolation: runtime passes only companionId matching context', async () => {
             const mockBrain = {
                 generatePlan: jest.fn().mockResolvedValue({ speech: 'OK', language: 'en' }),
             };
-            const mockMemory = {
+            const mockArchive = {
                 initialize: jest.fn().mockResolvedValue(undefined),
-                searchClaims: jest.fn().mockResolvedValue([]),
-                getDirectives: jest.fn().mockResolvedValue([]),
+                searchEvents: jest.fn().mockResolvedValue([]),
             };
             const runtime = new index_1.SiduriRuntime('companion-A', { name: 'AdvA' }, {
                 brain: mockBrain,
-                memory: mockMemory,
+                archive: mockArchive,
             });
             await runtime.handleUserMessage('Query', {
                 ...baseOwnerContext,
                 companionId: 'companion-A',
             });
-            expect(mockMemory.searchClaims).toHaveBeenCalledWith('Query', expect.objectContaining({ limit: 5 }), 5);
+            expect(mockArchive.searchEvents).toHaveBeenCalledWith('companion-A', 'Query', 5);
         });
     });
     // INVARIANT 2: Authority & Request Boundary
@@ -349,27 +354,30 @@ describe('Adversarial Hardening Verification Suite (Phase 3)', () => {
     });
     // INVARIANT 6: Failure Semantics & Degradation
     describe('Invariant 6: Subsystem Failure Diagnostics & Non-Empty Propagation', () => {
-        test('database/memory query failure surfaces diagnostic in contextPrompt and metadata', async () => {
+        test('archive/self query failure surfaces diagnostic in contextPrompt and metadata', async () => {
             const mockBrain = {
                 generatePlan: jest.fn().mockResolvedValue({ speech: 'Graceful fallback response', language: 'en' }),
             };
-            const failingMemory = {
+            const failingArchive = {
                 initialize: jest.fn().mockResolvedValue(undefined),
-                searchClaims: jest.fn().mockRejectedValue(new Error('Connection terminated unexpectedly')),
-                getDirectives: jest.fn().mockRejectedValue(new Error('Database read timeout')),
+                searchEvents: jest.fn().mockRejectedValue(new Error('Connection terminated unexpectedly')),
+            };
+            const failingSelf = {
+                getActiveDirectives: jest.fn().mockRejectedValue(new Error('Database read timeout')),
             };
             const runtime = new index_1.SiduriRuntime('companion-adv', { name: 'AdvCompanion' }, {
                 brain: mockBrain,
-                memory: failingMemory,
+                archive: failingArchive,
+                self: failingSelf,
             });
             const response = await runtime.handleUserMessage('Hello companion', baseOwnerContext);
             expect(response.status).toBe('APPROVED');
             expect(response.metadata.subsystem_diagnostics).toBeDefined();
-            expect(response.metadata.subsystem_diagnostics.memory_claims).toContain('UNAVAILABLE');
-            expect(response.metadata.subsystem_diagnostics.memory_directives).toContain('UNAVAILABLE');
+            expect(response.metadata.subsystem_diagnostics.archive).toContain('UNAVAILABLE');
+            expect(response.metadata.subsystem_diagnostics.self_directives).toContain('UNAVAILABLE');
             const brainCall = mockBrain.generatePlan.mock.calls[0][0];
             expect(brainCall.contextPrompt).toContain('SUBSYSTEM STATUS (DEGRADED):');
-            expect(brainCall.contextPrompt).toContain('memory_claims');
+            expect(brainCall.contextPrompt).toContain('archive');
         });
     });
     // INVARIANT 8: Truth Gate Admissibility vs Factuality

package/dist/chat-contract.d.ts

@@ -46,6 +46,15 @@ export interface ChatResponsePlan {
 export interface ChatResponseMetadata {
     language?: string;
     proposals?: Claim[];
+    claim_proposals?: Array<{
+        proposal_id: string;
+        subject?: string;
+        predicate?: string;
+        value?: string;
+        status: string;
+        content?: string;
+        claim_type?: string;
+    }>;
     memory_proposals?: Array<{
         proposal_id: string;
         subject?: string;

package/dist/cognition-planner.d.ts

@@ -1,11 +1,11 @@
-import { BrainOrgan, Message, ResponsePlan, MemoryScope } from './index';
+import { BrainOrgan, Message, ResponsePlan, ClaimScope } from './index';
 export interface CognitionPlanningParams {
     companionName: string;
     brain?: BrainOrgan;
     systemPrompt: string;
     contextPrompt: string;
     recentMessages: Message[];
-    recipient?: MemoryScope;
+    recipient?: ClaimScope;
     perceivedText: string;
 }
 /**

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, EKnowledgeOrgan } from './index';
 export interface ContextRetrievalParams {
     companionId: string;
     perceivedText: string;
@@ -7,16 +7,17 @@ export interface ContextRetrievalParams {
     isContextObject: boolean;
     shouldQueryKnowledge: boolean;
     knowledgeQueries?: string[];
-    memoryQueries?: string[];
+    archiveQueries?: string[];
     isSelfIdentityRequest?: boolean;
     knowledge?: KnowledgeOrgan | LifeDatabase;
-    memory?: MemoryOrgan | EpisodicMemoryStore;
+    archive?: ArchiveLedger;
+    memory?: any;
     self?: SelfRepository;
     externalKnowledge?: EKnowledgeOrgan | KnowledgeOrgan;
 }
 export interface RetrievedContext {
     knowledgeData: KnowledgeItem[];
-    memoryData: Claim[];
+    archiveData: Claim[];
     activeDirectives: BehaviorDirective[];
     subsystemDiagnostics: Record<string, string>;
     collectedEvidence: EvidenceRecord[];

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, archiveQueries, isSelfIdentityRequest, knowledge, archive, memory, self, externalKnowledge, } = params;
     const queryOptions = isContextObject
         ? {
             limit: 5,
@@ -31,11 +31,11 @@ async function retrieveRuntimeContext(params) {
         queryCandidateSet.add(perceivedText.trim());
     }
     const finalKnowledgeQueries = Array.from(queryCandidateSet);
-    const memoryQueryToRun = (memoryQueries && memoryQueries.length > 0 && memoryQueries[0])
-        ? memoryQueries[0]
+    const archiveQueryToRun = (archiveQueries && archiveQueries.length > 0 && archiveQueries[0])
+        ? archiveQueries[0]
         : (0, intent_classifier_1.extractSearchKeywords)(perceivedText, companionId)[0] || perceivedText;
     // 2. Query streams in parallel
-    const [knowledgeData, memoryData, selfOrMemoryDirectives, lifeContext, selfIdentity, selfRelationship, personality,] = await Promise.all([
+    const [knowledgeData, archiveData, selfDirectives, lifeContext, selfIdentity, selfRelationship, personality,] = await Promise.all([
         // Stream A: External Cited Lore / Documentation
         extKnowledge && shouldQueryKnowledge && typeof extKnowledge.search === 'function'
             ? Promise.all(finalKnowledgeQueries.map((q) => extKnowledge.search(q).catch((e) => {
@@ -46,10 +46,8 @@ async function retrieveRuntimeContext(params) {
                 const merged = [];
                 const seen = new Set();
                 for (const list of resultsArray) {
-                    if (!Array.isArray(list))
-                        continue;
                     for (const item of list) {
-                        const key = item.id || item.content || item.text || JSON.stringify(item.citations);
+                        const key = item.content.slice(0, 100);
                         if (!seen.has(key)) {
                             seen.add(key);
                             merged.push(item);
@@ -59,12 +57,11 @@ async function retrieveRuntimeContext(params) {
                 return merged;
             })
             : Promise.resolve([]),
-        // Stream B: Episodic Memory / Verified Claims (SQLite FTS5 with Identity Fallback)
+        // Stream B: Interaction Archive / Claims
         memory && typeof memory.searchClaims === 'function'
             ? (async () => {
                 try {
-                    // Support both (companionId, query, limit) and (query, options, limit)
-                    let result = await memory.searchClaims(memoryQueryToRun, queryOptions, 5);
+                    let result = await memory.searchClaims(archiveQueryToRun, queryOptions, 5);
                     if ((!result || result.length === 0) && isSelfIdentityRequest) {
                         if (typeof memory.getApprovedClaims === 'function') {
                             const approved = await memory.getApprovedClaims(companionId, 10);
@@ -93,7 +90,28 @@ async function retrieveRuntimeContext(params) {
                     return [];
                 }
             })()
-            : Promise.resolve([]),
+            : archive && typeof archive.searchEvents === 'function'
+                ? (async () => {
+                    try {
+                        const events = await archive.searchEvents(companionId, archiveQueryToRun, 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) => {
@@ -135,7 +153,7 @@ async function retrieveRuntimeContext(params) {
             ? self.getPersonality(companionId).catch(() => undefined)
             : Promise.resolve(undefined),
     ]);
-    const activeDirectives = (selfOrMemoryDirectives || []);
+    const activeDirectives = (selfDirectives || []);
     // Build evidence records from retrieved context streams
     const collectedEvidence = [];
     const citations = [];
@@ -187,19 +205,19 @@ async function retrieveRuntimeContext(params) {
             }
         }
     }
-    // Stream B: Episodic Memory Claims
-    if (memoryData.length > 0) {
-        for (const m of memoryData) {
-            const claimId = m.claim_id || m.id || `claim-${Date.now()}`;
-            const sourceId = m.provenance || 'sqlite-memory';
-            const evId = `ev-mem-${claimId}`;
-            const claimPreview = m.content || `${m.subject || 'user'} ${m.predicate || 'claims'}: ${m.value || ''}`;
+    // Stream B: Interaction Archive
+    if (archiveData.length > 0) {
+        for (const m of archiveData) {
+            const claimId = m.claim_id || m.id || `evt-${Date.now()}`;
+            const sourceId = m.provenance || 'archive_ledger';
+            const evId = `ev-arc-${claimId}`;
+            const claimPreview = m.content || `${m.subject || 'event'} ${m.predicate || 'event'}: ${m.value || ''}`;
             collectedEvidence.push({
                 evidenceId: evId,
                 sourceId,
                 documentId: claimId,
-                chunkId: `${m.subject || 'user'}:${m.predicate || 'claim'}`,
-                origin: 'memory',
+                chunkId: `${m.subject || 'archive'}:${m.predicate || 'event'}`,
+                origin: 'archive',
                 trust: 'configured',
                 sensitivity: 'private',
                 companionId,
@@ -208,11 +226,11 @@ async function retrieveRuntimeContext(params) {
             });
             citations.push({
                 evidenceId: evId,
-                provenance: 'memory',
+                provenance: 'archive',
                 sourceId,
                 documentId: claimId,
-                chunkId: `${m.subject || 'user'}.${m.predicate || 'claim'}`,
-                locator: `claim:${claimId}`,
+                chunkId: `${m.subject || 'archive'}.${m.predicate || 'event'}`,
+                locator: `archive:${claimId}`,
                 preview: claimPreview.slice(0, 300),
             });
         }
@@ -247,7 +265,7 @@ async function retrieveRuntimeContext(params) {
     }
     return {
         knowledgeData,
-        memoryData,
+        archiveData,
         activeDirectives,
         subsystemDiagnostics,
         collectedEvidence,