cogmem 3.6.2 → 3.6.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 3.6.4
+
+- Fixed OpenClaw/Hermes imports so empty imported episode boundaries are not batch-sealed into Dream work, and mature empty soft seals no longer abort `dream tick`.
+- Added Dream queue cleanup for legacy empty episode jobs so one bad upgraded/imported episode is marked skipped and does not consume maintenance batch slots.
+- Updated OpenClaw and Hermes auto-installed skills, runbooks, and README examples to prefer npm workspace-local installs, reserve `cogmem init` for interactive operator setup, and document the full import -> dream -> candidate governance -> `needs_confirmation` review flow.
+- Standardized MCP guidance on `cogmem mcp` for new Hermes/OpenClaw host configs while keeping `cogmem-mcp` as a compatibility bin for existing configs.
+
+## 3.6.3
+
+- Added a GitHub Release `published` workflow for npm Trusted Publishing with OIDC provenance, full tests, build, version-tag validation, and package dry-run verification before `npm publish`.
+- Fixed `cogmem migrate --dry-run` so it opens SQLite read-only and plans legacy `_meta.schema_version` adoption without creating `_schema_migrations` or writing migration rows.
+- Hardened `cogmem update` target resolution for npm global installs, one-line installer homes, local project dependencies, and source checkouts so `cogmem update --yes` does not silently install into an arbitrary current directory.
+- Updated OpenClaw diagnostics and generated bridge behavior to propagate `rememberDrainTimeoutMs`, recover stale `.processing` queue files, and report pending/dead/lock/processing queue state.
+
 ## 3.6.2
 
 - Switched the public distribution channel to the npm registry while keeping GitHub as the source and review mirror.

package/CONTRIBUTING.md

@@ -18,10 +18,10 @@ bun run typecheck
 bun test
 npm pack --dry-run --json
 npm publish --dry-run --access public
-npm publish --access public
+npm publish --provenance --access public
 ```
 
-`cogmem` is distributed through the npm registry. Use `npm pack --dry-run --json` to verify package contents, then `npm publish --dry-run --access public` before `npm publish --access public`. Keep the GitHub branch or release synchronized for source review and for older GitHub-installed users migrating onto the npm-first updater.
+`cogmem` is distributed through the npm registry. Use `npm pack --dry-run --json` to verify package contents. Normal publishing happens by creating a GitHub Release from the matching version tag; `.github/workflows/publish.yml` is intentionally triggered by the release `published` event, not by tag pushes. Use `npm publish --provenance --access public` only as an emergency manual fallback.
 
 ## API Discipline
 

package/README.md

@@ -11,15 +11,24 @@ It is not a knowledge-base app, a note-taking app, a vector RAG wrapper, an Obsi
 
 ## Status
 
-Current version: `3.6.2`
+Current version: `3.6.4`
 
 Distribution: npm registry. GitHub remains the source mirror and hosts this installer, but package install and upgrade resolve `cogmem` from npm by default.
 
+Default workspace install:
+
+```bash
+npm install cogmem@latest --save
+./node_modules/.bin/cogmem doctor
+```
+
+One-line installer for machines that need Bun bootstrapping:
+
 ```bash
 curl -fsSL https://raw.githubusercontent.com/liuqin164/cogmem/main/install.sh | bash
 ```
 
-The installer:
+The one-line installer:
 
 1. Ensures Bun is available.
 2. Installs `cogmem@latest` from the npm registry into `~/.cogmem/pkg`.
@@ -158,10 +167,11 @@ High-dimensional vectors grow quickly. Prefer `raw_then_dream` or `selective_com
 
 ## Quick Start
 
-Install globally:
+Install into an agent workspace with npm:
 
 ```bash
-curl -fsSL https://raw.githubusercontent.com/liuqin164/cogmem/main/install.sh | bash
+npm install cogmem@latest --save
+./node_modules/.bin/cogmem doctor
 ```
 
 Or install into an existing Bun workspace:
