cogmem 3.6.2

package/dist/bin/connect.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env bun
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { printCliJson } from './CliJson.js';
+import { installOpenClawAutoMemoryPlugin, } from '../host/openclaw/AutoMemoryPluginInstaller.js';
+const HERMES_COGMEM_TOOLS = [
+    'cogmem_remember_turn',
+    'cogmem_recall',
+    'cogmem_explain_recall',
+    'cogmem_strategy_plan',
+    'cogmem_episode_append',
+    'cogmem_episode_import',
+    'cogmem_episode_status',
+    'cogmem_topic_list',
+    'cogmem_topic_operate',
+    'cogmem_topic_rollback',
+    'cogmem_episode_repair',
+    'cogmem_episode_seal',
+    'cogmem_dream_tick',
+    'cogmem_dream_status',
+    'cogmem_memory_map',
+    'cogmem_graph_overview',
+    'cogmem_graph_search',
+    'cogmem_graph_explore',
+    'cogmem_graph_node',
+    'cogmem_graph_neighbors',
+    'cogmem_graph_path',
+    'cogmem_graph_timeline',
+    'cogmem_graph_touch',
+    'cogmem_candidate_review',
+    'cogmem_maintenance_tick',
+    'cogmem_prospective',
+];
+function readArgs(argv) {
+    const values = {};
+    const positionals = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const item = argv[index];
+        if (!item.startsWith('--')) {
+            positionals.push(item);
+            continue;
+        }
+        const next = argv[index + 1];
+        const key = item.slice(2);
+        if (!next || next.startsWith('--')) {
+            values[key] = true;
+            continue;
+        }
+        values[key] = next;
+        index += 1;
+    }
+    const rawAgent = positionals[0];
+    const agent = rawAgent === 'openclaw' || rawAgent === 'hermes' ? rawAgent : undefined;
+    return {
+        agent,
+        workspaceRoot: resolve(stringValue(values.workspace) || '.'),
+        configPath: stringValue(values.config),
+        openclawConfigPath: stringValue(values['openclaw-config']),
+        hermesConfigPath: stringValue(values['hermes-config']),
+        pluginDir: stringValue(values['plugin-dir']),
+        bunPath: stringValue(values.bun),
+        projectId: stringValue(values.project),
+        agentId: stringValue(values['agent-id']),
+        outputPath: stringValue(values.output),
+        auto: values.auto === true,
+        dryRun: values['dry-run'] === true,
+        force: values.force === true,
+        json: values.json === true,
+        help: values.help === true || values.h === true,
+    };
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function packageRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+}
+function templatePathFor(agent) {
+    return join(packageRoot(), 'examples', `${agent}-backend`, 'SKILL.md');
+}
+function operationsTemplatePathFor(agent) {
+    return join(packageRoot(), 'examples', `${agent}-backend`, 'references', 'operations.md');
+}
+function defaultSkillPath(agent, workspaceRoot) {
+    if (agent === 'openclaw') {
+        return join(workspaceRoot, 'skills', 'cogmem-memory', 'SKILL.md');
+    }
+    return join(process.env.HOME || homedir(), '.hermes', 'skills', 'cogmem-memory', 'SKILL.md');
+}
+function nextCommands(agent) {
+    if (agent === 'openclaw') {
+        return [
+            './node_modules/.bin/cogmem-init --agent openclaw --scope project',
+            './node_modules/.bin/cogmem-doctor',
+            './node_modules/.bin/cogmem-import-openclaw --workspace . --project openclaw --dry-run',
+            './node_modules/.bin/cogmem-import-openclaw --workspace . --project openclaw',
+            './node_modules/.bin/cogmem-connect openclaw --workspace . --auto --force',
+        ];
+    }
+    return [
+        './node_modules/.bin/cogmem-init --agent hermes',
+        './node_modules/.bin/cogmem-doctor',
+        './node_modules/.bin/cogmem-connect hermes --workspace . --auto --force',
+        './node_modules/.bin/cogmem-import-hermes --workspace . --project hermes --dry-run',
+        './node_modules/.bin/cogmem-import-hermes --workspace . --project hermes',
+    ];
+}
+function usage() {
+    return [
+        'Usage: cogmem-connect <openclaw|hermes> [--workspace <dir>] [--output <SKILL.md>] [--auto] [--config <config.toml>] [--openclaw-config <openclaw.json>] [--hermes-config <config.yaml>] [--dry-run] [--force] [--json]',
+        '',
+        'Installs the agent-facing cogmem memory skill bundle into:',
+        '  OpenClaw: <workspace>/skills/cogmem-memory/',
+        '  Hermes:   ~/.hermes/skills/cogmem-memory/',
+        '',
+        'The bundle includes SKILL.md plus references/operations.md with migration, import, recall, Atlas, governance, repair, and backup commands.',
+        'For OpenClaw, pass --auto to install the local automatic recall/remember plugin wrapper and patch OpenClaw plugin config.',
+        'For Hermes, pass --auto to patch ~/.hermes/config.yaml with a cogmem MCP server entry.',
+    ].join('\n');
+}
+function hostConfigSnippet(agent, workspaceRoot, auto) {
+    if (agent === 'openclaw') {
+        if (auto) {
+            return [
+                '// cogmem-connect openclaw --auto installs a local OpenClaw plugin wrapper.',
+                '// The wrapper registers before_prompt_build for governed recall and agent_end for turn recording.',
+                '// It calls KernelAgentMemoryBackend through cogmem public API via a Bun bridge.',
+                '// Restart the OpenClaw Gateway after changing plugin code, hook policy, or plugins.load.paths.',
+            ].join('\n');
+        }
+        return [
+            '// cogmem-connect does not modify OpenClaw host config.',
+            '// It installs a workspace skill at <workspace>/skills/cogmem-memory/SKILL.md.',
+            '// Current OpenClaw memory config is owned by OpenClaw, for example memory.backend = "builtin" | "qmd".',
+            '// Do not write unknown OpenClaw config fields for cogmem.',
+            '// Add host config only after installing a real OpenClaw plugin wrapper with a valid manifest/schema.',
+        ].join('\n');
+    }
+    const mcpBin = resolveCogmemMcpCommand(workspaceRoot);
+    return [
+        'mcp_servers:',
+        '  cogmem:',
+        `    command: "${mcpBin}"`,
+        '    args: []',
+        '    enabled: true',
+        '    tools:',
+        '      include:',
+        ...HERMES_COGMEM_TOOLS.map((tool) => `        - ${tool}`),
+    ].join('\n');
+}
+function resolveCogmemMcpCommand(workspaceRoot) {
+    if (process.env.COGMEM_MCP_BIN)
+        return process.env.COGMEM_MCP_BIN;
+    const workspaceBin = join(workspaceRoot, 'node_modules', '.bin', 'cogmem-mcp');
+    if (existsSync(workspaceBin))
+        return workspaceBin;
+    const pathValue = process.env.PATH || '';
+    for (const segment of pathValue.split(':')) {
+        if (!segment)
+            continue;
+        const candidate = join(segment, 'cogmem-mcp');
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return 'cogmem-mcp';
+}
+function installSkill(args) {
+    if (!args.agent)
+        throw new Error(usage());
+    const templatePath = templatePathFor(args.agent);
+    const operationsTemplatePath = operationsTemplatePathFor(args.agent);
+    for (const requiredPath of [templatePath, operationsTemplatePath]) {
+        if (!existsSync(requiredPath)) {
+            throw new Error(`Missing packaged skill template: ${requiredPath}`);
+        }
+    }
+    const template = readFileSync(templatePath, 'utf8');
+    const operationsTemplate = readFileSync(operationsTemplatePath, 'utf8');
+    const skillPath = resolve(args.outputPath || defaultSkillPath(args.agent, args.workspaceRoot));
+    const operationsPath = join(dirname(skillPath), 'references', 'operations.md');
+    const skillFiles = [skillPath, operationsPath];
+    const alreadyCurrent = existsSync(skillPath)
+        && readFileSync(skillPath, 'utf8') === template
+        && existsSync(operationsPath)
+        && readFileSync(operationsPath, 'utf8') === operationsTemplate;
+    let autoMemory;
+    let hermesMcp;
+    if (!args.dryRun && !alreadyCurrent) {
+        if (existsSync(skillPath) && !args.force) {
+            throw new Error(`Skill already exists at ${skillPath}. Re-run with --force to overwrite.`);
+        }
+        mkdirSync(dirname(skillPath), { recursive: true });
+        writeFileSync(skillPath, template, 'utf8');
+        mkdirSync(dirname(operationsPath), { recursive: true });
+        writeFileSync(operationsPath, operationsTemplate, 'utf8');
+    }
+    if (args.agent === 'openclaw' && args.auto) {
+        autoMemory = installOpenClawAutoMemoryPlugin({
+            workspaceRoot: args.workspaceRoot,
+            configPath: args.configPath,
+            openclawConfigPath: args.openclawConfigPath,
+            pluginDir: args.pluginDir,
+            bunPath: args.bunPath,
+            projectId: args.projectId,
+            agentId: args.agentId,
+            dryRun: args.dryRun,
+            force: args.force,
+        });
+    }
+    else if (args.agent === 'hermes' && args.auto) {
+        hermesMcp = installHermesMcpConfig({
+            workspaceRoot: args.workspaceRoot,
+            configPath: args.hermesConfigPath,
+            dryRun: args.dryRun,
+            force: args.force,
+        });
+    }
+    return {
+        agent: args.agent,
+        workspaceRoot: args.workspaceRoot,
+        skillPath,
+        skillFiles,
+        templatePath,
+        dryRun: args.dryRun,
+        installed: !args.dryRun && !alreadyCurrent,
+        alreadyCurrent,
+        nextCommands: nextCommands(args.agent),
+        hostConfigSnippet: hostConfigSnippet(args.agent, args.workspaceRoot, args.auto),
+        autoMemory,
+        hermesMcp,
+    };
+}
+function defaultHermesConfigPath(env = process.env) {
+    return join(env.HOME || homedir(), '.hermes', 'config.yaml');
+}
+function installHermesMcpConfig(input) {
+    const configPath = resolve(input.configPath || defaultHermesConfigPath());
+    const serverCommand = resolveCogmemMcpCommand(resolve(input.workspaceRoot));
+    const original = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
+    const patched = patchHermesMcpConfig(original, serverCommand);
+    const changed = patched !== original;
+    let backupPath;
+    if (!input.dryRun && (changed || input.force)) {
+        mkdirSync(dirname(configPath), { recursive: true });
+        if (existsSync(configPath)) {
+            backupPath = `${configPath}.cogmem.bak-${Date.now()}`;
+            writeFileSync(backupPath, original, 'utf8');
+        }
+        writeFileSync(configPath, patched, 'utf8');
+    }
+    return {
+        enabled: true,
+        configPath,
+        serverCommand,
+        dryRun: input.dryRun,
+        configUpdated: changed || input.force,
+        backupPath,
+    };
+}
+function patchHermesMcpConfig(original, serverCommand) {
+    if (/^\s+cogmem\s*:/m.test(original) && original.includes('cogmem-mcp')) {
+        return patchExistingHermesCogmemConfig(original);
+    }
+    const lines = original.replace(/\r\n/g, '\n').split('\n');
+    const serverBlock = [
+        '  cogmem:',
+        `    command: "${serverCommand}"`,
+        '    args: []',
+        '    enabled: true',
+        '    tools:',
+        '      include:',
+        ...HERMES_COGMEM_TOOLS.map((tool) => `        - ${tool}`),
+    ];
+    const mcpIndex = lines.findIndex((line) => /^mcp_servers\s*:\s*(?:\{\})?\s*$/.test(line.trim()));
+    if (mcpIndex === -1) {
+        const prefix = original.trimEnd();
+        return `${prefix}${prefix ? '\n\n' : ''}mcp_servers:\n${serverBlock.join('\n')}\n`;
+    }
+    lines[mcpIndex] = 'mcp_servers:';
+    let insertAt = mcpIndex + 1;
+    while (insertAt < lines.length) {
+        const line = lines[insertAt];
+        if (line.trim() && !line.startsWith(' ') && !line.startsWith('\t') && !line.trim().startsWith('#'))
+            break;
+        insertAt += 1;
+    }
+    lines.splice(insertAt, 0, ...serverBlock);
+    return `${lines.join('\n').replace(/\n+$/u, '')}\n`;
+}
+function patchExistingHermesCogmemConfig(original) {
+    const lines = original.replace(/\r\n/g, '\n').split('\n');
+    const cogmemIndex = lines.findIndex((line) => /^\s+cogmem\s*:\s*$/.test(line));
+    if (cogmemIndex === -1)
+        return original.endsWith('\n') ? original : `${original}\n`;
+    const cogmemIndent = leadingSpaces(lines[cogmemIndex]);
+    let blockEnd = cogmemIndex + 1;
+    while (blockEnd < lines.length) {
+        const line = lines[blockEnd];
+        if (line.trim()
+            && !line.trim().startsWith('#')
+            && leadingSpaces(line) <= cogmemIndent) {
+            break;
+        }
+        blockEnd += 1;
+    }
+    const block = lines.slice(cogmemIndex, blockEnd);
+    const existingTools = new Set();
+    for (const line of block) {
+        const match = line.match(/^\s*-\s*(cogmem_[\w-]+)\s*$/);
+        if (match?.[1])
+            existingTools.add(match[1]);
+    }
+    const missing = HERMES_COGMEM_TOOLS.filter((tool) => !existingTools.has(tool));
+    if (missing.length === 0)
+        return `${lines.join('\n').replace(/\n+$/u, '')}\n`;
+    const includeRelativeIndex = block.findIndex((line) => /^\s+include\s*:\s*$/.test(line));
+    if (includeRelativeIndex !== -1) {
+        const includeIndex = cogmemIndex + includeRelativeIndex;
+        const includeIndent = leadingSpaces(lines[includeIndex]);
+        let insertAt = includeIndex + 1;
+        while (insertAt < blockEnd) {
+            const line = lines[insertAt];
+            if (!line.trim()) {
+                insertAt += 1;
+                continue;
+            }
+            if (leadingSpaces(line) <= includeIndent)
+                break;
+            if (!/^\s*-\s*/.test(line) && leadingSpaces(line) <= includeIndent + 2)
+                break;
+            insertAt += 1;
+        }
+        const itemIndent = `${' '.repeat(includeIndent + 2)}`;
+        lines.splice(insertAt, 0, ...missing.map((tool) => `${itemIndent}- ${tool}`));
+        return `${lines.join('\n').replace(/\n+$/u, '')}\n`;
+    }
+    const childIndent = `${' '.repeat(cogmemIndent + 2)}`;
+    const includeIndent = `${' '.repeat(cogmemIndent + 4)}`;
+    const itemIndent = `${' '.repeat(cogmemIndent + 6)}`;
+    lines.splice(blockEnd, 0, `${childIndent}tools:`, `${includeIndent}include:`, ...HERMES_COGMEM_TOOLS.map((tool) => `${itemIndent}- ${tool}`));
+    return `${lines.join('\n').replace(/\n+$/u, '')}\n`;
+}
+function leadingSpaces(line) {
+    return line.match(/^\s*/)?.[0].length ?? 0;
+}
+function printHuman(result) {
+    console.log(`cogmem ${result.agent} skill ${result.dryRun ? 'dry-run' : result.installed ? 'installed' : 'already current'}`);
+    console.log(`workspace: ${result.workspaceRoot}`);
+    console.log(`skill: ${result.skillPath}`);
+    console.log(`reference: ${result.skillFiles[1]}`);
+    console.log('');
+    console.log('Host config snippet:');
+    console.log(result.hostConfigSnippet);
+    if (result.autoMemory) {
+        console.log('');
+        console.log('OpenClaw automatic memory plugin:');
+        console.log(`  plugin: ${result.autoMemory.pluginDir}`);
+        console.log(`  config: ${result.autoMemory.openclawConfigPath}`);
+        console.log(`  hooks: ${result.autoMemory.hookNames.join(', ')}`);
+        if (result.autoMemory.backupPath)
+            console.log(`  backup: ${result.autoMemory.backupPath}`);
+    }
+    if (result.hermesMcp) {
+        console.log('');
+        console.log('Hermes MCP integration:');
+        console.log(`  config: ${result.hermesMcp.configPath}`);
+        console.log(`  command: ${result.hermesMcp.serverCommand}`);
+        if (result.hermesMcp.backupPath)
+            console.log(`  backup: ${result.hermesMcp.backupPath}`);
+        console.log('  reload: /reload-mcp');
+    }
+    console.log('');
+    console.log('Next commands:');
+    for (const command of result.nextCommands) {
+        console.log(`  ${command}`);
+    }
+    console.log('');
+    console.log('Then let the agent read the installed SKILL.md before changing runtime wiring.');
+}
+async function main() {
+    const args = readArgs(process.argv.slice(2));
+    if (args.help) {
+        console.log(usage());
+        return;
+    }
+    const result = installSkill(args);
+    if (args.json) {
+        printCliJson(`connect.${result.agent}`, result);
+        return;
+    }
+    printHuman(result);
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/bin/doctor.d.ts

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

package/dist/bin/doctor.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env bun
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadCogmemConfig, resolveCogmemConfigPath } from '../config/CogmemConfig.js';
+import { createMemoryKernelFromConfig } from '../factory.js';
+import { defaultOpenClawAutoMemoryPluginDir, inspectOpenClawAutoMemoryPlugin, installOpenClawAutoMemoryPlugin, } from '../host/openclaw/AutoMemoryPluginInstaller.js';
+import { compactStorage } from '../storage/StorageCompactor.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 ok(message) {
+    console.log(`OK ${message}`);
+}
+function warn(code, message) {
+    console.log(`WARN ${code}: ${message}`);
+}
+function printWarnings(diagnostics) {
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.severity === 'warning')
+            warn(diagnostic.code, diagnostic.message);
+    }
+}
+function fail(message) {
+    console.error(`FAIL ${message}`);
+    process.exit(1);
+}
+const configPath = readArg('--config');
+const envPath = readArg('--env-path');
+const fix = hasFlag('--fix');
+const agent = readArg('--agent');
+const workspace = readArg('--workspace');
+const openclawConfigPath = readArg('--openclaw-config');
+const pluginDir = readArg('--plugin-dir');
+const bunPath = readArg('--bun');
+const storage = hasFlag('--storage');
+const pluginOnly = hasFlag('--plugin-only');
+const json = hasFlag('--json');
+if (envPath) {
+    fail('--env-path is no longer supported. Use cogmem-init to create .cogmem/config.toml, then run cogmem-doctor --config <config.toml>.');
+}
+else {
+    const resolution = resolveCogmemConfigPath({ configPath });
+    if (resolution.kind === 'missing')
+        fail(`missing config file: ${resolution.path}`);
+    const loaded = loadCogmemConfig({ configPath: resolution.path });
+    const error = loaded.diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+    if (error)
+        fail(`${error.code}: ${error.message}`);
+    if (pluginOnly) {
+        if (agent && agent !== 'openclaw')
+            fail('doctor --plugin-only currently supports --agent openclaw.');
+        const workspaceRoot = workspace || loaded.integrations.openclaw.workspaceDir || process.cwd();
+        let fixed = undefined;
+        if (fix) {
+            fixed = installOpenClawAutoMemoryPlugin({
+                workspaceRoot,
+                configPath: resolution.path,
+                openclawConfigPath,
+                pluginDir,
+                bunPath,
+                force: true,
+            });
+        }
+        const inspection = inspectOpenClawAutoMemoryPlugin({
+            workspaceRoot,
+            pluginDir: pluginDir || defaultOpenClawAutoMemoryPluginDir(workspaceRoot),
+        });
+        const audit = readLatestOpenClawAudit(workspaceRoot);
+        if (json) {
+            console.log(JSON.stringify({
+                schemaVersion: 'cogmem.cli.v1',
+                command: 'doctor',
+                pluginOnly: true,
+                configPath: resolution.path,
+                openclaw: { plugin: inspection, fixed, audit },
+            }));
+        }
+        else {
+            printWarnings(loaded.diagnostics);
+            ok('configuration parsed');
+            ok(`openclaw plugin ${inspection.current ? 'current' : 'stale'} at ${inspection.pluginDir}`);
+            if (!inspection.current)
+                warn('openclaw_plugin_stale', 'Run cogmem doctor --fix --agent openclaw --plugin-only --workspace <workspace>.');
+            if (fixed)
+                ok(`openclaw auto memory integration fixed at ${fixed.pluginDir}`);
+            if (audit.lastBeforePromptBuild)
+                ok(`last before_prompt_build action=${audit.lastBeforePromptBuild.action || 'unknown'} reason=${audit.lastBeforePromptBuild.reason || ''}`);
+        }
+        process.exit(0);
+    }
+    printWarnings(loaded.diagnostics);
+    ok('configuration parsed');
+    ok(`cogmem home ${loaded.homeDir}`);
+    const kernel = createMemoryKernelFromConfig({ configPath: resolution.path });
+    const health = kernel.getHealthStatus();
+    if (health.package !== 'cogmem')
+        fail('unexpected package identity');
+    ok(`kernel ready at ${health.dbPath}`);
+    kernel.close();
+    if (storage) {
+        const storageStats = compactStorage({
+            dbPath: health.dbPath,
+            dryRun: true,
+            dimension: loaded.options.vectorDimension,
+        });
+        ok([
+            `storage raw_events=${storageStats.rawEventsBefore}`,
+            `vectors=${storageStats.vectorCountBefore}`,
+            `vector_bytes=${storageStats.vectorBytesBefore}`,
+            `eligible_vector_bytes=${storageStats.eligibleVectorBytes}`,
+            `vector_bytes_per_raw_event=${storageStats.vectorBytesPerRawEventBefore.toFixed(2)}`,
+        ].join(' '));
+        if (storageStats.rawEventsBefore > 0 && storageStats.vectorBytesPerRawEventBefore >= 8192) {
+            warn('vector_storage_growth', 'Vector bytes per raw event are high; consider selective_compile/raw_then_dream and cogmem compact --dry-run.');
+        }
+    }
+    if (fix) {
+        if (agent !== 'openclaw') {
+            fail('doctor --fix currently requires --agent openclaw.');
+        }
+        const result = installOpenClawAutoMemoryPlugin({
+            workspaceRoot: workspace || loaded.integrations.openclaw.workspaceDir || process.cwd(),
+            configPath: resolution.path,
+            openclawConfigPath,
+            pluginDir,
+            bunPath,
+            force: true,
+        });
+        ok(`openclaw auto memory integration fixed at ${result.pluginDir}`);
+        ok(`openclaw config patched at ${result.openclawConfigPath}`);
+    }
+    if (agent === 'openclaw' || workspace) {
+        const workspaceRoot = workspace || loaded.integrations.openclaw.workspaceDir || process.cwd();
+        const inspection = inspectOpenClawAutoMemoryPlugin({
+            workspaceRoot,
+            pluginDir: pluginDir || defaultOpenClawAutoMemoryPluginDir(workspaceRoot),
+        });
+        if (inspection.installed) {
+            ok(`openclaw plugin ${inspection.current ? 'current' : 'stale'} at ${inspection.pluginDir}`);
+            if (!inspection.current)
+                warn('openclaw_plugin_stale', 'Run cogmem connect openclaw --workspace <workspace> --auto --force or cogmem doctor --fix --agent openclaw --plugin-only.');
+        }
+        const audit = readLatestOpenClawAudit(workspaceRoot);
+        if (audit.lastBeforePromptBuild) {
+            ok(`last before_prompt_build action=${audit.lastBeforePromptBuild.action || 'unknown'} reason=${audit.lastBeforePromptBuild.reason || ''}`);
+        }
+    }
+}
+function readLatestOpenClawAudit(workspaceRoot) {
+    const logPath = join(workspaceRoot, '.cogmem', 'logs', 'openclaw-auto-memory.jsonl');
+    if (!existsSync(logPath))
+        return {};
+    const lines = readFileSync(logPath, 'utf8').split('\n').map((line) => line.trim()).filter(Boolean).slice(-200);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        try {
+            const record = JSON.parse(lines[index]);
+            if (record.hook === 'before_prompt_build')
+                return { lastBeforePromptBuild: record };
+        }
+        catch {
+            // Ignore malformed audit rows.
+        }
+    }
+    return {};
+}

