cogmem 3.6.2

package/dist/adapters/hermes/HermesStateDbAdapter.js

@@ -0,0 +1,268 @@
+import Database from 'bun:sqlite';
+import { pathToFileURL } from 'node:url';
+import { computeStableHash, parseLooseTimestamp } from '../types.js';
+const TEXT_COLUMNS = [
+    'content',
+    'text',
+    'message',
+    'body',
+    'message_text',
+    'raw',
+    'payload',
+];
+const ROLE_COLUMNS = ['role', 'sender_role', 'sender', 'author', 'speaker', 'type'];
+const SESSION_COLUMNS = ['session_id', 'sessionId', 'conversation_id', 'conversationId', 'thread_id', 'threadId', 'chat_id', 'chatId'];
+const MESSAGE_ID_COLUMNS = ['id', 'message_id', 'messageId', 'uuid'];
+const MESSAGE_TIME_COLUMNS = [
+    'occurredAt',
+    'occurred_at',
+    'timestamp',
+    'createdAt',
+    'created_at',
+    'sentAt',
+    'sent_at',
+    'time',
+];
+const INSERT_TIME_COLUMNS = ['InsertTime', 'insertTime', 'insert_time', 'imported_at', 'importedAt'];
+export class HermesStateDbAdapter {
+    kind = 'hermes_state_db';
+    adapterVersion = 'hermes-state-db-v1';
+    adapt(source, snapshot, window) {
+        const diagnostics = [];
+        const records = [];
+        let db;
+        try {
+            db = openReadonlySqlite(source.sourcePath);
+            if (!hasTable(db, 'messages')) {
+                diagnostics.push(this.diagnostic(source, 'error', 'hermes_state_db_missing_messages_table', 'Hermes state database does not contain a messages table.'));
+                return this.result(source, snapshot, records, diagnostics);
+            }
+            const columns = tableColumns(db, 'messages');
+            const rows = db.prepare(`SELECT rowid AS __rowid, * FROM ${quoteIdentifier('messages')}`).all();
+            const mapped = rows
+                .map((row, index) => this.toRecord(source, snapshot, row, columns, index, diagnostics))
+                .filter((record) => Boolean(record))
+                .filter((record) => !window || (record.timestamp >= window.start && record.timestamp < window.end))
+                .sort((a, b) => a.timestamp - b.timestamp || numericMetadata(a, 'sourceOffset') - numericMetadata(b, 'sourceOffset'));
+            records.push(...mapped);
+        }
+        catch (error) {
+            diagnostics.push(this.diagnostic(source, 'error', 'hermes_state_db_read_failed', `Failed to read Hermes state database: ${error instanceof Error ? error.message : String(error)}`));
+        }
+        finally {
+            db?.close();
+        }
+        return this.result(source, snapshot, records, diagnostics);
+    }
+    toRecord(source, snapshot, row, columns, index, diagnostics) {
+        const text = pickText(row, TEXT_COLUMNS);
+        if (!text)
+            return undefined;
+        const rowId = typeof row.__rowid === 'number' ? row.__rowid : index + 1;
+        const role = normalizeRole(pickText(row, ROLE_COLUMNS));
+        const sessionId = pickText(row, SESSION_COLUMNS) || `hermes-state-db-${computeStableHash([source.sourcePath]).slice(0, 10)}`;
+        const messageId = pickText(row, MESSAGE_ID_COLUMNS) || String(rowId);
+        const timeSource = pickTimestampSource(row);
+        const timestamp = parseTimestampValue(timeSource.value, snapshot.fileMtimeMs + index);
+        const sourceOffset = index + 1;
+        const recordHash = computeStableHash([
+            source.sourceId,
+            sessionId,
+            messageId,
+            timestamp,
+            role,
+            text,
+        ]);
+        if (timeSource.kind === 'insert_time_fallback') {
+            diagnostics.push(this.diagnostic(source, 'warning', 'hermes_state_db_insert_time_fallback', `Message ${messageId} did not expose occurredAt/timestamp; using InsertTime/import time fallback.`));
+        }
+        return {
+            recordId: `hermesmsg-${recordHash.slice(0, 16)}`,
+            turnId: computeStableHash([source.sourceId, sessionId, 'turn', rowId]),
+            kind: 'conversation_message',
+            role,
+            text,
+            timestamp,
+            tags: ['hermes', 'state_db', 'conversation'],
+            confidenceHint: 0.92,
+            sourceTypeHint: role === 'agent' ? 'llm_inference' : role === 'user' ? 'user_input' : 'external_tool',
+            metadata: {
+                hermesStateDbTable: 'messages',
+                hermesStateDbRowId: rowId,
+                hermesStateDbMessageId: messageId,
+                hermesStateDbColumns: columns,
+                timestampSource: timeSource.column,
+                threadId: sessionId,
+                sessionId,
+                sourceOffset,
+                threadSeq: sourceOffset,
+                turnSeq: sourceOffset,
+                eventOrdinal: 1,
+                orderingConfidence: 'high',
+            },
+            provenance: {
+                sourceId: source.sourceId,
+                sourcePath: source.sourcePath,
+                sourceType: this.kind,
+                adapterVersion: this.adapterVersion,
+                fileHash: snapshot.fileHash,
+                fileMtimeMs: snapshot.fileMtimeMs,
+                recordHash,
+                reliabilityClass: 'raw_utterance',
+                sourceOffset,
+                orderingConfidence: 'high',
+            },
+        };
+    }
+    result(source, snapshot, records, diagnostics) {
+        return {
+            source,
+            snapshot: {
+                sourceId: snapshot.sourceId,
+                adapterKind: snapshot.adapterKind,
+                sourcePath: snapshot.sourcePath,
+                projectId: snapshot.projectId,
+                fileHash: snapshot.fileHash,
+                fileMtimeMs: snapshot.fileMtimeMs,
+                fileSize: snapshot.fileSize,
+                readAt: snapshot.readAt,
+            },
+            records,
+            diagnostics,
+        };
+    }
+    diagnostic(source, severity, code, message) {
+        return {
+            severity,
+            code,
+            message,
+            filePath: source.sourcePath,
+            adapterKind: this.kind,
+        };
+    }
+}
+function hasTable(db, tableName) {
+    const row = db.prepare(`
+    SELECT name
+    FROM sqlite_master
+    WHERE type = 'table' AND lower(name) = lower(?)
+    LIMIT 1
+  `).get(tableName);
+    return Boolean(row?.name);
+}
+function tableColumns(db, tableName) {
+    return db.prepare(`PRAGMA table_info(${quoteIdentifier(tableName)})`).all()
+        .map((row) => row.name);
+}
+function quoteIdentifier(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+function pickText(row, columns) {
+    const lowerMap = new Map(Object.keys(row).map((key) => [key.toLowerCase(), key]));
+    for (const column of columns) {
+        const actual = lowerMap.get(column.toLowerCase());
+        if (!actual)
+            continue;
+        const text = textFromValue(row[actual]);
+        if (text)
+            return text;
+    }
+    return undefined;
+}
+function textFromValue(value) {
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return undefined;
+        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                const nested = textFromStructuredValue(parsed);
+                if (nested)
+                    return nested;
+            }
+            catch {
+                return trimmed;
+            }
+        }
+        return trimmed;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return textFromStructuredValue(value);
+}
+function textFromStructuredValue(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    for (const key of TEXT_COLUMNS) {
+        const nested = textFromValue(record[key]);
+        if (nested)
+            return nested;
+    }
+    return undefined;
+}
+function normalizeRole(value) {
+    const normalized = (value || '').trim().toLowerCase();
+    if (['assistant', 'agent', 'ai', 'bot', 'model'].includes(normalized))
+        return 'agent';
+    if (['system', 'sys', 'tool'].includes(normalized))
+        return 'system';
+    if (['narrator', 'note', 'memo'].includes(normalized))
+        return 'narrator';
+    return 'user';
+}
+function pickTimestampSource(row) {
+    const lowerMap = new Map(Object.keys(row).map((key) => [key.toLowerCase(), key]));
+    for (const column of MESSAGE_TIME_COLUMNS) {
+        const actual = lowerMap.get(column.toLowerCase());
+        if (!actual)
+            continue;
+        const value = textFromValue(row[actual]);
+        if (value)
+            return { value, column: actual, kind: 'message_time' };
+    }
+    for (const column of INSERT_TIME_COLUMNS) {
+        const actual = lowerMap.get(column.toLowerCase());
+        if (!actual)
+            continue;
+        const value = textFromValue(row[actual]);
+        if (value)
+            return { value, column: actual, kind: 'insert_time_fallback' };
+    }
+    return { kind: 'missing' };
+}
+function parseTimestampValue(value, fallback) {
+    if (!value)
+        return fallback;
+    const trimmed = value.trim();
+    if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+        const numeric = Number(trimmed);
+        return numeric < 10_000_000_000 ? numeric * 1000 : numeric;
+    }
+    return parseLooseTimestamp(trimmed, fallback);
+}
+function openReadonlySqlite(sourcePath) {
+    const attempts = [
+        sourcePath,
+        `${pathToFileURL(sourcePath).href}?immutable=1`,
+    ];
+    let lastError;
+    for (const attempt of attempts) {
+        let db;
+        try {
+            db = new Database(attempt, { readonly: true, create: false });
+            db.prepare(`SELECT name FROM sqlite_master LIMIT 1`).get();
+            return db;
+        }
+        catch (error) {
+            lastError = error;
+            db?.close();
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+function numericMetadata(record, key) {
+    const value = record.metadata?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}

package/dist/adapters/hermes/HermesWorkspaceProfile.d.ts

@@ -0,0 +1,15 @@
+import { type SourceDefinition } from '../types.js';
+export interface HermesWorkspaceSourceOptions {
+    projectId?: string;
+    sessionDir?: string;
+    sessionPaths?: string[];
+    profilePath?: string;
+    stateDbPath?: string;
+}
+export declare class HermesWorkspaceProfile {
+    readonly workspaceRoot: string;
+    constructor(workspaceRoot: string);
+    buildSourceDefinitions(options?: HermesWorkspaceSourceOptions): SourceDefinition[];
+    private relativePath;
+}
+//# sourceMappingURL=HermesWorkspaceProfile.d.ts.map

package/dist/adapters/hermes/HermesWorkspaceProfile.js

@@ -0,0 +1,82 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { basename, join, relative, resolve } from 'node:path';
+import { computeStableHash } from '../types.js';
+export class HermesWorkspaceProfile {
+    workspaceRoot;
+    constructor(workspaceRoot) {
+        this.workspaceRoot = resolve(workspaceRoot);
+    }
+    buildSourceDefinitions(options = {}) {
+        const projectId = options.projectId ?? basename(this.workspaceRoot);
+        const sources = [];
+        const profilePath = resolve(this.workspaceRoot, options.profilePath ?? 'profile.md');
+        const stateDbPath = resolve(this.workspaceRoot, options.stateDbPath ?? 'state.db');
+        if (existsSync(stateDbPath) && statSync(stateDbPath).isFile()) {
+            sources.push({
+                sourceId: `hermes-state-db-${computeStableHash([projectId, this.relativePath(stateDbPath)]).slice(0, 12)}`,
+                adapterKind: 'hermes_state_db',
+                sourcePath: stateDbPath,
+                projectId,
+                tags: ['hermes', 'state_db'],
+                metadata: {
+                    hermesWorkspaceRoot: this.workspaceRoot,
+                    hermesRelativePath: this.relativePath(stateDbPath),
+                    hermesSourceClass: 'state_db',
+                },
+            });
+        }
+        if (existsSync(profilePath) && statSync(profilePath).isFile()) {
+            sources.push({
+                sourceId: `hermes-profile-${computeStableHash([projectId, this.relativePath(profilePath)]).slice(0, 12)}`,
+                adapterKind: 'soul_markdown',
+                sourcePath: profilePath,
+                projectId,
+                tags: ['hermes', 'profile'],
+                metadata: {
+                    hermesWorkspaceRoot: this.workspaceRoot,
+                    hermesRelativePath: this.relativePath(profilePath),
+                    hermesSourceClass: 'profile',
+                },
+            });
+        }
+        const sessionDir = resolve(this.workspaceRoot, options.sessionDir ?? 'sessions');
+        const sessionPaths = uniquePaths([
+            ...listMarkdownFiles(sessionDir),
+            ...(options.sessionPaths || []),
+        ]);
+        for (const sourcePath of sessionPaths) {
+            if (!existsSync(sourcePath) || !statSync(sourcePath).isFile())
+                continue;
+            sources.push({
+                sourceId: `hermes-session-${computeStableHash([projectId, this.relativePath(sourcePath)]).slice(0, 12)}`,
+                adapterKind: 'conversation_markdown',
+                sourcePath,
+                projectId,
+                tags: ['hermes', 'session'],
+                metadata: {
+                    hermesWorkspaceRoot: this.workspaceRoot,
+                    hermesRelativePath: this.relativePath(sourcePath),
+                    hermesSourceClass: 'session',
+                },
+            });
+        }
+        return sources;
+    }
+    relativePath(filePath) {
+        return relative(this.workspaceRoot, filePath).replace(/\\/g, '/');
+    }
+}
+function uniquePaths(paths) {
+    return Array.from(new Set(paths.map((item) => resolve(item))));
+}
+function listMarkdownFiles(dir) {
+    if (!existsSync(dir))
+        return [];
+    const entries = readdirSync(dir).map((entry) => join(dir, entry));
+    return entries.flatMap((entry) => {
+        const stat = statSync(entry);
+        if (stat.isDirectory())
+            return listMarkdownFiles(entry);
+        return /\.(md|markdown)$/i.test(entry) ? [entry] : [];
+    });
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,15 @@
+export * from './types.js';
+export { MarkdownSourceLoader } from './MarkdownSourceLoader.js';
+export { ConversationMarkdownAdapter } from './conversation/ConversationMarkdownAdapter.js';
+export { SoulMarkdownAdapter } from './soul/SoulMarkdownAdapter.js';
+export { OpenClawDailyMemoryAdapter } from './openclaw/OpenClawDailyMemoryAdapter.js';
+export { OpenClawSessionAdapter } from './openclaw/OpenClawSessionAdapter.js';
+export { OpenClawMemoryIndexAdapter } from './openclaw/OpenClawMemoryIndexAdapter.js';
+export { OpenClawUserProfileAdapter } from './openclaw/OpenClawUserProfileAdapter.js';
+export { OpenClawPersonaAdapter } from './openclaw/OpenClawPersonaAdapter.js';
+export { OpenClawWorkspaceProfile } from './openclaw/OpenClawWorkspaceProfile.js';
+export type { OpenClawClassifiedPath, OpenClawWorkspaceSelection, OpenClawWorkspaceSelectionDiagnostic, OpenClawWorkspaceSourceOptions, } from './openclaw/OpenClawWorkspaceProfile.js';
+export { HermesStateDbAdapter } from './hermes/HermesStateDbAdapter.js';
+export { HermesWorkspaceProfile } from './hermes/HermesWorkspaceProfile.js';
+export type { HermesWorkspaceSourceOptions } from './hermes/HermesWorkspaceProfile.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/index.js

@@ -0,0 +1,12 @@
+export * from './types.js';
+export { MarkdownSourceLoader } from './MarkdownSourceLoader.js';
+export { ConversationMarkdownAdapter } from './conversation/ConversationMarkdownAdapter.js';
+export { SoulMarkdownAdapter } from './soul/SoulMarkdownAdapter.js';
+export { OpenClawDailyMemoryAdapter } from './openclaw/OpenClawDailyMemoryAdapter.js';
+export { OpenClawSessionAdapter } from './openclaw/OpenClawSessionAdapter.js';
+export { OpenClawMemoryIndexAdapter } from './openclaw/OpenClawMemoryIndexAdapter.js';
+export { OpenClawUserProfileAdapter } from './openclaw/OpenClawUserProfileAdapter.js';
+export { OpenClawPersonaAdapter } from './openclaw/OpenClawPersonaAdapter.js';
+export { OpenClawWorkspaceProfile } from './openclaw/OpenClawWorkspaceProfile.js';
+export { HermesStateDbAdapter } from './hermes/HermesStateDbAdapter.js';
+export { HermesWorkspaceProfile } from './hermes/HermesWorkspaceProfile.js';

package/dist/adapters/openclaw/OpenClawAdapterSupport.d.ts

@@ -0,0 +1,14 @@
+import type { AdaptedSource, SourceAdapterKind, SourceAdapterRecord, SourceDefinition, SourceReliabilityClass } from '../types.js';
+export interface OpenClawRecordDecoration {
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    reliabilityClass?: SourceReliabilityClass;
+    confidenceHint?: number;
+}
+export declare function decorateOpenClawRecords(adapted: AdaptedSource, source: SourceDefinition, input: {
+    adapterKind: SourceAdapterKind;
+    adapterVersion: string;
+    baseTags: string[];
+    decorateRecord?: (record: SourceAdapterRecord) => OpenClawRecordDecoration;
+}): AdaptedSource;
+//# sourceMappingURL=OpenClawAdapterSupport.d.ts.map

package/dist/adapters/openclaw/OpenClawAdapterSupport.js

@@ -0,0 +1,29 @@
+export function decorateOpenClawRecords(adapted, source, input) {
+    return {
+        ...adapted,
+        source,
+        records: adapted.records.map((record) => {
+            const decoration = input.decorateRecord?.(record) || {};
+            const tags = Array.from(new Set([
+                ...record.tags,
+                ...input.baseTags,
+                ...(decoration.tags || [])
+            ]));
+            return {
+                ...record,
+                tags,
+                confidenceHint: decoration.confidenceHint ?? record.confidenceHint,
+                metadata: {
+                    ...(record.metadata || {}),
+                    ...(decoration.metadata || {})
+                },
+                provenance: {
+                    ...record.provenance,
+                    sourceType: input.adapterKind,
+                    adapterVersion: input.adapterVersion,
+                    reliabilityClass: decoration.reliabilityClass ?? record.provenance.reliabilityClass
+                }
+            };
+        })
+    };
+}

package/dist/adapters/openclaw/OpenClawDailyMemoryAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSource, AdapterWindow, SourceAdapter, SourceDefinition, SourceFileSnapshot } from '../types.js';
+export declare class OpenClawDailyMemoryAdapter implements SourceAdapter {
+    readonly kind: "openclaw_daily_memory";
+    private readonly adapterVersion;
+    private readonly delegate;
+    adapt(source: SourceDefinition, snapshot: SourceFileSnapshot, window?: AdapterWindow): AdaptedSource;
+}
+//# sourceMappingURL=OpenClawDailyMemoryAdapter.d.ts.map

package/dist/adapters/openclaw/OpenClawDailyMemoryAdapter.js

@@ -0,0 +1,35 @@
+import { SoulMarkdownAdapter } from '../soul/SoulMarkdownAdapter.js';
+import { decorateOpenClawRecords } from './OpenClawAdapterSupport.js';
+export class OpenClawDailyMemoryAdapter {
+    kind = 'openclaw_daily_memory';
+    adapterVersion = 'openclaw-daily-memory-v1';
+    delegate = new SoulMarkdownAdapter();
+    adapt(source, snapshot, window) {
+        const adapted = this.delegate.adapt(source, snapshot, window);
+        return decorateOpenClawRecords(adapted, source, {
+            adapterKind: this.kind,
+            adapterVersion: this.adapterVersion,
+            baseTags: ['openclaw', 'source_class:daily_memory'],
+            decorateRecord: (record) => {
+                if (record.provenance.reliabilityClass === 'raw_utterance') {
+                    return {
+                        tags: ['memory_layer:episodic']
+                    };
+                }
+                return {
+                    reliabilityClass: 'imported_summary',
+                    tags: [
+                        'provenance:imported_summary',
+                        'governance:imported_summary_support',
+                        'memory_layer:summary_seed'
+                    ],
+                    metadata: {
+                        openclawImportKind: 'daily_memory_summary',
+                        importedSummarySupport: true
+                    },
+                    confidenceHint: Math.min(record.confidenceHint, 0.58)
+                };
+            }
+        });
+    }
+}

package/dist/adapters/openclaw/OpenClawMemoryIndexAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSource, AdapterWindow, SourceAdapter, SourceDefinition, SourceFileSnapshot } from '../types.js';
+export declare class OpenClawMemoryIndexAdapter implements SourceAdapter {
+    readonly kind: "openclaw_memory_index";
+    private readonly adapterVersion;
+    private readonly delegate;
+    adapt(source: SourceDefinition, snapshot: SourceFileSnapshot, window?: AdapterWindow): AdaptedSource;
+}
+//# sourceMappingURL=OpenClawMemoryIndexAdapter.d.ts.map

package/dist/adapters/openclaw/OpenClawMemoryIndexAdapter.js

@@ -0,0 +1,23 @@
+import { SoulMarkdownAdapter } from '../soul/SoulMarkdownAdapter.js';
+import { decorateOpenClawRecords } from './OpenClawAdapterSupport.js';
+export class OpenClawMemoryIndexAdapter {
+    kind = 'openclaw_memory_index';
+    adapterVersion = 'openclaw-memory-index-v1';
+    delegate = new SoulMarkdownAdapter();
+    adapt(source, snapshot, window) {
+        const adapted = this.delegate.adapt(source, snapshot, undefined);
+        return decorateOpenClawRecords(adapted, source, {
+            adapterKind: this.kind,
+            adapterVersion: this.adapterVersion,
+            baseTags: ['openclaw', 'source_class:memory_index', 'memory_layer:summary_seed'],
+            decorateRecord: (record) => ({
+                reliabilityClass: 'imported_summary',
+                tags: ['provenance:imported_summary'],
+                metadata: {
+                    openclawImportKind: 'memory_index'
+                },
+                confidenceHint: Math.max(record.confidenceHint, 0.68)
+            })
+        });
+    }
+}

package/dist/adapters/openclaw/OpenClawPersonaAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSource, AdapterWindow, SourceAdapter, SourceDefinition, SourceFileSnapshot } from '../types.js';
+export declare class OpenClawPersonaAdapter implements SourceAdapter {
+    readonly kind: "openclaw_persona";
+    private readonly adapterVersion;
+    private readonly delegate;
+    adapt(source: SourceDefinition, snapshot: SourceFileSnapshot, window?: AdapterWindow): AdaptedSource;
+}
+//# sourceMappingURL=OpenClawPersonaAdapter.d.ts.map

package/dist/adapters/openclaw/OpenClawPersonaAdapter.js

@@ -0,0 +1,24 @@
+import { SoulMarkdownAdapter } from '../soul/SoulMarkdownAdapter.js';
+import { decorateOpenClawRecords } from './OpenClawAdapterSupport.js';
+export class OpenClawPersonaAdapter {
+    kind = 'openclaw_persona';
+    adapterVersion = 'openclaw-persona-v1';
+    delegate = new SoulMarkdownAdapter();
+    adapt(source, snapshot, window) {
+        const adapted = this.delegate.adapt(source, snapshot, undefined);
+        return decorateOpenClawRecords(adapted, source, {
+            adapterKind: this.kind,
+            adapterVersion: this.adapterVersion,
+            baseTags: ['openclaw', 'source_class:persona', 'namespace:agent_persona', 'ingest:profile_only'],
+            decorateRecord: () => ({
+                reliabilityClass: 'imported_profile',
+                tags: ['profile:seed', 'profile_scope:agent'],
+                metadata: {
+                    openclawImportKind: 'agent_persona',
+                    profileNamespace: 'agent_persona'
+                },
+                confidenceHint: 0.8
+            })
+        });
+    }
+}

package/dist/adapters/openclaw/OpenClawSessionAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSource, AdapterWindow, SourceAdapter, SourceDefinition, SourceFileSnapshot } from '../types.js';
+export declare class OpenClawSessionAdapter implements SourceAdapter {
+    readonly kind: "openclaw_session";
+    private readonly adapterVersion;
+    private readonly delegate;
+    adapt(source: SourceDefinition, snapshot: SourceFileSnapshot, window?: AdapterWindow): AdaptedSource;
+}
+//# sourceMappingURL=OpenClawSessionAdapter.d.ts.map