@@ -178,6 +188,26 @@ npm install cogmem@latest
 ./node_modules/.bin/cogmem init
 ```
 
+Or install globally with npm when Bun is already on PATH:
+
+```bash
+npm install -g cogmem@latest
+cogmem init
+```
+
+Or use the one-line installer for machines that do not already have Bun:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/liuqin164/cogmem/main/install.sh | bash
+```
+
+For agent-run installs, skip the interactive wizard and connect the host explicitly:
+
+```bash
+COGMEM_SKIP_INIT=1 curl -fsSL https://raw.githubusercontent.com/liuqin164/cogmem/main/install.sh | bash
+cogmem doctor
+```
+
 Validate configuration:
 
 ```bash
@@ -190,7 +220,7 @@ Upgrade from npm and migrate an existing database:
 cogmem update --yes
 ```
 
-`cogmem update --yes` installs `cogmem@latest` from npm, then runs the newly installed `cogmem migrate --yes --backup --config <resolved-config>`. If OpenClaw is configured, the updater also runs the newly installed plugin-only repair command so stale `index.js` and `bridge.mjs` files are refreshed before you restart the agent. To inspect changes without writing:
+`cogmem update --yes` installs `cogmem@latest` from npm, then runs the newly installed `cogmem migrate --yes --backup --config <resolved-config>`. It updates npm-global installs with `npm install -g`, the one-line installer home under `~/.cogmem/pkg`, or the current workspace dependency when Cogmem is a project dependency. If OpenClaw is configured, the updater also runs the newly installed plugin-only repair command so stale `index.js` and `bridge.mjs` files are refreshed before you restart the agent. To inspect changes without writing:
 
 ```bash
 cogmem update --dry-run --json
@@ -199,7 +229,7 @@ cogmem migrate --dry-run --json
 
 For a manual migration, run `cogmem migrate --yes --backup`. The migration runner adopts the existing `_meta.schema_version`, applies only later idempotent migrations, preserves Raw Ledger rows, and creates a timestamped, transaction-consistent standalone database backup before changing an on-disk database. The backup includes committed SQLite WAL pages instead of copying only the main database file.
 
-Upgrade a 3.5.2 database, a 3.6.0 database, or a pre-release schema-25 test database into the 3.6.2 schema set with one command:
+Upgrade a 3.5.2 database, a 3.6.0 database, or a pre-release schema-25 test database into the 3.6.4 schema set with one command:
 
 ```bash
 cogmem migrate --yes --backup --json
@@ -230,9 +260,14 @@ cogmem repair project-scope --from "" --to openclaw --apply --json
 Inspect and conditionally process sealed conversation episodes:
 
 ```bash
+cogmem memory status --project my-agent --json
 cogmem episode status --project my-agent --json
-cogmem dream tick --project my-agent --mode auto --json
+cogmem dream status --project my-agent --json
+cogmem dream tick --project my-agent --mode auto --max-episodes 20 --json
+cogmem memory candidates --project my-agent --status candidate --json
 cogmem memory govern --project my-agent --json
+cogmem memory candidates --project my-agent --status needs_confirmation --json
+cogmem memory review --project my-agent --id <candidate-id> --action approve --actor <operator> --reason "confirmed" --confirmation-event <user-event-id> --json
 ```
 
 For a host timer, call `dream tick`; the timer only wakes the scheduler. An empty backlog performs no Dream work:
