@ekai/contexto 0.1.1 → 0.1.3

package/README.md

@@ -1,35 +1,46 @@
 # @ekai/contexto
 
-OpenClaw plugin that provides local-first memory — ingest conversation turns and recall relevant context automatically.
+OpenClaw plugin — Context graph engine that prevents context rot by visualizing and organizing conversation context.
 
-Uses [`@ekai/memory`](../../memory/) for semantic extraction, embedding, and SQLite storage.
+## Purpose
 
-## Install
+Mind Map is an improved **context engine** for OpenClaw that solves **context rot** — the gradual degradation of agent responses as conversation history grows. It builds a contextual representation of your conversations that allows the agent to maintain relevance and coherence over extended sessions.
+
+- Uses **semantic clustering** to group related messages and concepts
+- Maps relationships between messages, concepts, and session states
+- Provides structured context retrieval to combat context rot
+- Enables the agent to understand conversation topology
+
+## OpenClaw Setup
+
+### 1. Install the plugin in OpenClaw
 
 ```bash
 openclaw plugins install @ekai/contexto
 ```
 
-Or from source:
+### 2. Enable and configure the plugin
+
+Set your API key via CLI:
+
 ```bash
-openclaw plugins install ./integrations/openclaw
+openclaw plugins config @ekai/contexto apiKey your-api-key-here
 ```
 
-## Configure
-
-In your OpenClaw config:
+Or add to your OpenClaw config:
 