package/dist/adapters/openclaw/OpenClawSessionAdapter.js

@@ -0,0 +1,15 @@
+import { ConversationMarkdownAdapter } from '../conversation/ConversationMarkdownAdapter.js';
+import { decorateOpenClawRecords } from './OpenClawAdapterSupport.js';
+export class OpenClawSessionAdapter {
+    kind = 'openclaw_session';
+    adapterVersion = 'openclaw-session-v1';
+    delegate = new ConversationMarkdownAdapter();
+    adapt(source, snapshot, window) {
+        const adapted = this.delegate.adapt(source, snapshot, window);
+        return decorateOpenClawRecords(adapted, source, {
+            adapterKind: this.kind,
+            adapterVersion: this.adapterVersion,
+            baseTags: ['openclaw', 'source_class:session_log', 'memory_layer:raw_evidence']
+        });
+    }
+}

package/dist/adapters/openclaw/OpenClawUserProfileAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { AdaptedSource, AdapterWindow, SourceAdapter, SourceDefinition, SourceFileSnapshot } from '../types.js';
+export declare class OpenClawUserProfileAdapter implements SourceAdapter {
+    readonly kind: "openclaw_user_profile";
+    private readonly adapterVersion;
+    private readonly delegate;
+    adapt(source: SourceDefinition, snapshot: SourceFileSnapshot, window?: AdapterWindow): AdaptedSource;
+}
+//# sourceMappingURL=OpenClawUserProfileAdapter.d.ts.map