package/dist/bin/dream.d.ts

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

package/dist/bin/dream.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env bun
+import { createMemoryKernel, createMemoryKernelFromConfig } from '../factory.js';
+import { printCliJson } from './CliJson.js';
+function parseArgs(argv) {
+    const [command, ...rest] = argv;
+    const args = { command };
+    for (let index = 0; index < rest.length; index += 1) {
+        const item = rest[index];
+        if (!item.startsWith('--'))
+            continue;
+        const key = item.slice(2);
+        const next = rest[index + 1];
+        if (!next || next.startsWith('--'))
+            args[key] = true;
+        else {
+            args[key] = next;
+            index += 1;
+        }
+    }
+    return args;
+}
+function usage() {
+    return [
+        'Usage: cogmem dream <tick|status|retry> [args]',
+        '  tick [--project <id>] [--mode auto|micro|normal|deep] [--max-episodes <n>] [--json]',
+        '  status [--project <id>] [--json]',
+        '  retry [--project <id>] [--json]',
+        'A tick is explicit and conditional. It processes sealed episodes only and never executes tools.',
+        '--json emits cogmem.cli.v1 with command payload fields at the top level.',
+    ].join('\n');
+}
+function openKernel(args) {
+    const dbPath = stringArg(args, 'db');
+    return dbPath ? createMemoryKernel({ dbPath }) : createMemoryKernelFromConfig({ configPath: stringArg(args, 'config'), cwd: process.cwd() });
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (!args.command || args.help === true || args.h === true) {
+        console.log(usage());
+        return;
+    }
+    const kernel = openKernel(args);
+    try {
+        const projectId = stringArg(args, 'project');
+        const result = args.command === 'tick'
+            ? await kernel.runDreamTick({ projectId, mode: modeArg(stringArg(args, 'mode')), maxEpisodes: numberArg(args, 'max-episodes') })
+            : args.command === 'status'
+                ? kernel.getEpisodeDreamStatus(projectId)
+                : args.command === 'retry'
+                    ? { retried: kernel.retryFailedEpisodeDreams(projectId), status: kernel.getEpisodeDreamStatus(projectId) }
+                    : (() => { throw new Error(usage()); })();
+        printCliJson(`dream.${args.command}`, result);
+    }
+    finally {
+        kernel.close();
+    }
+}
+function stringArg(args, key) { return typeof args[key] === 'string' && args[key] ? args[key] : undefined; }
+function numberArg(args, key) { const value = stringArg(args, key); if (!value)
+    return undefined; const parsed = Number(value); if (!Number.isFinite(parsed))
+    throw new Error(`--${key} must be numeric`); return parsed; }
+function modeArg(value) { if (!value)
+    return undefined; if (value === 'auto' || value === 'micro' || value === 'normal' || value === 'deep')
+    return value; throw new Error('mode must be auto, micro, normal, or deep'); }
+main().catch((error) => { console.error(error instanceof Error ? error.message : String(error)); process.exit(1); });

package/dist/bin/episode.d.ts

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