@@ -241,9 +276,9 @@ For a host timer, call `dream tick`; the timer only wakes the scheduler. An empt
 cogmem dream tick --project my-agent --mode auto --max-episodes 10 --json
 ```
 
-Raw events are always written first. `KernelAgentMemoryBackend` and OpenClaw plugin 0.6.2 assemble live turns automatically. The foreground hook uses deterministic rules and previous assistant/user context; background import and repair paths may use the advisory hybrid classifier. Advisory output is allow-listed and cannot directly mutate durable memory. Unknown turns now fail closed as ambiguous. Continuation requires explicit continuation language or project/topic/entity/semantic overlap; Cogmem does not route domains with an expanding hard-coded keyword dictionary.
+Raw events are always written first. `KernelAgentMemoryBackend` and OpenClaw plugin 0.6.3 assemble live turns automatically. The foreground hook uses deterministic rules and previous assistant/user context; background import and repair paths may use the advisory hybrid classifier. Advisory output is allow-listed and cannot directly mutate durable memory. Unknown turns now fail closed as ambiguous. Continuation requires explicit continuation language or project/topic/entity/semantic overlap; Cogmem does not route domains with an expanding hard-coded keyword dictionary.
 
-Hookless MCP agents can call `cogmem_episode_append` or bounded `cogmem_episode_import`. Existing OpenClaw/Hermes import commands use stable content identities and the same episode schema. Low-confidence imported groups soft-seal for review unless an operator explicitly forces sealing. Episode semantic summaries and closure receipts are control hints, never durable evidence; every Dream candidate must cite a non-empty subset of the episode's raw event IDs and still pass CPU governance.
+Hookless MCP agents can call `cogmem_episode_append` or bounded `cogmem_episode_import`. Existing OpenClaw/Hermes import commands use stable content identities and the same episode schema. Low-confidence imported groups soft-seal for review unless an operator explicitly forces sealing. Cogmem 3.6.4 skips import batch sealing for empty episode boundaries and skips legacy empty Dream jobs so one bad imported episode cannot block the queue. Episode semantic summaries and closure receipts are control hints, never durable evidence; every Dream candidate must cite a non-empty subset of the episode's raw event IDs and still pass CPU governance.
 
 User-shaped topic state is project-scoped. Explicit user operations become active and auditable; model-proposed topics, aliases, and relations remain candidates. Use MCP `cogmem_topic_list` to inspect nodes, `cogmem_topic_operate` to create, rename, alias, move, merge, split, or relate topics, and `cogmem_topic_rollback` to reverse an audited operation. Alias collisions fail closed as `needs_review`; applications can also call `TopicGovernance.rollback()` through the public API.
 
@@ -337,7 +372,7 @@ cogmem strategy plan --project hermes --query "我当时的原话是什么？" -
 cogmem strategy outcomes --project hermes --json
 ```
 
-OpenClaw plugin 0.6.2 skips Cogmem entirely for greetings, uses only session state/turn bridge for short continuations, and applies Strategy Cortex before full recall. Navigation turns use one bridge/kernel lifecycle for Atlas exploration, evidence-bearing node/timeline drill-down, and recall. The bounded volatile `<COGMEM_MEMORY_ATLAS>` block includes evidence event IDs and drill-down commands; OpenClaw does not need MCP for this path.
+OpenClaw plugin 0.6.3 skips Cogmem entirely for greetings, uses only session state/turn bridge for short continuations, and applies Strategy Cortex before full recall. Navigation turns use one bridge/kernel lifecycle for Atlas exploration, evidence-bearing node/timeline drill-down, and recall. The bounded volatile `<COGMEM_MEMORY_ATLAS>` block includes evidence event IDs and drill-down commands; OpenClaw does not need MCP for this path.
 
 `ProspectiveMemoryService` stores future intentions, commitments, reminders, open loops, and plans as candidates only. A candidate is not actionable until an explicit user event confirms it. Rejected candidates stay suppressed unless genuinely new evidence creates a new version. The service and `cogmem prospective` CLI manage state only; they expose no task or tool execution capability.
 
@@ -475,8 +510,8 @@ Hermes integration is MCP-based in this release. cogmem does not claim to be a n
 Install the skill and patch Hermes MCP config:
 
 ```bash
-cogmem init --agent hermes
-cogmem connect hermes --workspace /path/to/hermes/workspace --auto --force
+npm install cogmem@latest --save
+./node_modules/.bin/cogmem connect hermes --workspace /path/to/hermes/workspace --auto --force
 ```
 
 This installs the agent-facing skill bundle at:
@@ -494,6 +529,8 @@ With `--auto`, it adds or updates a `cogmem` MCP server entry in:
 ~/.hermes/config.yaml
 ```
 
+New Hermes configs start the server with `cogmem mcp`. Existing `cogmem-mcp` entries remain supported and are updated in place for tool allow-list changes.
+
 Then reload MCP inside Hermes:
 
 ```text