package/dist/adapters/openclaw/OpenClawUserProfileAdapter.js

@@ -0,0 +1,24 @@
+import { SoulMarkdownAdapter } from '../soul/SoulMarkdownAdapter.js';
+import { decorateOpenClawRecords } from './OpenClawAdapterSupport.js';
+export class OpenClawUserProfileAdapter {
+    kind = 'openclaw_user_profile';
+    adapterVersion = 'openclaw-user-profile-v1';
+    delegate = new SoulMarkdownAdapter();
+    adapt(source, snapshot, window) {
+        const adapted = this.delegate.adapt(source, snapshot, undefined);
+        return decorateOpenClawRecords(adapted, source, {
+            adapterKind: this.kind,
+            adapterVersion: this.adapterVersion,
+            baseTags: ['openclaw', 'source_class:user_profile', 'namespace:user_profile', 'ingest:profile_only'],
+            decorateRecord: (record) => ({
+                reliabilityClass: 'imported_profile',
+                tags: ['profile:seed', 'profile_scope:user'],
+                metadata: {
+                    openclawImportKind: 'user_profile',
+                    profileNamespace: 'user_profile'
+                },
+                confidenceHint: 0.84
+            })
+        });
+    }
+}

package/dist/adapters/openclaw/OpenClawWorkspaceProfile.d.ts

