cogmem 3.6.2

package/dist/topic/TopicRelationGraph.js

@@ -0,0 +1,55 @@
+import { randomUUID } from 'node:crypto';
+export class TopicRelationGraph {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    add(input) {
+        this.assertTopic(input.sourceTopicId, input.projectId);
+        this.assertTopic(input.targetTopicId, input.projectId);
+        if (!/^[A-Z][A-Z0-9_]{1,63}$/.test(input.relation))
+            throw new Error(`invalid_topic_relation:${input.relation}`);
+        const relationId = `topic-relation-${randomUUID()}`;
+        const now = input.now ?? Date.now();
+        const status = input.createdBy === 'model_candidate' ? 'candidate' : 'active';
+        this.db.prepare(`
+      INSERT INTO topic_relations (relation_id, project_id, source_topic_id, relation, target_topic_id, status,
+        created_by, confidence, evidence_event_ids_json, evidence_episode_ids_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(relationId, input.projectId, input.sourceTopicId, input.relation, input.targetTopicId, status, input.createdBy, Math.max(0, Math.min(1, input.confidence ?? 1)), JSON.stringify(input.evidenceEventIds || []), JSON.stringify(input.evidenceEpisodeIds || []), now, now);
+        return this.get(relationId);
+    }
+    get(relationId) {
+        const row = this.db.prepare(`SELECT * FROM topic_relations WHERE relation_id = ?`).get(relationId);
+        return row ? mapRelation(row) : undefined;
+    }
+    archive(relationId, projectId, now = Date.now()) {
+        this.db.prepare(`UPDATE topic_relations SET status = 'archived', updated_at = ? WHERE relation_id = ? AND project_id = ?`)
+            .run(now, relationId, projectId);
+    }
+    setStatus(relationId, projectId, status, now = Date.now()) {
+        const relation = this.get(relationId);
+        if (!relation)
+            throw new Error(`topic_relation_not_found:${relationId}`);
+        if (relation.projectId !== projectId)
+            throw new Error(`topic_relation_project_mismatch:${relationId}`);
+        this.db.prepare(`UPDATE topic_relations SET status = ?, updated_at = ? WHERE relation_id = ? AND project_id = ?`)
+            .run(status, now, relationId, projectId);
+    }
+    list(projectId) {
+        return this.db.prepare(`SELECT * FROM topic_relations WHERE project_id = ? ORDER BY created_at`).all(projectId).map(mapRelation);
+    }
+    assertTopic(topicId, projectId) {
+        const row = this.db.prepare(`SELECT project_id FROM topic_nodes WHERE topic_id = ?`).get(topicId);
+        if (!row)
+            throw new Error(`topic_not_found:${topicId}`);
+        if (row.project_id !== projectId)
+            throw new Error(`topic_project_mismatch:${topicId}`);
+    }
+}
+function mapRelation(row) {
+    return { relationId: row.relation_id, projectId: row.project_id, sourceTopicId: row.source_topic_id,
+        relation: row.relation, targetTopicId: row.target_topic_id, status: row.status, createdBy: row.created_by,
+        confidence: row.confidence, evidenceEventIds: JSON.parse(row.evidence_event_ids_json),
+        evidenceEpisodeIds: JSON.parse(row.evidence_episode_ids_json), createdAt: row.created_at, updatedAt: row.updated_at };
+}

package/dist/topic/TopicTypes.d.ts

@@ -0,0 +1,73 @@
+import type { MemoryOntologyClass } from '../ontology/MemoryOntology.js';
+export type TopicStatus = 'candidate' | 'active' | 'merged' | 'archived' | 'needs_review';
+export type TopicCreatedBy = 'user_explicit' | 'model_candidate' | 'import' | 'repair';
+export type TopicOperationType = 'USER_DEFINED_TOPIC_CREATE' | 'USER_DEFINED_TOPIC_RENAME' | 'USER_DEFINED_TOPIC_ALIAS' | 'USER_DEFINED_TOPIC_MOVE' | 'USER_DEFINED_TOPIC_MERGE' | 'USER_DEFINED_TOPIC_SPLIT' | 'USER_DEFINED_TOPIC_REASSIGN' | 'USER_DEFINED_TOPIC_RELATION_ADD' | 'USER_DEFINED_TOPIC_RELATION_REMOVE' | 'MODEL_PROPOSED_TOPIC' | 'MODEL_PROPOSED_TOPIC_ALIAS' | 'MODEL_PROPOSED_TOPIC_RELATION' | 'SYSTEM_REPAIR_TOPIC';
+export interface TopicNode {
+    topicId: string;
+    projectId: string;
+    topicPath: string;
+    canonicalName: string;
+    aliases: string[];
+    parentTopicId?: string;
+    ontologyClass: MemoryOntologyClass;
+    status: TopicStatus;
+    createdBy: TopicCreatedBy;
+    confidence: number;
+    evidenceEventIds: string[];
+    evidenceEpisodeIds: string[];
+    lastUsedAt: number;
+    mergeCandidates?: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TopicOperationInput {
+    projectId: string;
+    operationType: TopicOperationType;
+    actor: TopicCreatedBy;
+    targetTopicId?: string;
+    payload: Record<string, unknown>;
+    evidenceEventIds?: string[];
+    now?: number;
+}
+export interface TopicOperationRecord {
+    operationId: string;
+    projectId: string;
+    operationType: TopicOperationType;
+    actor: TopicCreatedBy;
+    targetTopicId?: string;
+    payload: Record<string, unknown>;
+    before?: unknown;
+    after?: unknown;
+    status: 'applied' | 'reverted' | 'needs_review' | 'rejected';
+    evidenceEventIds: string[];
+    createdAt: number;
+    revertedAt?: number;
+}
+export interface TopicAliasRecord {
+    aliasId: string;
+    projectId: string;
+    topicId: string;
+    alias: string;
+    normalizedAlias: string;
+    status: 'candidate' | 'active' | 'needs_review' | 'archived';
+    createdBy: TopicCreatedBy;
+    confidence: number;
+    evidenceEventIds: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TopicRelationRecord {
+    relationId: string;
+    projectId: string;
+    sourceTopicId: string;
+    relation: string;
+    targetTopicId: string;
+    status: 'candidate' | 'active' | 'archived' | 'needs_review';
+    createdBy: TopicCreatedBy;
+    confidence: number;
+    evidenceEventIds: string[];
+    evidenceEpisodeIds: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+//# sourceMappingURL=TopicTypes.d.ts.map

package/dist/topic/TopicTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/topic/index.d.ts

@@ -0,0 +1,6 @@
+export * from './TopicTypes.js';
+export * from './TopicPathRegistry.js';
+export * from './TopicAliasRegistry.js';
+export * from './TopicRelationGraph.js';
+export * from './TopicGovernance.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/topic/index.js

@@ -0,0 +1,5 @@
+export * from './TopicTypes.js';
+export * from './TopicPathRegistry.js';
+export * from './TopicAliasRegistry.js';
+export * from './TopicRelationGraph.js';
+export * from './TopicGovernance.js';

package/dist/types/AsyncEnrichment.d.ts

@@ -0,0 +1,62 @@
+import type { BeliefCandidate, Neuron } from './index.js';
+import type { ConsolidationResult } from '../engine/ConsolidationPipeline.js';
+import type { EntityRecord } from '../store/EntityStore.js';
+import type { FactRecord } from '../store/FactStore.js';
+export interface AsyncEnrichmentTrigger {
+    kind: 'ingest_compiled_fact_count_zero' | 'self_correction_pattern' | 'multi_candidate_single_fact' | 'unseen_entity_binding_suspect' | 'low_compiler_confidence';
+    detail: string;
+}
+export interface AsyncEnrichmentCompilerOutput {
+    facts: ConsolidationResult['compiledFacts'];
+    events: ConsolidationResult['compiledEvents'];
+    entityIds: string[];
+}
+export interface AsyncEnrichmentEntityBinding {
+    compiledEntityIds: string[];
+    compiledEntities: EntityRecord[];
+    suspicious: boolean;
+    reasons: string[];
+}
+export interface AsyncEnrichmentContextSnapshot {
+    recentEntities: EntityRecord[];
+    recentFacts: FactRecord[];
+    recentPreferenceFacts: FactRecord[];
+}
+export interface AsyncEnrichmentWriteback {
+    entities?: Array<{
+        canonicalName: string;
+        type: string;
+        aliases?: string[];
+        metadata?: Record<string, unknown>;
+        instanceMode?: 'auto' | 'canonical' | 'new_instance';
+    }>;
+    facts?: Array<Omit<FactRecord, 'factId'> & {
+        metadata?: Record<string, unknown>;
+    }>;
+    beliefs?: BeliefCandidate[];
+}
+export interface AsyncEnrichmentHookInput {
+    runId: string;
+    neuron: Neuron;
+    sourceEventId: string;
+    triggers: AsyncEnrichmentTrigger[];
+    consolidation: ConsolidationResult;
+    compilerOutput: AsyncEnrichmentCompilerOutput;
+    entityBinding: AsyncEnrichmentEntityBinding;
+    recentContext: AsyncEnrichmentContextSnapshot;
+}
+export interface AsyncEnrichmentWritebackContext {
+    persist(result: AsyncEnrichmentWriteback): {
+        entities: EntityRecord[];
+        facts: FactRecord[];
+        beliefIds: string[];
+    };
+}
+export interface AsyncEnrichmentHook {
+    enrich(input: AsyncEnrichmentHookInput, context: AsyncEnrichmentWritebackContext): Promise<AsyncEnrichmentWriteback | void> | AsyncEnrichmentWriteback | void;
+}
+export declare class NoopAsyncEnrichmentHook implements AsyncEnrichmentHook {
+    enrich(): void;
+}
+export declare function createAsyncEnrichmentRunId(): string;
+//# sourceMappingURL=AsyncEnrichment.d.ts.map

package/dist/types/AsyncEnrichment.js

@@ -0,0 +1,7 @@
+import { randomUUID } from 'crypto';
+export class NoopAsyncEnrichmentHook {
+    enrich() { }
+}
+export function createAsyncEnrichmentRunId() {
+    return `async-enrich-${Date.now()}-${randomUUID()}`;
+}

package/dist/types/BrainRecallResult.d.ts

@@ -0,0 +1,66 @@
+import type { BeliefRecord, Neuron } from './index.js';
+import type { EntityTimelineItem } from '../store/EntityStore.js';
+import type { EventRecord, FactRecord } from '../store/FactStore.js';
+import type { FileEvidence } from '../assets/index.js';
+import type { SkillCandidateLike } from './ExtensionPoints.js';
+export interface BrainRecallResult {
+    query: string;
+    strategy: {
+        primaryLevel: 'compiled_memory' | 'raw_evidence' | 'recent_unprocessed_sources';
+        fallbackUsed: boolean;
+        vectorSearchUsed?: boolean;
+    };
+    compiledMemory: {
+        beliefs: BeliefRecord[];
+        facts: FactRecord[];
+        events: EventRecord[];
+        entityTimeline: EntityTimelineItem[];
+    };
+    rawEvidence: Neuron[];
+    fallbackSnippets: Array<{
+        sourceId: string;
+        sourcePath: string;
+        text: string;
+        timestamp: number;
+        sourceType: 'conversation_markdown' | 'soul_markdown' | 'hermes_state_db' | 'openclaw_daily_memory' | 'openclaw_session' | 'openclaw_memory_index' | 'openclaw_user_profile' | 'openclaw_persona';
+    }>;
+    profileSignals: Array<{
+        neuronId: string;
+        sourcePath?: string;
+        text: string;
+        tags: string[];
+        namespace: 'user_profile' | 'agent_persona';
+    }>;
+    profileSurface: {
+        userProfile: Array<{
+            neuronId: string;
+            sourcePath?: string;
+            label: string;
+            value: string;
+            section?: string;
+        }>;
+        agentPersona: Array<{
+            neuronId: string;
+            sourcePath?: string;
+            label: string;
+            value: string;
+            section?: string;
+        }>;
+    };
+    summaries?: Array<{
+        summaryId: string;
+        text: string;
+        scope: string;
+        windowStart?: number;
+        windowEnd?: number;
+        confidence: number;
+    }>;
+    fileEvidence?: FileEvidence[];
+    skillCandidates?: SkillCandidateLike[];
+    topicRouteInfo?: {
+        matchedTopicPath: string | null;
+        confidence: number;
+        fallbackToGlobal: boolean;
+    };
+}
+//# sourceMappingURL=BrainRecallResult.d.ts.map

package/dist/types/BrainRecallResult.js

@@ -0,0 +1 @@
+export {};

package/dist/types/ExtensionPoints.d.ts

@@ -0,0 +1,116 @@
+import type { BrainRecallResult } from './BrainRecallResult.js';
+import type { Neuron } from './index.js';
+export interface ILLMClarifier {
+    clarify(prompt: string, evidence: BrainRecallResult): Promise<{
+        finalAnswer: string;
+    } | string>;
+}
+export interface SkillCandidateLike {
+    skillId: string;
+    skillVersion?: string;
+    description: string;
+    intentTags?: string[];
+    successRate?: number;
+    executionCount?: number;
+    lastExecutedAt?: number;
+    relevanceScore?: number;
+    confidence?: number;
+}
+export interface ISkillDiscovery {
+    findCandidates(query: string, projectId?: string, topK?: number): SkillCandidateLike[];
+}
+export interface ISkillMemoryStore {
+    recordExecution(skillId: string, success: boolean, failureReason?: string): void;
+    listAll(): Neuron[];
+    getExecutionStatsForTags?(tags: string[], options?: {
+        projectId?: string;
+        before?: number;
+        after?: number;
+    }): Record<string, {
+        samples: number;
+        successRate: number;
+    }>;
+}
+export interface IAuditLedger {
+    getPendingVerificationEntries(projectId: string): Array<{
+        proposalId: string;
+        projectId: string;
+        skillId: string;
+        predictedImpact: unknown;
+    }>;
+    updateVerificationResult(proposalId: string, result: unknown): void;
+    predictionStats?(intentTag: string): {
+        accuracy: number;
+        verifiedCount?: number;
+        total?: number;
+        verified?: number;
+    };
+}
+export interface IProceduralBridge {
+    scan(projectId: string): Promise<unknown> | unknown;
+}
+export interface AutonomyContext {
+    readonly taskId?: string;
+    readonly workspaceId?: string;
+    readonly authorityId?: string;
+    readonly autonomyMode?: 'observe' | 'safe_edit' | 'autonomous_local' | 'supervised';
+}
+export interface ChatSessionLike {
+    getRecentTurns(limit?: number): Array<{
+        role: 'user' | 'assistant';
+        content: string;
+        timestamp: number;
+    }>;
+    getRelevantTurns?(input: {
+        query: string;
+        projectId?: string;
+        maxChars?: number;
+    }): Array<{
+        role: 'user' | 'assistant';
+        content: string;
+        timestamp: number;
+    }>;
+    getContextForLLM?(): string;
+}
+export interface QueryManagerLike {
+    query(input: unknown): Promise<unknown> | unknown;
+}
+export interface ManagerRegistryLike {
+    dispatch(intent: string, params?: Record<string, unknown>): Promise<unknown> | unknown;
+}
+export interface RuntimeSelfManifestLike {
+    manifestId: string;
+    generatedAt: number;
+    capabilities: unknown[];
+    models: {
+        roles: unknown[];
+    };
+    fileAssets: {
+        indexedAssetCount: number;
+    };
+    constraints: Array<{
+        id: string;
+    }>;
+}
+export interface GraphEdgeRecordLike {
+    fromNodeId?: string;
+    toNodeId?: string;
+    edgeRecordId?: string;
+    sourceNeuronId?: string;
+    targetNeuronId?: string;
+    fromNeuronId?: string;
+    toNeuronId?: string;
+    relation?: string;
+    relationType?: string;
+    weight?: number;
+    status?: string;
+}
+export interface GraphEdgeStoreLike {
+    list?(options?: unknown): GraphEdgeRecordLike[];
+    listActiveNeighborEdges?(entityIds: string[], edgeTypes?: string[], limit?: number): GraphEdgeRecordLike[];
+    appendEdge?(input: unknown): GraphEdgeRecordLike;
+}
+export interface ProposalLedgerLike {
+    append?(items: unknown[]): void;
+}
+//# sourceMappingURL=ExtensionPoints.d.ts.map

package/dist/types/ExtensionPoints.js

@@ -0,0 +1 @@
+export {};

package/dist/types/Migration.d.ts

@@ -0,0 +1,22 @@
+import type Database from 'bun:sqlite';
+export interface Migration {
+    version: string;
+    description: string;
+    up(db: Database): void;
+    down(db: Database): void;
+}
+export interface MigrationRecord {
+    version: string;
+    appliedAt: string;
+    description: string;
+}
+export interface BackupRecord {
+    backupId: string;
+    label?: string;
+    createdAt: string;
+    schemaVersion: string;
+    dbPath: string;
+    backupPath: string;
+    configPath?: string;
+}
+//# sourceMappingURL=Migration.d.ts.map

package/dist/types/Migration.js

@@ -0,0 +1 @@
+export {};

package/dist/types/QueryTimePendingEntityResolution.d.ts

@@ -0,0 +1,11 @@
+import type { QueryTimePendingEntityResolverOutput, QueryTimePendingEntityResolverInput } from '../retrieval/QueryTimePendingEntityResolver.js';
+export interface QueryTimePendingEntityResolutionHookOutput extends QueryTimePendingEntityResolverOutput {
+    hookRan: boolean;
+}
+export interface QueryTimePendingEntityResolutionHook {
+    resolve(input: QueryTimePendingEntityResolverInput): QueryTimePendingEntityResolutionHookOutput;
+}
+export declare class NoopQueryTimePendingEntityResolutionHook implements QueryTimePendingEntityResolutionHook {
+    resolve(): QueryTimePendingEntityResolutionHookOutput;
+}
+//# sourceMappingURL=QueryTimePendingEntityResolution.d.ts.map

package/dist/types/QueryTimePendingEntityResolution.js

@@ -0,0 +1,23 @@
+export class NoopQueryTimePendingEntityResolutionHook {
+    resolve() {
+        return {
+            hookRan: false,
+            overallStatus: 'not_applicable',
+            overallReason: 'no_relative_pending_reference_in_query',
+            resolvedEntityIds: [],
+            candidateEntityIds: [],
+            candidateNeuronIds: [],
+            results: [],
+            pendingCaptureMetrics: {
+                pending_record_emitted_count: 0,
+                pending_record_expected_but_missing_count: 0,
+                pending_candidate_set_nonempty_count: 0,
+                pending_candidate_set_empty_count: 0,
+                referential_signal_preserved_count: 0,
+                referential_signal_lost_count: 0,
+                query_time_not_needed_due_to_write_time_sufficient_count: 0,
+                query_time_not_needed_due_to_missing_pending_capture_count: 0
+            }
+        };
+    }
+}