@@ -681,7 +718,7 @@ For Hermes after an update, reload the MCP server or restart the agent host. If
 cogmem connect hermes --workspace /path/to/hermes/workspace --auto --force
 ```
 
-This also updates existing Hermes `cogmem-mcp` blocks with missing strategy, episode, Dream, memory-map, maintenance, and prospective tools.
+This also updates existing Hermes MCP blocks with missing strategy, episode, Dream, memory-map, maintenance, and prospective tools. New configs use `cogmem mcp`; `cogmem-mcp` remains a compatibility bin.
 
 ## Documentation
 
@@ -703,6 +740,7 @@ Installed OpenClaw and Hermes skills include their own `references/operations.md
 cogmem init
 cogmem doctor
 cogmem connect openclaw|hermes
+cogmem mcp
 cogmem update
 cogmem memory recall|search|show|dream|govern|candidates|review|status|map|tick|bind
 cogmem memory graph|graph-search|graph-explore|graph-node|graph-neighbors|graph-path|graph-timeline
@@ -732,7 +770,15 @@ npm pack --dry-run --json
 npm publish --dry-run --access public
 ```
 
-Publish with `npm publish --access public` after the dry run and full tests pass. Keep GitHub branches/releases in sync so old GitHub-installed 3.6.1 users have a discoverable bridge to the npm-first 3.6.2 updater.
+Create a GitHub Release from the matching version tag, for example `v3.6.4`. The `.github/workflows/publish.yml` workflow publishes to npm only when the release is published, not when a tag is pushed. The npm Trusted Publisher entry must match repository `liuqin164/cogmem`, workflow file `publish.yml`, and environment `npm publish`.
+
+Publish manually only for emergency fallback:
+
+```bash
+npm publish --provenance --access public
+```
+
+Keep GitHub branches/releases in sync so old GitHub-installed users have a discoverable bridge to the npm-first updater.
 
 ## Security and Privacy
 

package/RELEASE_CHECKLIST.md

@@ -1,11 +1,11 @@
-# cogmem 3.6.2 Release Checklist
+# cogmem 3.6.4 Release Checklist
 
 This release is distributed through the npm registry. GitHub remains the source and review mirror.
 
 ## Required Metadata
 
 - `package.json` name is `cogmem`.
-- `package.json` version is `3.6.2`.
+- `package.json` version is `3.6.4`.
 - `package.json` has `publishConfig.access = public`.
 - Public export `.` points to `dist/public.js` and `dist/public.d.ts`.
 - Internal subpath `./internal` exists only as an explicit advanced subpath.
@@ -19,12 +19,13 @@ This release is distributed through the npm registry. GitHub remains the source
 - `cogmem doctor`
 - `cogmem connect`
 - `cogmem update`
+- `cogmem mcp`
 - `cogmem openclaw diagnose`
 - `cogmem-compact`
 - `cogmem memory`
 - `cogmem repair`
 - `cogmem explain-recall`
-- `cogmem-mcp`
+- `cogmem-mcp` compatibility bin for existing host configs
 - `cogmem import-openclaw`
 - `cogmem import-hermes`
 - `cogmem normalize-transcript`
@@ -43,6 +44,8 @@ MCP `tools/list` includes strategy, episode append/import/status/seal/repair, to
 ## Required Documentation
 
 - README explains the vision, architecture, limits, and one-line install command.
+- README and skills document npm as the default install path: workspace-local `npm install cogmem@latest --save` for OpenClaw/Hermes projects, global npm only when the operator wants one shared CLI, and the one-line installer as compatibility.
+- README and skills state that `cogmem init` is an interactive operator wizard and must not be scripted by an unattended agent; agents should use resolved `cogmem` commands, `cogmem doctor`, and `cogmem connect <agent>`.
 - README says this is a single-agent memory kernel, not an agent team shared brain.
 - README distinguishes embedding models from Dream Curator memory-model LLMs.
 - README and integration docs explain labeled `sourceContext`, strict before/after window metadata, `charRange` / `sourceRange`, and OpenClaw `sourceWindow` / `sourceTruncation` injection.
@@ -56,6 +59,9 @@ MCP `tools/list` includes strategy, episode append/import/status/seal/repair, to
 - README and skills explain that Prospective Memory is confirmed-only state with no task execution capability, and how to use BrainEval as a release gate.
 - README and skills explain Strategy Cortex templates, no-instruction-authority lifecycle, one-retry replanning, strategy-conditioned retrieval, offline-only rollout comparison, and read-only MemoryUseJudge telemetry.
 - README and skills explain Raw Ledger-first episode assembly, soft/hard sealing, explicit conditional Dream ticks, raw-event evidence grounding, repair/retry, and hookless Hermes MCP/import usage.
+- README and skills give the full post-import maintenance sequence: status, episode status, Dream status, bounded Dream tick, candidate listing, govern candidate, needs-confirmation listing, explicit review, and recall verification.
+- README and skills explain that 3.6.4 skips empty imported episode boundaries and legacy empty Dream jobs instead of letting them abort `dream tick`.
+- README and skills document `cogmem mcp` as the preferred MCP server command for new configs while preserving `cogmem-mcp` as a compatibility bin.
 - README and skills explain CPU foreground versus hybrid background classification, contextual short replies, registry-aware topic boundaries, safe reopen, semantic-summary non-evidence status, per-job Dream modes/failures, stable import identity, and schema migration 24.
 - README and skills explain user-shaped topic operations, user-explicit versus model-candidate authority, alias collision review, operation rollback, and project isolation.
 - README, `MEMORY_ATLAS.md`, and skills distinguish the system anatomy map from the content Atlas; explain graph overview/search/explore/node/neighbors/path/timeline, generic multi-facet cold-memory resurrection, activation visibility, source drill-down, and project isolation.
@@ -85,8 +91,10 @@ npm publish --dry-run --access public
 
 The pack dry-run must include built public API files, CLI files, examples, docs, and `install.sh`. It must not include local databases or machine-specific files.
 
-After verification, publish with:
+After verification, create a GitHub Release from the matching version tag, for example `v3.6.4`. The release workflow publishes through npm Trusted Publishing when the release is published. It must not publish on tag push alone.
+
+Emergency manual fallback:
 
 ```bash