@@ -0,0 +1,38 @@
+import { type SourceAdapterKind, type SourceDefinition } from '../types.js';
+export type OpenClawSourceClassification = 'memory_source' | 'identity_profile_source' | 'operational_ignore' | 'unknown';
+export interface OpenClawClassifiedPath {
+    path: string;
+    relativePath: string;
+    classification: OpenClawSourceClassification;
+    adapterKind?: SourceAdapterKind;
+    reason: string;
+}
+export interface OpenClawWorkspaceSourceOptions {
+    projectId?: string;
+    date?: string;
+    sessionPaths?: string[];
+    optionalMemoryPaths?: string[];
+}
+export interface OpenClawWorkspaceSelectionDiagnostic extends OpenClawClassifiedPath {
+    explicit: boolean;
+    exists: boolean;
+    included: boolean;
+}
+export interface OpenClawWorkspaceSelection {
+    sources: SourceDefinition[];
+    diagnostics: OpenClawWorkspaceSelectionDiagnostic[];
+}
+export declare class OpenClawWorkspaceProfile {
+    readonly workspaceRoot: string;
+    constructor(workspaceRoot: string);
+    static discoverWorkspaceRoot(startPath: string): string | null;
+    static looksLikeWorkspaceRoot(candidate: string): boolean;
+    classifyPath(filePath: string): OpenClawClassifiedPath;
+    listReferenceWorkspaceContract(): OpenClawClassifiedPath[];
+    buildInstalledBatchSources(options?: OpenClawWorkspaceSourceOptions): SourceDefinition[];
+    buildInstalledBatchSelection(options?: OpenClawWorkspaceSourceOptions): OpenClawWorkspaceSelection;
+    private classifyExplicitPath;
+    private isSessionPath;
+    private result;
+}
+//# sourceMappingURL=OpenClawWorkspaceProfile.d.ts.map