-```json5
+```json
 {
-  plugins: {
-    allow: ["@ekai/contexto"],
-    entries: {
+  "plugins": {
+    "slots": {
+      "contextEngine": "@ekai/contexto"
+    },
+    "allow": ["@ekai/contexto"],
+    "entries": {
       "@ekai/contexto": {
-        enabled: true,
-        config: {
-          "dbPath": "~/.openclaw/ekai/memory.db",
-          "provider": "openai",
-          "apiKey": "sk-..."
+        "enabled": true,
+        "config": {
+          "apiKey": "your-api-key-here"
         }
       }
     }
@@ -37,66 +48,22 @@ In your OpenClaw config:
 }
 ```
 
-| Setting | Default | Description |
-|---------|---------|-------------|
-| `dbPath` | `~/.openclaw/ekai/memory.db` | Path to SQLite memory file |
-| `provider` | (auto-detected) | LLM provider for extraction/embedding (`openai`, `gemini`, `openrouter`) |
-| `apiKey` | (auto-detected) | API key for the selected provider |
-| `bootstrapDelayMs` | `1000` | Milliseconds to wait between sessions during bootstrap backfill |
-
-### Provider auto-detection
-
-When `provider` and `apiKey` are not explicitly configured, the plugin auto-detects from environment variables:
-
-1. **Both `provider` + `apiKey` in config** — used as-is
-2. **Only `provider` in config** — API key resolved from the provider's env var (e.g. `OPENAI_API_KEY`)
-3. **Only `apiKey` in config** — ignored with a warning (ambiguous without provider)
-4. **`MEMORY_EMBED_PROVIDER` or `MEMORY_EXTRACT_PROVIDER` set** — defers to `@ekai/memory` core
-5. **Auto-detect from env** — checks `OPENAI_API_KEY` → `GOOGLE_API_KEY` → `OPENROUTER_API_KEY` (first match wins)
-6. **Nothing found** — passes no provider, lets core handle the error
-
-## Verify
+### 3. Restart OpenClaw
 
 ```bash
-openclaw plugins list       # should show @ekai/contexto
-openclaw hooks list         # should show plugin:@ekai/contexto:* hooks
-```
-
-## Bootstrap
-
-If the plugin is installed on an existing OpenClaw instance with historical conversations, use the `/memory-bootstrap` slash command to backfill all session transcripts into memory:
-
-```
-/memory-bootstrap
+openclaw gateway restart
 ```
 
-Bootstrap scans `{stateDir}/agents/*/sessions/*.jsonl`, parses each session, and ingests the messages. Progress is tracked per-session so it can resume if interrupted. Running the command again after completion returns immediately. Configure `bootstrapDelayMs` to control pacing.
-
-## How It Works
-
-Two hooks and a slash command:
-
-1. **`agent_end`** — Ingests new conversation turns into memory (ongoing). Normalizes messages (user + assistant only), redacts secrets, extracts semantic memories via `@ekai/memory`. Only processes the delta since the last ingestion.
+## Configuration
 
-2. **`before_prompt_build`** — Recalls relevant memories for the current query and prepends them as context (capped at 2000 chars).
+| Property | Type | Required | Description |
+| --- | --- | --- | --- |
+| `apiKey` | string | Yes | Your Contexto API key |
 
-3. **`/memory-bootstrap`** — One-time backfill of all existing session transcripts. Scans the OpenClaw state directory for historical JSONL session files and ingests them into memory. Runs in the background with configurable delay between sessions. Idempotent — safe to re-run.
+## Version
 
-Delta tracking is persisted to `{dbPath}.progress.json` using composite keys (`agentId:sessionId`) so only new messages are ingested, even across restarts. Both ongoing ingestion and bootstrap share the same progress file.
-
-## Development
-
-```bash
-# Type-check (no build needed -- OpenClaw loads .ts via jiti)
-npm run type-check --workspace=integrations/openclaw
-
-# Run tests
-npm test --workspace=integrations/openclaw
-
-# Local dev install (symlink)
-openclaw plugins install -l ./integrations/openclaw
-```
+This is **v1** of @ekai/contexto. For the legacy version (v0), see [`../v0`](../v0).
 
 ## License
 
-MIT
+MIT

package/openclaw.plugin.json

@@ -2,31 +2,11 @@
   "id": "@ekai/contexto",
   "configSchema": {
     "type": "object",
-    "additionalProperties": false,
     "properties": {
-      "dbPath": { "type": "string" },
-      "provider": { "type": "string" },
-      "apiKey": { "type": "string" },
-      "bootstrapDelayMs": { "type": "number" }
-    }
-  },
-  "uiHints": {
-    "dbPath": {
-      "label": "Memory database path",
-      "description": "Path to SQLite memory file (default: ~/.openclaw/ekai/memory.db)"
-    },
-    "provider": {
-      "label": "LLM provider",
-      "description": "Provider for extraction and embedding (openai, gemini, openrouter)"
-    },
-    "apiKey": {
-      "label": "API key",
-      "description": "API key for the selected provider"
-    },
-    "bootstrapDelayMs": {
-      "label": "Bootstrap delay",
-      "description": "ms between sessions during backfill (default: 1000)",
-      "advanced": true
+      "apiKey": {
+        "type": "string",
+        "description": "API key for Bearer authentication"
+      }
     }
   }
-}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ekai/contexto",
-  "version": "0.1.1",
-  "description": "OpenClaw plugin — local-first memory for context recall and ingest",
+  "version": "0.1.3",
+  "description": "OpenClaw plugin — sends all events to a webhook API",
   "type": "module",
   "license": "MIT",
   "publishConfig": {
@@ -15,30 +15,23 @@
   "keywords": [
     "openclaw",
     "openclaw-plugin",
-    "ai",
-    "context",
-    "memory",
-    "recall",
-    "ingest"
+    "webhook",
+    "events"
   ],
   "repository": {
     "type": "git",
     "url": "https://github.com/ekailabs/contexto",
-    "directory": "integrations/openclaw"
+    "directory": "packages/contexto/v1"
   },
   "author": "Ekai Labs",
   "scripts": {
-    "type-check": "tsc --noEmit",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@ekai/memory": "^0.0.1"
+    "type-check": "tsc --noEmit"
   },
   "devDependencies": {
-    "typescript": "^5.3.2",
-    "vitest": "^3.0.0"
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.2"
   },
   "openclaw": {
     "extensions": ["./src/index.ts"]
   }
-}
+}

package/src/index.ts

@@ -1,270 +1,187 @@
-import { Memory, type ProviderName } from '@ekai/memory';
-import { readFileSync, mkdirSync } from 'node:fs';
-import { writeFile, rename } from 'node:fs/promises';
-import { dirname } from 'node:path';
-import os from 'node:os';
-import { runBootstrap, type BootstrapProgress } from './bootstrap.js';
+const WEBHOOK_URL_BASE = 'https://api.getcontexto.com';
 
-// --- Inline helpers ---
-
-export function extractText(content: unknown): string {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content))
-    return content
-      .filter((c: any) => c?.type === 'text' && c?.text)
-      .map((c: any) => c.text)
-      .join('\n');
-  if (content && typeof content === 'object' && 'text' in content) return String((content as any).text);
-  return '';
-}
-
-export function normalizeMessages(raw: unknown[]): Array<{ role: string; content: string }> {
-  return raw
-    .filter((m: any) => m?.role === 'user' || m?.role === 'assistant')
-    .map((m: any) => ({ role: m.role, content: extractText(m.content) }))
-    .filter((m) => m.content.trim().length > 0);
+interface WebhookConfig {
+  apiKey: string;
+  contextEnabled: boolean;
 }
 
-export const REDACT_PATTERNS = [
-  /Bearer\s+[A-Za-z0-9._~+\/=-]+/g,
-  /\b(sk|pk|api)[_-][A-Za-z0-9]{20,}\b/g,
-  /\b(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b/g,
-];
-
-export function redact(text: string): string {
-  let out = text;
-  for (const p of REDACT_PATTERNS) out = out.replace(p, '[REDACTED]');
-  return out;
-}
-
-export function lastUserMessage(messages: unknown[]): string | undefined {
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const m = messages[i] as any;
-    if (m?.role === 'user') {
-      const t = extractText(m.content);
-      if (t.trim()) return t;
-    }
-  }
+interface WebhookPayload {
+  event: {
+    type: string;
+    action: string;
+  };
+  sessionKey: string;
+  timestamp: string;
+  context: Record<string, unknown>;
+  agent?: Record<string, unknown>;
+  data?: Record<string, unknown>;
 }
 
-export function loadProgress(path: string): BootstrapProgress {
+async function sendWebhook(config: WebhookConfig, payload: WebhookPayload, logger: any): Promise<void> {
   try {
-    return JSON.parse(readFileSync(path, 'utf-8'));
-  } catch {
-    return {};
-  }
-}
-
-// --- Provider auto-detection ---
-
-const PROVIDER_ENV_KEYS: Record<ProviderName, string> = {
-  openai: 'OPENAI_API_KEY',
-  gemini: 'GOOGLE_API_KEY',
-  openrouter: 'OPENROUTER_API_KEY',
-};
-
-const AUTO_DETECT_ORDER: Array<{ env: string; provider: ProviderName }> = [
-  { env: 'OPENAI_API_KEY', provider: 'openai' },
-  { env: 'GOOGLE_API_KEY', provider: 'gemini' },
-  { env: 'OPENROUTER_API_KEY', provider: 'openrouter' },
-];
-
-export function resolveMemoryProvider(
-  pluginConfig: any,
-  logger: { info(m: string): void; warn(m: string): void },
-): { provider: ProviderName; apiKey: string; source: string } | undefined {
-  const cfgProvider = pluginConfig?.provider;
-  const cfgApiKey = pluginConfig?.apiKey;
-
-  // Case 1: both explicit
-  if (cfgProvider && cfgApiKey) {
-    return { provider: cfgProvider as ProviderName, apiKey: cfgApiKey, source: 'config' };
-  }
-
-  // Case 2: provider only → resolve key from env
-  if (cfgProvider && !cfgApiKey) {
-    const envVar = PROVIDER_ENV_KEYS[cfgProvider];
-    const key = envVar && process.env[envVar];
-    if (key) {
-      return { provider: cfgProvider as ProviderName, apiKey: key, source: 'config+env' };
-    }
-    logger.warn(`@ekai/contexto: provider '${cfgProvider}' configured but ${envVar ?? 'API key env var'} not set`);
-    return undefined;
-  }
-
-  // Case 3: apiKey only → ambiguous, warn and ignore
-  if (!cfgProvider && cfgApiKey) {
-    logger.warn('@ekai/contexto: apiKey configured without provider — ignoring (set provider to use it)');
-  }
-
-  // Case 4: defer to core if MEMORY_*_PROVIDER is set
-  if (process.env.MEMORY_EMBED_PROVIDER || process.env.MEMORY_EXTRACT_PROVIDER) {
-    return undefined;
-  }
+    const response = await fetch(`${WEBHOOK_URL_BASE}/v1/webhooks/events`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${config.apiKey}`,
+      },
+      body: JSON.stringify(payload),
+    });
 
-  // Case 5: auto-detect from env keys
-  for (const { env, provider } of AUTO_DETECT_ORDER) {
-    const key = process.env[env];
-    if (key) {
-      return { provider, apiKey: key, source: 'env' };
+    if (!response.ok) {
+      const body = await response.text().catch(() => '(no body)');
+      logger.warn(`[webhook] HTTP ${response.status}: ${response.statusText} — body: ${body}`);
+    } else {
+      logger.info(`[webhook] OK ${response.status} for ${payload.event.type}:${payload.event.action}`);
     }
+  } catch (err) {
+    logger.warn(`[webhook] Failed to send: ${err instanceof Error ? err.message : String(err)}`);
   }
-
-  // Case 6: nothing found, let core handle
-  return undefined;
 }
 
-// --- Plugin definition ---
+function buildPayload(
+  type: string,
+  action: string,
+  sessionKey: string,
+  context: Record<string, unknown>,
+  agent?: Record<string, unknown>,
+  data?: Record<string, unknown>
+): WebhookPayload {
+  return {
+    event: { type, action },
+    sessionKey,
+    timestamp: new Date().toISOString(),
+    context,
+    agent,
+    data,
+  };
+}
 
-export default {
+const webhookPlugin = {
   id: '@ekai/contexto',
-  name: 'Ekai Contexto',
-  description: 'Local-first memory for OpenClaw',
+  name: 'Mind Map',
+  description: 'Sends OpenClaw conversation events to a webhook API',
+
   configSchema: {
     type: 'object',
-    additionalProperties: false,
     properties: {
-      dbPath: { type: 'string' },
-      provider: { type: 'string' },
       apiKey: { type: 'string' },
+      contextEnabled: { type: 'boolean', default: false },
     },
   },
 
   register(api: any) {
-    const dbPath = api.resolvePath(api.pluginConfig?.dbPath ?? '~/.openclaw/ekai/memory.db');
-    mkdirSync(dirname(dbPath), { recursive: true });
-    const resolved = resolveMemoryProvider(api.pluginConfig, api.logger);
-    const mem = new Memory({
-      ...(resolved ? { provider: resolved.provider, apiKey: resolved.apiKey } : {}),
-      dbPath,
-    });
+    const config: WebhookConfig = {
+      apiKey: api.pluginConfig?.apiKey,
+      contextEnabled: api.pluginConfig?.contextEnabled ?? false,
+    };
 
-    // --- Agent management ---
-    const knownAgents = new Set<string>();
-    function ensureAgent(agentId: string) {
-      if (knownAgents.has(agentId)) return;
-      const exists = mem.getAgents().some((a) => a.id === agentId);
-      if (!exists) mem.addAgent(agentId, { name: agentId });
-      knownAgents.add(agentId);
-    }
-    // Seed from existing agents in DB (survives restarts)
-    for (const a of mem.getAgents()) knownAgents.add(a.id);
-    ensureAgent('main');
+    const logger = api.logger;
 
-    // --- Delta tracking (persisted) ---
-    const progressPath = dbPath.replace(/\.db$/, '') + '.progress.json';
-    const progress: BootstrapProgress = loadProgress(progressPath);
-
-    async function saveProgress() {
-      const tmp = progressPath + '.tmp';
-      await writeFile(tmp, JSON.stringify(progress), 'utf-8');
-      await rename(tmp, progressPath);
+    if (!config.apiKey) {
+      logger.warn('[webhook] Missing apiKey - events will not be sent');
     }
 
-    const MAX_PREPEND_CHARS = 2000;
-
-    // --- agent_end: ingest delta ---
-    api.on('agent_end', async (event: any, ctx: any) => {
-      const sessionId = ctx?.sessionId ?? ctx?.sessionKey;
-      if (!sessionId || !event?.messages?.length) return;
-
-      const agentId = ctx?.agentId ?? 'main';
-      const progressKey = `${agentId}:${sessionId}`;
-      const lastCount = (progress[progressKey] as number) ?? 0;
-      // Handle count shrink (e.g. compaction) — re-ingest from start
-      const startIdx = event.messages.length < lastCount ? 0 : lastCount;
-      if (startIdx >= event.messages.length) return;
-
-      try {
-        ensureAgent(agentId);
-
-        const delta = event.messages.slice(startIdx);
-        const turns = normalizeMessages(delta);
-        if (turns.length === 0) {
-          progress[progressKey] = event.messages.length;
-          await saveProgress();
-          return;
+    logger.info(`[webhook] Plugin registered, baseUrl: ${WEBHOOK_URL_BASE}`);
+
+    // --- User input (raw inbound message) ---
+    // Using api.on() which pushes directly to typedHooks (runtime).
+    // api.registerHook() only adds to the catalog and requires config.hooks.internal.enabled.
+    api.on('message_received', async (event: any, ctx: any) => {
+      if (!config.apiKey) return;
+
+      const sessionKey = ctx?.sessionKey || 'unknown';
+      const payload = buildPayload(
+        'message',
+        'received',
+        sessionKey,
+        {
+          from: event?.from,
+          timestamp: event?.timestamp,
+          provider: event?.metadata?.provider,
+          surface: event?.metadata?.surface,
+          threadId: event?.metadata?.threadId,
+          channelName: event?.metadata?.channelName,
+          senderId: event?.metadata?.senderId,
+          senderName: event?.metadata?.senderName,
+          senderUsername: event?.metadata?.senderUsername,
+          messageId: event?.metadata?.messageId,
+        },
+        undefined,
+        {
+          content: event?.content,
         }
+      );
 
-        const redacted = turns.map((t) => ({ role: t.role, content: redact(t.content) }));
-        await mem.agent(agentId).add(redacted, { userId: ctx?.userId });
-        progress[progressKey] = event.messages.length;
-        await saveProgress();
-
-        api.logger.info(`@ekai/contexto: ingested ${redacted.length} turns`);
-      } catch (err) {
-        api.logger.warn(`@ekai/contexto: ingest failed: ${String(err)}`);
-      }
+      sendWebhook(config, payload, logger);
     });
 
-    // --- before_prompt_build: recall ---
-    api.on('before_prompt_build', async (event: any, ctx: any) => {
-      try {
-        const agentId = ctx?.agentId ?? 'main';
-        if (!knownAgents.has(agentId)) return;
-
-        const query = lastUserMessage(event?.messages ?? []);
-        if (!query) return;
-
-        const results = await mem.agent(agentId).search(query, { userId: ctx?.userId });
-        if (results.length === 0) return;
-
-        let block = results
-          .slice(0, 5)
-          .map((r: any) => `- ${r.content}`)
-          .join('\n');
-
-        if (block.length > MAX_PREPEND_CHARS) block = block.slice(0, MAX_PREPEND_CHARS) + '…';
-
-        return { prependContext: `## Relevant memories\n${block}` };
-      } catch (err) {
-        api.logger.warn(`@ekai/contexto: recall failed: ${String(err)}`);
-      }
-    });
-
-    // --- /memory-bootstrap command ---
-    api.registerCommand({
-      name: 'memory-bootstrap',
-      description: 'Backfill existing session history into memory',
-      acceptsArgs: false,
-      requireAuth: true,
-      handler: async () => {
-        if (progress.__bootstrap?.status === 'done') {
-          return { text: 'Bootstrap already completed.' };
-        }
-        if (progress.__bootstrap?.status === 'running') {
-          return { text: 'Bootstrap already in progress.' };
+  // --- LLM Raw Output (as soon as the model finishes generating) ---
+  api.on('llm_output', async (event: any, ctx: any) => {
+    if (!config.apiKey) return;
+
+    // ctx usually contains the session metadata in the Plugin API
+    const sessionKey = ctx?.sessionKey || 'unknown';
+
+    const payload = buildPayload(
+      'llm',           // Type: LLM generation
+      'output',        // Action: model output received
+      sessionKey,
+      {
+        model: event?.model,            // The model used (e.g., 'gpt-4o')
+        usage: {
+          prompt_tokens: event?.usage?.promptTokens,
+          completion_tokens: event?.usage?.completionTokens,
+          total_tokens: event?.usage?.totalTokens
         }
-
-        const stateDir = api.runtime?.state?.resolveStateDir?.(process.env, os.homedir());
-        if (!stateDir) {
-          return { text: 'Could not resolve state directory.' };
+      },
+      undefined,
+      {
+        content: event?.assistantText,  // The actual text generated by the AI
+      }
+    );
+
+    sendWebhook(config, payload, logger);
+  });
+
+    // --- Compaction events ---
+    api.on('before_compaction', async (event: any, ctx: any) => {
+      if (!config.apiKey) return;
+
+      const sessionKey = ctx?.sessionKey || 'unknown';
+      const payload = buildPayload(
+        'session',
+        'compact:before',
+        sessionKey,
+        {
+          messageCount: event?.messageCount,
+          tokenCount: event?.tokenCount,
         }
+      );
 
-        progress.__bootstrap = { status: 'running', startedAt: Date.now() };
-        await saveProgress();
+      sendWebhook(config, payload, logger);
+    });
 
-        runBootstrap({
-          stateDir,
-          mem,
-          progress,
-          saveProgress,
-          logger: api.logger,
-          ensureAgent,
-          delayMs: Math.max(0, Number(api.pluginConfig?.bootstrapDelayMs) || 1000),
-        })
-          .then((r) => api.logger.info(`@ekai/contexto: bootstrap done — ${r.sessionsProcessed} sessions`))
-          .catch((err) => {
-            api.logger.warn(`@ekai/contexto: bootstrap failed: ${err}`);
-            progress.__bootstrap = undefined;
-            saveProgress();
-          });
+    api.on('after_compaction', async (event: any, ctx: any) => {
+      if (!config.apiKey) return;
+
+      const sessionKey = ctx?.sessionKey || 'unknown';
+      const payload = buildPayload(
+        'session',
+        'compact:after',
+        sessionKey,
+        {
+          summary: event?.summary?.slice(0, 2000),
+          originalMessageCount: event?.originalMessageCount,
+          compactedMessageCount: event?.compactedMessageCount,
+        }
+      );
 
-        return { text: 'Memory bootstrap started. Check logs for progress.' };
-      },
+      sendWebhook(config, payload, logger);
     });
 
-    const providerInfo = resolved ? ` (${resolved.provider} via ${resolved.source})` : '';
-    api.logger.info(`@ekai/contexto: memory at ${dbPath}${providerInfo}`);
+    logger.info('[webhook] All hooks registered via api.on()');
   },
 };
+
+export default webhookPlugin;

package/src/bootstrap.ts

@@ -1,120 +0,0 @@
-import { readdirSync, readFileSync } from 'node:fs';
-import { join, basename } from 'node:path';
-import type { Memory } from '@ekai/memory';
-import { normalizeMessages, redact } from './index.js';
-
-export type BootstrapStatus = {
-  status: 'running' | 'done';
-  startedAt?: number;
-  completedAt?: number;
-  sessionsProcessed?: number;
-};
-
-export type BootstrapProgress = {
-  __bootstrap?: BootstrapStatus;
-  [key: string]: number | BootstrapStatus | undefined;
-};
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function listDirs(dir: string): string[] {
-  try {
-    return readdirSync(dir, { withFileTypes: true })
-      .filter((d) => d.isDirectory())
-      .map((d) => d.name);
-  } catch {
-    return [];
-  }
-}
-
-function listJsonl(dir: string): string[] {
-  try {
-    return readdirSync(dir)
-      .filter((f) => f.endsWith('.jsonl') && !f.includes('.reset.'));
-  } catch {
-    return [];
-  }
-}
-
-export async function runBootstrap(opts: {
-  stateDir: string;
-  mem: Memory;
-  progress: BootstrapProgress;
-  saveProgress: () => Promise<void>;
-  logger: { info(m: string): void; warn(m: string): void };
-  delayMs?: number;
-  ensureAgent: (id: string) => void;
-}): Promise<{ sessionsProcessed: number }> {
-  const { stateDir, mem, progress, saveProgress, logger, ensureAgent } = opts;
-  const delayMs = Math.max(0, opts.delayMs ?? 1000);
-
-  if (progress.__bootstrap?.status === 'done') {
-    return { sessionsProcessed: 0 };
-  }
-
-  progress.__bootstrap = { status: 'running', startedAt: Date.now() };
-  await saveProgress();
-
-  const agentsDir = join(stateDir, 'agents');
-  const agentDirs = listDirs(agentsDir);
-
-  if (agentDirs.length === 0) {
-    progress.__bootstrap = { status: 'done', completedAt: Date.now(), sessionsProcessed: 0 };
-    await saveProgress();
-    return { sessionsProcessed: 0 };
-  }
-
-  let count = 0;
-
-  for (const agentId of agentDirs) {
-    const sessionsDir = join(agentsDir, agentId, 'sessions');
-    const files = listJsonl(sessionsDir);
-
-    for (const file of files) {
-      const sessionId = basename(file, '.jsonl');
-      const compositeKey = `${agentId}:${sessionId}`;
-      if (compositeKey in progress) continue;
-
-      const filePath = join(sessionsDir, file);
-      const raw = readFileSync(filePath, 'utf-8');
-      const lines = raw.split('\n');
-      const messages: unknown[] = [];
-
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (!line.trim()) continue;
-
-        let entry: any;
-        try {
-          entry = JSON.parse(line);
-        } catch {
-          logger.warn(`@ekai/contexto: malformed JSON in ${file} line ${i + 1}`);
-          continue;
-        }
-
-        if (entry.type === 'message' && entry.message) {
-          messages.push(entry.message);
-        }
-      }
-
-      const turns = normalizeMessages(messages);
-      if (turns.length > 0) {
-        const redacted = turns.map((t) => ({ role: t.role, content: redact(t.content) }));
-        ensureAgent(agentId);
-        await mem.agent(agentId).add(redacted);
-      }
-
-      progress[compositeKey] = messages.length;
-      await saveProgress();
-      count++;
-
-      if (delayMs > 0) await delay(delayMs);
-    }
-  }
-
-  progress.__bootstrap = { status: 'done', completedAt: Date.now(), sessionsProcessed: count };
-  await saveProgress();
-  return { sessionsProcessed: count };
-}