-npm publish --access public
+npm publish --provenance --access public
 ```

package/dist/bin/connect.js

@@ -92,19 +92,18 @@ function defaultSkillPath(agent, workspaceRoot) {
 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',
+            './node_modules/.bin/cogmem doctor',
+            './node_modules/.bin/cogmem openclaw diagnose --workspace . --json',
+            './node_modules/.bin/cogmem import-openclaw --workspace . --project openclaw --dry-run',
+            './node_modules/.bin/cogmem import-openclaw --workspace . --project openclaw',
+            './node_modules/.bin/cogmem memory status --project openclaw --json',
         ];
     }
     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',
+        './node_modules/.bin/cogmem doctor',
+        './node_modules/.bin/cogmem import-hermes --workspace . --project hermes --dry-run',
+        './node_modules/.bin/cogmem import-hermes --workspace . --project hermes',
+        './node_modules/.bin/cogmem memory status --project hermes --json',
     ];
 }
 function usage() {
@@ -138,33 +137,45 @@ function hostConfigSnippet(agent, workspaceRoot, auto) {
             '// Add host config only after installing a real OpenClaw plugin wrapper with a valid manifest/schema.',
         ].join('\n');
     }
-    const mcpBin = resolveCogmemMcpCommand(workspaceRoot);
+    const mcpServer = resolveCogmemMcpServer(workspaceRoot);
     return [
         'mcp_servers:',
         '  cogmem:',
-        `    command: "${mcpBin}"`,
-        '    args: []',
+        `    command: "${mcpServer.command}"`,
+        `    args: ${JSON.stringify(mcpServer.args)}`,
         '    enabled: true',
         '    tools:',
         '      include:',
         ...HERMES_COGMEM_TOOLS.map((tool) => `        - ${tool}`),
     ].join('\n');
 }
-function resolveCogmemMcpCommand(workspaceRoot) {
+function resolveCogmemMcpServer(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;
+        return { command: process.env.COGMEM_MCP_BIN, args: [] };
+    if (process.env.COGMEM_BIN)
+        return { command: process.env.COGMEM_BIN, args: ['mcp'] };
+    const workspaceCli = join(workspaceRoot, 'node_modules', '.bin', 'cogmem');
+    if (existsSync(workspaceCli))
+        return { command: workspaceCli, args: ['mcp'] };
     const pathValue = process.env.PATH || '';
+    for (const segment of pathValue.split(':')) {
+        if (!segment)
+            continue;
+        const candidate = join(segment, 'cogmem');
+        if (existsSync(candidate))
+            return { command: candidate, args: ['mcp'] };
+    }
+    const workspaceMcp = join(workspaceRoot, 'node_modules', '.bin', 'cogmem-mcp');
+    if (existsSync(workspaceMcp))
+        return { command: workspaceMcp, args: [] };
     for (const segment of pathValue.split(':')) {
         if (!segment)
             continue;
         const candidate = join(segment, 'cogmem-mcp');
         if (existsSync(candidate))
-            return candidate;
+            return { command: candidate, args: [] };
     }
-    return 'cogmem-mcp';
+    return { command: 'cogmem', args: ['mcp'] };
 }
 function installSkill(args) {
     if (!args.agent)
@@ -237,9 +248,9 @@ function defaultHermesConfigPath(env = process.env) {
 }
 function installHermesMcpConfig(input) {
     const configPath = resolve(input.configPath || defaultHermesConfigPath());
-    const serverCommand = resolveCogmemMcpCommand(resolve(input.workspaceRoot));
+    const server = resolveCogmemMcpServer(resolve(input.workspaceRoot));
     const original = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
-    const patched = patchHermesMcpConfig(original, serverCommand);
+    const patched = patchHermesMcpConfig(original, server.command, server.args);
     const changed = patched !== original;
     let backupPath;
     if (!input.dryRun && (changed || input.force)) {
@@ -253,21 +264,22 @@ function installHermesMcpConfig(input) {
     return {
         enabled: true,
         configPath,
-        serverCommand,
+        serverCommand: server.command,
+        serverArgs: server.args,
         dryRun: input.dryRun,
         configUpdated: changed || input.force,
         backupPath,
     };
 }
-function patchHermesMcpConfig(original, serverCommand) {
-    if (/^\s+cogmem\s*:/m.test(original) && original.includes('cogmem-mcp')) {
+function patchHermesMcpConfig(original, serverCommand, serverArgs) {
+    if (/^\s+cogmem\s*:/m.test(original)) {
         return patchExistingHermesCogmemConfig(original);
     }
     const lines = original.replace(/\r\n/g, '\n').split('\n');
     const serverBlock = [
         '  cogmem:',
         `    command: "${serverCommand}"`,
-        '    args: []',
+        `    args: ${JSON.stringify(serverArgs)}`,
         '    enabled: true',
         '    tools:',
         '      include:',
@@ -366,7 +378,7 @@ function printHuman(result) {
         console.log('');
         console.log('Hermes MCP integration:');
         console.log(`  config: ${result.hermesMcp.configPath}`);
-        console.log(`  command: ${result.hermesMcp.serverCommand}`);
+        console.log(`  command: ${result.hermesMcp.serverCommand} ${result.hermesMcp.serverArgs.join(' ')}`.trimEnd());
         if (result.hermesMcp.backupPath)
             console.log(`  backup: ${result.hermesMcp.backupPath}`);
         console.log('  reload: /reload-mcp');

package/dist/bin/import-support.d.ts

@@ -22,6 +22,7 @@ export interface AgentImportResult {
     recordsIngested: number;
     skippedRecords: number;
     rawRecordsAnchored?: number;
+    emptyEpisodesSkipped?: number;
     reindexRaw?: boolean;
     processedSourceIds: string[];
     diagnostics: SourceAdapterDiagnostic[];

package/dist/bin/import-support.js

@@ -152,6 +152,7 @@ function previewSources(input) {
         recordsIngested: 0,
         skippedRecords: 0,
         rawRecordsAnchored: 0,
+        emptyEpisodesSkipped: 0,
         reindexRaw: false,
         processedSourceIds: [],
         diagnostics,
@@ -161,6 +162,7 @@ function previewSources(input) {
 async function importSources(input) {
     const opened = openKernel(input.args, input.workspaceRoot);
     const importedEpisodeIds = new Set();
+    let emptyEpisodesSkipped = 0;
     const processor = new InstalledBatchProcessor({
         cursorStore: opened.kernel.cursorStore,
         ingestBatch: async (items) => {
@@ -190,7 +192,7 @@ async function importSources(input) {
         for (const episodeId of importedEpisodeIds) {
             const episode = opened.kernel.getEpisode(episodeId);
             if (episode?.status !== 'sealed') {
-                opened.kernel.sealImportedEpisode(episodeId, { reason: `${input.agent}_import_batch_boundary` });
+                emptyEpisodesSkipped += sealImportedEpisodeIfReady(opened.kernel, episodeId, `${input.agent}_import_batch_boundary`) ? 0 : 1;
             }
         }
         return {
@@ -207,6 +209,7 @@ async function importSources(input) {
             recordsIngested: summary.recordsIngested,
             skippedRecords: summary.skippedRecords,
             rawRecordsAnchored: summary.recordsIngested,
+            emptyEpisodesSkipped,
             reindexRaw: false,
             processedSourceIds: summary.processedSourceIds,
             diagnostics: summary.adapterDiagnostics,
@@ -238,6 +241,7 @@ async function reindexRawSources(input) {
     let rawRecordsAnchored = 0;
     let skippedRecords = 0;
     const importedEpisodeIds = new Set();
+    let emptyEpisodesSkipped = 0;
     try {
         for (const source of input.sources) {
             const adapter = adapters.get(source.adapterKind);
@@ -279,7 +283,7 @@ async function reindexRawSources(input) {
         for (const episodeId of importedEpisodeIds) {
             const episode = opened.kernel.getEpisode(episodeId);
             if (episode?.status !== 'sealed') {
-                opened.kernel.sealImportedEpisode(episodeId, { reason: `${input.agent}_reindex_batch_boundary` });
+                emptyEpisodesSkipped += sealImportedEpisodeIfReady(opened.kernel, episodeId, `${input.agent}_reindex_batch_boundary`) ? 0 : 1;
             }
         }
         return {
@@ -297,6 +301,7 @@ async function reindexRawSources(input) {
             recordsIngested: rawRecordsAnchored,
             skippedRecords,
             rawRecordsAnchored,
+            emptyEpisodesSkipped,
             processedSourceIds,
             diagnostics,
             sourceResults,
@@ -307,6 +312,12 @@ async function reindexRawSources(input) {
         opened.kernel.close();
     }
 }
+function sealImportedEpisodeIfReady(kernel, episodeId, reason) {
+    if (kernel.listEpisodeEventLinks(episodeId).length === 0)
+        return false;
+    kernel.sealImportedEpisode(episodeId, { reason });
+    return true;
+}
 async function recordRawImportedEvidence(kernel, projectId, envelope) {
     const sourceRef = envelope.ingestInput.sourceRefs?.[0];
     const record = envelope.record;
@@ -483,6 +494,8 @@ function printHumanSummary(result) {
     console.log(`records ${action}: ${result.dryRun ? result.recordsWouldIngest : result.recordsIngested}`);
     if (result.rawRecordsAnchored !== undefined)
         console.log(`raw ledger anchors: ${result.rawRecordsAnchored}`);
+    if (result.emptyEpisodesSkipped)
+        console.log(`empty episodes skipped: ${result.emptyEpisodesSkipped}`);
     console.log(`records skipped: ${result.skippedRecords}`);
     if (result.diagnostics.length > 0) {
         console.log('diagnostics:');

package/dist/bin/mcp.js

@@ -29,7 +29,8 @@ function stringArg(values, key) {
 }
 function usage() {
     return [
-        'Usage: cogmem-mcp [--db <memory.db>|--config <config.toml>] [--cwd <dir>]',
+        'Usage: cogmem mcp [--db <memory.db>|--config <config.toml>] [--cwd <dir>]',
+        '       cogmem-mcp [--db <memory.db>|--config <config.toml>] [--cwd <dir>]',
         '',
         'Starts a stdio MCP server exposing recall, strategy, episode append/import/status/seal, conditional dream tick/status, memory map, maintenance, and prospective-memory tools.',
     ].join('\n');

package/dist/bin/migrate.js

@@ -62,11 +62,13 @@ 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);
+    const db = new Database(dbPath, args.dryRun && dbPath !== ':memory:' ? { readonly: true, create: false } : undefined);
     db.exec('PRAGMA busy_timeout = 5000;');
+    if (args.dryRun)
+        db.exec('PRAGMA query_only = ON;');
     try {
         const backupPath = shouldBackup ? backupDatabase(db, dbPath) : undefined;
-        const runner = new SchemaMigrationRunner(db, ALL_MIGRATIONS);
+        const runner = new SchemaMigrationRunner(db, ALL_MIGRATIONS, { readonly: args.dryRun });
         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);`);

