cogmem 3.6.2

package/dist/bin/migrate-vectors.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=migrate-vectors.d.ts.map

package/dist/bin/migrate-vectors.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env bun
+import Database from 'bun:sqlite';
+import { loadCogmemConfig, resolveCogmemConfigPath } from '../config/CogmemConfig.js';
+import { DEFAULT_VECTOR_DIMENSION, parseVectorDimensionValue } from '../config/VectorDimension.js';
+import { NeuronEmbeddingStore } from '../embedding/NeuronEmbeddingStore.js';
+import { SqliteVecStore } from '../store/SqliteVecStore.js';
+import { printCliJson } from './CliJson.js';
+function parseArgs(argv) {
+    let dbPath = '';
+    let configPath = '';
+    let dimension;
+    let dryRun = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--db')
+            dbPath = argv[++index] ?? '';
+        else if (arg === '--config')
+            configPath = argv[++index] ?? '';
+        else if (arg === '--dimension')
+            dimension = parseDimensionArg(argv[++index], '--dimension');
+        else if (arg === '--dry-run')
+            dryRun = true;
+    }
+    return { dbPath: dbPath || undefined, configPath: configPath || undefined, dimension, dryRun };
+}
+function parseDimensionArg(value, label) {
+    if (!value || value.startsWith('--'))
+        throw new Error(`${label} must be a positive integer.`);
+    const diagnostics = [];
+    const dimension = parseVectorDimensionValue(value, label, diagnostics);
+    const error = diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+    if (error || dimension === undefined)
+        throw new Error(error?.message ?? `${label} must be a positive integer.`);
+    return dimension;
+}
+async function main() {
+    const args = parseArgs(Bun.argv.slice(2));
+    const resolution = args.configPath ? resolveCogmemConfigPath({ configPath: args.configPath }) : resolveCogmemConfigPath();
+    const loaded = resolution.kind === 'toml' ? loadCogmemConfig({ configPath: resolution.path }) : undefined;
+    const dbPath = args.dbPath || loaded?.options.dbPath;
+    if (!dbPath) {
+        throw new Error('Usage: bun run packages/core/src/bin/migrate-vectors.ts [--config <config.toml>|--db <memory.db>] [--dimension 384] [--dry-run]');
+    }
+    const db = new Database(dbPath);
+    db.exec('PRAGMA busy_timeout = 5000;');
+    try {
+        const embeddingStore = new NeuronEmbeddingStore(db);
+        const embeddings = embeddingStore.listLatestEmbeddings();
+        const dimension = args.dimension ?? loaded?.options.vectorDimension ?? embeddings[0]?.dimensions ?? DEFAULT_VECTOR_DIMENSION;
+        const sqliteVec = new SqliteVecStore(db, dimension);
+        const compatible = embeddings.filter((row) => row.dimensions === dimension);
+        if (!args.dryRun) {
+            sqliteVec.addVectors(compatible.map((row) => ({
+                id: row.neuronId,
+                vector: Array.from(row.vector),
+            })));
+        }
+        printCliJson('migrate-vectors', {
+            migrated: args.dryRun ? 0 : compatible.length,
+            eligible: compatible.length,
+            skippedDimensionMismatch: embeddings.length - compatible.length,
+            dimension,
+            backend: sqliteVec.getStats().backend,
+            dryRun: args.dryRun,
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/bin/migrate.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=migrate.d.ts.map

package/dist/bin/migrate.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+import Database from 'bun:sqlite';
+import { existsSync, renameSync, rmSync } from 'node:fs';
+import { loadCogmemConfig, resolveCogmemConfigPath } from '../config/CogmemConfig.js';
+import { ALL_MIGRATIONS, SchemaMigrationRunner } from '../migrations/index.js';
+import { printCliJson } from './CliJson.js';
+function parseArgs(argv) {
+    let dbPath;
+    let configPath;
+    let yes = false;
+    let dryRun = false;
+    let backup = false;
+    let json = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--db')
+            dbPath = argv[++index];
+        else if (arg === '--config')
+            configPath = argv[++index];
+        else if (arg === '--yes')
+            yes = true;
+        else if (arg === '--dry-run')
+            dryRun = true;
+        else if (arg === '--backup')
+            backup = true;
+        else if (arg === '--json')
+            json = true;
+    }
+    return { dbPath, configPath, dryRun: dryRun || !yes, backup, json };
+}
+function resolveDbPath(args) {
+    if (args.dbPath)
+        return args.dbPath;
+    const resolution = args.configPath
+        ? resolveCogmemConfigPath({ configPath: args.configPath })
+        : resolveCogmemConfigPath();
+    if (resolution.kind !== 'toml') {
+        throw new Error('Usage: cogmem migrate [--config <config.toml>|--db <memory.db>] [--dry-run|--yes] [--backup] [--json]');
+    }
+    const loaded = loadCogmemConfig({ configPath: resolution.path });
+    if (!loaded.options.dbPath)
+        throw new Error('Configured database path is missing.');
+    return loaded.options.dbPath;
+}
+function backupDatabase(db, dbPath) {
+    if (dbPath === ':memory:')
+        return undefined;
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = `${dbPath}.pre-migrate-${stamp}.bak`;
+    const temporaryPath = `${backupPath}.tmp`;
+    try {
+        // VACUUM INTO includes committed WAL pages and produces a standalone backup.
+        db.prepare('VACUUM INTO ?').run(temporaryPath);
+        renameSync(temporaryPath, backupPath);
+        return backupPath;
+    }
+    finally {
+        rmSync(temporaryPath, { force: true });
+    }
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const dbPath = resolveDbPath(args);
+    const shouldBackup = !args.dryRun && args.backup && dbPath !== ':memory:' && existsSync(dbPath);
+    const db = new Database(dbPath);
+    db.exec('PRAGMA busy_timeout = 5000;');
+    try {
+        const backupPath = shouldBackup ? backupDatabase(db, dbPath) : undefined;
+        const runner = new SchemaMigrationRunner(db, ALL_MIGRATIONS);
+        const result = runner.run({ dryRun: args.dryRun });
+        if (!args.dryRun) {
+            db.exec(`CREATE TABLE IF NOT EXISTS _meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);`);
+            const numericVersion = Number.parseInt(result.currentVersion || '0', 10);
+            db.prepare(`INSERT OR REPLACE INTO _meta (key, value) VALUES ('schema_version', ?)`).run(String(numericVersion));
+        }
+        const output = { command: 'migrate', dbPath, backupPath, ...result };
+        if (args.json)
+            printCliJson('migrate', output);
+        else {
+            console.log(`cogmem migrate ${args.dryRun ? 'dry-run' : 'complete'}`);
+            console.log(`database: ${dbPath}`);
+            console.log(`pending: ${result.pending.join(', ') || 'none'}`);
+            console.log(`applied: ${result.applied.join(', ') || 'none'}`);
+            if (backupPath)
+                console.log(`backup: ${backupPath}`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/bin/normalize-transcript.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+import { type ExportBridgeMarker, type NormalizationFamily, type NormalizedMessageSource } from '../utils/ConversationMarkdownNormalization.js';
+export interface NormalizeTranscriptCliResult {
+    inputPath: string;
+    outputPath: string;
+    title: string;
+    family: NormalizationFamily;
+    dryRun: boolean;
+    written: boolean;
+    messageCount: number;
+    sourceRefCount: number;
+    sourceRefs: NormalizedMessageSource[];
+    markers: ExportBridgeMarker[];
+}
+export declare function runNormalizeTranscript(argv: string[]): Promise<NormalizeTranscriptCliResult | void>;
+//# sourceMappingURL=normalize-transcript.d.ts.map

package/dist/bin/normalize-transcript.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+import { extname, resolve } from 'node:path';
+import { normalizeAppPrivateMixedEventExport, normalizeDelimitedRecords, normalizeJsonArrayRecords, normalizeJsonlMixedEventLogExport, normalizeJsonlRecords, writeNormalizedConversationMarkdown, } from '../utils/ConversationMarkdownNormalization.js';
+import { printCliJson } from './CliJson.js';
+const USAGE = [
+    'Usage: cogmem-normalize-transcript --input <file> --output <file> [--family json-array|jsonl|csv|tsv|app-private-mixed-event|jsonl-mixed-event-log] [--title <title>] [--dry-run] [--json]',
+    '',
+    'This command only normalizes transcript exports into conversation Markdown with source-ref anchors.',
+    'It does not open a memory database, run recall, or modify agent runtime state.',
+].join('\n');
+export async function runNormalizeTranscript(argv) {
+    const args = parseArgs(argv);
+    if (args.values.help === true || args.values.h === true) {
+        console.log(USAGE);
+        return;
+    }
+    const inputPath = resolve(requireString(args, 'input'));
+    const outputPath = resolve(requireString(args, 'output'));
+    const title = stringArg(args, 'title') || 'Normalized Conversation Export';
+    const dryRun = args.values['dry-run'] === true;
+    const normalized = normalizeInput(inputPath, stringArg(args, 'family'), stringArg(args, 'format'));
+    if (!dryRun) {
+        writeNormalizedConversationMarkdown(outputPath, title, normalized.family, normalized.messages, normalized.markers);
+    }
+    const sourceRefs = normalized.messages
+        .map((message) => message.source)
+        .filter((source) => Boolean(source));
+    const result = {
+        inputPath,
+        outputPath,
+        title,
+        family: normalized.family,
+        dryRun,
+        written: !dryRun,
+        messageCount: normalized.messages.length,
+        sourceRefCount: sourceRefs.length,
+        sourceRefs,
+        markers: normalized.markers,
+    };
+    if (args.values.json === true) {
+        printCliJson('normalize-transcript', result);
+    }
+    else {
+        printHumanSummary(result);
+    }
+    return result;
+}
+function normalizeInput(inputPath, familyArg, formatArg) {
+    const family = resolveFamily(inputPath, familyArg, formatArg);
+    switch (family) {
+        case 'jsonl_transcript_export':
+            return { family, messages: normalizeJsonlRecords(inputPath), markers: [] };
+        case 'json_array_transcript_export':
+            return { family, messages: normalizeJsonArrayRecords(inputPath), markers: [] };
+        case 'csv_transcript_export': {
+            const normalized = normalizeDelimitedRecords(inputPath, 'csv');
+            return { family: normalized.family, messages: normalized.messages, markers: [] };
+        }
+        case 'tsv_transcript_export': {
+            const normalized = normalizeDelimitedRecords(inputPath, 'tsv');
+            return { family: normalized.family, messages: normalized.messages, markers: [] };
+        }
+        case 'app_private_mixed_event_export':
+            return normalizeAppPrivateMixedEventExport(inputPath);
+        case 'jsonl_mixed_event_log_export':
+            return normalizeJsonlMixedEventLogExport(inputPath);
+    }
+}
+function resolveFamily(inputPath, familyArg, formatArg) {
+    if (familyArg)
+        return normalizeFamilyAlias(familyArg);
+    if (formatArg)
+        return normalizeFamilyAlias(formatArg);
+    const ext = extname(inputPath).toLowerCase();
+    if (ext === '.json')
+        return 'json_array_transcript_export';
+    if (ext === '.jsonl')
+        return 'jsonl_transcript_export';
+    if (ext === '.csv')
+        return 'csv_transcript_export';
+    if (ext === '.tsv')
+        return 'tsv_transcript_export';
+    throw new Error('Unable to infer transcript family. Pass --family json-array|jsonl|csv|tsv|app-private-mixed-event|jsonl-mixed-event-log.');
+}
+function normalizeFamilyAlias(value) {
+    const normalized = value.trim().toLowerCase().replace(/_/g, '-');
+    const aliases = {
+        'json': 'json_array_transcript_export',
+        'json-array': 'json_array_transcript_export',
+        'json-array-transcript-export': 'json_array_transcript_export',
+        'jsonl': 'jsonl_transcript_export',
+        'jsonl-transcript-export': 'jsonl_transcript_export',
+        'csv': 'csv_transcript_export',
+        'csv-transcript-export': 'csv_transcript_export',
+        'tsv': 'tsv_transcript_export',
+        'tsv-transcript-export': 'tsv_transcript_export',
+        'app-private-mixed-event': 'app_private_mixed_event_export',
+        'app-private-mixed-event-export': 'app_private_mixed_event_export',
+        'jsonl-mixed': 'jsonl_mixed_event_log_export',
+        'jsonl-mixed-event-log': 'jsonl_mixed_event_log_export',
+        'jsonl-mixed-event-log-export': 'jsonl_mixed_event_log_export',
+    };
+    const family = aliases[normalized];
+    if (!family) {
+        throw new Error(`Unsupported --family: ${value}`);
+    }
+    return family;
+}
+function parseArgs(argv) {
+    const values = {};
+    const args = argv[0] === '--' ? argv.slice(1) : argv;
+    for (let index = 0; index < args.length; index += 1) {
+        const item = args[index];
+        if (!item.startsWith('--'))
+            continue;
+        const key = item.slice(2);
+        const next = args[index + 1];
+        if (!next || next.startsWith('--')) {
+            values[key] = true;
+        }
+        else {
+            values[key] = next;
+            index += 1;
+        }
+    }
+    return { values };
+}
+function requireString(args, key) {
+    const value = args.values[key];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`Missing required --${key}. ${USAGE}`);
+    }
+    return value;
+}
+function stringArg(args, key) {
+    const value = args.values[key];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function printHumanSummary(result) {
+    console.log(`cogmem transcript normalization ${result.dryRun ? 'dry-run' : 'complete'}`);
+    console.log(`input: ${result.inputPath}`);
+    console.log(`output: ${result.outputPath}`);
+    console.log(`family: ${result.family}`);
+    console.log(`messages: ${result.messageCount}`);
+    console.log(`source refs: ${result.sourceRefCount}`);
+    console.log(`written: ${result.written}`);
+}
+if (import.meta.main) {
+    runNormalizeTranscript(process.argv.slice(2)).catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/dist/bin/openclaw.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=openclaw.d.ts.map

package/dist/bin/openclaw.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env bun
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { defaultOpenClawAutoMemoryPluginDir, inspectOpenClawAutoMemoryPlugin, } from '../host/openclaw/AutoMemoryPluginInstaller.js';
+function readArg(name) {
+    const index = process.argv.indexOf(name);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+function hasFlag(name) {
+    return process.argv.includes(name);
+}
+function usage() {
+    return [
+        'Usage: cogmem openclaw diagnose --workspace <workspace> [--plugin-dir <dir>] [--json]',
+        '',
+        'Diagnoses the generated OpenClaw Cogmem plugin without opening the Cogmem database.',
+    ].join('\n');
+}
+function readAudit(workspaceRoot) {
+    const logPath = join(workspaceRoot, '.cogmem', 'logs', 'openclaw-auto-memory.jsonl');
+    if (!existsSync(logPath))
+        return { logPath, recentErrors: [] };
+    const records = readFileSync(logPath, 'utf8')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .slice(-500)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((record) => Boolean(record));
+    return {
+        logPath,
+        lastBeforePromptBuild: records.slice().reverse().find((record) => record.hook === 'before_prompt_build'),
+        recentErrors: records.filter((record) => record.action === 'error').slice(-20),
+    };
+}
+function main() {
+    const [command] = process.argv.slice(2).filter((arg) => !arg.startsWith('--'));
+    if (command !== 'diagnose' || hasFlag('--help') || hasFlag('-h')) {
+        console.log(usage());
+        process.exit(command === 'diagnose' ? 0 : 1);
+    }
+    const workspace = readArg('--workspace');
+    if (!workspace)
+        throw new Error(`Missing --workspace.\n${usage()}`);
+    const workspaceRoot = resolve(workspace);
+    const pluginDir = readArg('--plugin-dir') || defaultOpenClawAutoMemoryPluginDir(workspaceRoot);
+    const plugin = inspectOpenClawAutoMemoryPlugin({ workspaceRoot, pluginDir });
+    const audit = readAudit(workspaceRoot);
+    const payload = {
+        schemaVersion: 'cogmem.cli.v1',
+        command: 'openclaw diagnose',
+        workspaceRoot,
+        plugin,
+        audit,
+    };
+    if (hasFlag('--json')) {
+        console.log(JSON.stringify(payload));
+        return;
+    }
+    console.log(`OpenClaw workspace: ${workspaceRoot}`);
+    console.log(`plugin: ${plugin.current ? 'current' : plugin.installed ? 'stale' : 'missing'} ${plugin.pluginDir}`);
+    if (audit.lastBeforePromptBuild) {
+        console.log(`last before_prompt_build: action=${audit.lastBeforePromptBuild.action || 'unknown'} reason=${audit.lastBeforePromptBuild.reason || ''}`);
+    }
+    else {
+        console.log('last before_prompt_build: none');
+    }
+}
+main();

package/dist/bin/prospective.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=prospective.d.ts.map

package/dist/bin/prospective.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env bun
+import { createMemoryKernel, createMemoryKernelFromConfig } from '../factory.js';
+import { printCliJson } from './CliJson.js';
+function parseArgs(argv) {
+    const [command, ...rest] = argv;
+    const values = new Map();
+    for (let index = 0; index < rest.length; index += 1) {
+        const item = rest[index];
+        if (!item.startsWith('--'))
+            continue;
+        const next = rest[index + 1];
+        const value = !next || next.startsWith('--') ? 'true' : next;
+        values.set(item.slice(2), [...(values.get(item.slice(2)) ?? []), value]);
+        if (value !== 'true')
+            index += 1;
+    }
+    return { command, values };
+}
+function usage() {
+    return [
+        'Usage: cogmem prospective <list|due|create|confirm|reject|defer|complete|expire> [options]',
+        '  list --project <id> [--status pending --status confirmed]',
+        '  due --project <id> [--at <epoch-ms>]',
+        '  create --project <id> --type <type> --key <key> --title <text> --evidence <eventId> [--due <epoch-ms>]',
+        '  confirm --project <id> --id <candidateId> --evidence <userEventId>',
+        '  reject|complete|expire --project <id> --id <candidateId>',
+        '  defer --project <id> --id <candidateId> --until <epoch-ms>',
+        '  Common: --config <config.toml> | --db <memory.db> --json',
+        'This command manages candidates only. It never executes tasks or tools.',
+    ].join('\n');
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (!args.command || args.command === 'help' || args.values.has('help')) {
+        console.log(usage());
+        return;
+    }
+    const dbPath = args.values.get('db')?.[0];
+    const configPath = args.values.get('config')?.[0];
+    const kernel = dbPath ? createMemoryKernel({ dbPath }) : createMemoryKernelFromConfig({ configPath });
+    try {
+        const service = kernel.prospectiveMemoryService;
+        const projectId = args.values.get('project')?.[0];
+        let result;
+        if (args.command === 'list') {
+            if (!projectId)
+                throw new Error('--project is required');
+            result = service.list({ projectId, statuses: args.values.get('status') });
+        }
+        else if (args.command === 'due') {
+            if (!projectId)
+                throw new Error('--project is required');
+            result = service.listDue({ projectId, atTime: numberValue(args.values, 'at') });
+        }
+        else if (args.command === 'create') {
+            const candidateType = args.values.get('type')?.[0];
+            const canonicalKey = args.values.get('key')?.[0];
+            const title = args.values.get('title')?.[0];
+            const evidenceEventIds = args.values.get('evidence') ?? [];
+            if (!projectId || !candidateType || !canonicalKey || !title || evidenceEventIds.length === 0) {
+                throw new Error('create requires --project --type --key --title and at least one --evidence');
+            }
+            result = service.propose({
+                projectId, candidateType, canonicalKey, title, evidenceEventIds,
+                details: args.values.get('details')?.[0],
+                proposedBy: args.values.get('proposed-by')?.[0] ?? 'operator',
+                dueAt: numberValue(args.values, 'due'),
+            });
+        }
+        else {
+            const candidateId = args.values.get('id')?.[0];
+            if (!candidateId)
+                throw new Error('--id is required');
+            if (!projectId)
+                throw new Error('--project is required');
+            if (args.command === 'confirm') {
+                const evidence = args.values.get('evidence')?.[0];
+                if (!evidence)
+                    throw new Error('confirm requires --evidence <userEventId>');
+                result = service.resolve(candidateId, { action: 'confirm', confirmationEvidenceEventId: evidence }, projectId);
+            }
+            else if (args.command === 'reject')
+                result = service.resolve(candidateId, { action: 'reject' }, projectId);
+            else if (args.command === 'complete')
+                result = service.resolve(candidateId, { action: 'complete' }, projectId);
+            else if (args.command === 'expire')
+                result = service.resolve(candidateId, { action: 'expire' }, projectId);
+            else if (args.command === 'defer') {
+                const deferredUntil = numberValue(args.values, 'until');
+                if (deferredUntil === undefined)
+                    throw new Error('defer requires --until <epoch-ms>');
+                result = service.resolve(candidateId, { action: 'defer', deferredUntil }, projectId);
+            }
+            else
+                throw new Error(`unknown prospective command: ${args.command}`);
+        }
+        printCliJson(`prospective.${String(args.command)}`, result);
+    }
+    finally {
+        kernel.close();
+    }
+}
+function numberValue(values, key) {
+    const value = values.get(key)?.[0];
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`--${key} must be a finite number`);
+    return parsed;
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/bin/re-embed.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=re-embed.d.ts.map

package/dist/bin/re-embed.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+import Database from 'bun:sqlite';
+import { NeuronEmbeddingStore } from '../embedding/NeuronEmbeddingStore.js';
+import { loadCogmemConfig, resolveCogmemConfigPath } from '../config/CogmemConfig.js';
+import { printCliJson } from './CliJson.js';
+function parseArgs(argv) {
+    const args = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const item = argv[index];
+        if (!item.startsWith('--'))
+            continue;
+        const key = item.slice(2);
+        const next = argv[index + 1];
+        if (!next || next.startsWith('--')) {
+            args[key] = true;
+        }
+        else {
+            args[key] = next;
+            index += 1;
+        }
+    }
+    return args;
+}
+const [command, ...rest] = process.argv.slice(2);
+const args = parseArgs(rest);
+if (command !== 'status') {
+    console.error('Usage: re-embed.ts status --db <cogmem.db>');
+    process.exit(1);
+}
+const configPath = typeof args.config === 'string' ? args.config : undefined;
+const resolution = configPath ? resolveCogmemConfigPath({ configPath }) : resolveCogmemConfigPath();
+const loaded = resolution.kind === 'toml' ? loadCogmemConfig({ configPath: resolution.path }) : undefined;
+const dbPath = typeof args.db === 'string' ? args.db : loaded?.options.dbPath ?? './cogmem.db';
+const db = new Database(dbPath);
+const store = new NeuronEmbeddingStore(db);
+const progress = store.getProgress();
+const completedOrFailed = progress.completed + progress.failed;
+const status = {
+    isRunning: false,
+    dbPath,
+    ...progress,
+    percentComplete: progress.total === 0 ? 100 : Math.min(100, (completedOrFailed / progress.total) * 100),
+    estimatedRemainingMs: null,
+};
+printCliJson('re-embed.status', status);
+db.close();

package/dist/bin/repair.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env bun
+export {};
+//# sourceMappingURL=repair.d.ts.map