package/dist/bin/openclaw.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
-import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { defaultOpenClawAutoMemoryPluginDir, inspectOpenClawAutoMemoryPlugin, } from '../host/openclaw/AutoMemoryPluginInstaller.js';
 function readArg(name) {
     const index = process.argv.indexOf(name);
@@ -42,6 +42,54 @@ function readAudit(workspaceRoot) {
         recentErrors: records.filter((record) => record.action === 'error').slice(-20),
     };
 }
+function countJsonlLines(path) {
+    if (!existsSync(path))
+        return 0;
+    return readFileSync(path, 'utf8').split('\n').map((line) => line.trim()).filter(Boolean).length;
+}
+function readLock(path) {
+    if (!existsSync(path))
+        return undefined;
+    const ownerPath = join(path, 'owner.json');
+    let owner;
+    if (existsSync(ownerPath)) {
+        try {
+            owner = JSON.parse(readFileSync(ownerPath, 'utf8'));
+        }
+        catch {
+            owner = { parseError: true };
+        }
+    }
+    const stat = statSync(path);
+    return {
+        path,
+        mtimeMs: stat.mtimeMs,
+        ageMs: Date.now() - stat.mtimeMs,
+        owner,
+    };
+}
+function inspectQueue(workspaceRoot) {
+    const queuePath = join(workspaceRoot, '.cogmem', 'queue', 'openclaw-remember.jsonl');
+    const queueDir = dirname(queuePath);
+    const processingFiles = existsSync(queueDir)
+        ? readdirSync(queueDir)
+            .filter((entry) => entry.startsWith('openclaw-remember.jsonl.') && entry.endsWith('.processing'))
+            .map((entry) => {
+            const path = join(queueDir, entry);
+            const stat = statSync(path);
+            return { path, lines: countJsonlLines(path), mtimeMs: stat.mtimeMs, ageMs: Date.now() - stat.mtimeMs };
+        })
+        : [];
+    return {
+        queuePath,
+        pendingLines: countJsonlLines(queuePath),
+        deadPath: `${queuePath}.dead.jsonl`,
+        deadLines: countJsonlLines(`${queuePath}.dead.jsonl`),
+        lock: readLock(`${queuePath}.lock`),
+        spawnLock: readLock(`${queuePath}.spawn.lock`),
+        processingFiles,
+    };
+}
 function main() {
     const [command] = process.argv.slice(2).filter((arg) => !arg.startsWith('--'));
     if (command !== 'diagnose' || hasFlag('--help') || hasFlag('-h')) {
@@ -55,12 +103,14 @@ function main() {
     const pluginDir = readArg('--plugin-dir') || defaultOpenClawAutoMemoryPluginDir(workspaceRoot);
     const plugin = inspectOpenClawAutoMemoryPlugin({ workspaceRoot, pluginDir });
     const audit = readAudit(workspaceRoot);
+    const queue = inspectQueue(workspaceRoot);
     const payload = {
         schemaVersion: 'cogmem.cli.v1',
         command: 'openclaw diagnose',
         workspaceRoot,
         plugin,
         audit,
+        queue,
     };
     if (hasFlag('--json')) {
         console.log(JSON.stringify(payload));
@@ -74,5 +124,6 @@ function main() {
     else {
         console.log('last before_prompt_build: none');
     }
+    console.log(`queue: pending=${queue.pendingLines} dead=${queue.deadLines} processing=${Array.isArray(queue.processingFiles) ? queue.processingFiles.length : 0}`);
 }
 main();