cogmem 3.6.2

package/dist/utils/hash.d.ts

@@ -0,0 +1,33 @@
+export declare class HashUtils {
+    /**
+     * 计算字符串的 SHA-256 哈希
+     */
+    static sha256(content: string): string;
+    /**
+     * 计算神经元的 self_hash
+     * 基于内容、时间坐标和空间坐标生成唯一哈希
+     */
+    static computeSelfHash(content: string, timestamp: number, spatialCoords: [number, number, number]): string;
+    /**
+     * 计算 prev_hash（区块链风格链接）
+     * 新神经元的 prev_hash 指向前一个神经元的 self_hash
+     */
+    static computePrevHash(prevNeuronSelfHash: string | null): string;
+    /**
+     * 验证神经元的哈希完整性
+     */
+    static verifyNeuronHash(neuron: {
+        content: string;
+        prev_hash: string;
+        self_hash: string;
+        coordinates: {
+            T: number;
+            S: [number, number, number];
+        };
+    }): boolean;
+    /**
+     * 计算记忆锚点的摘要哈希
+     */
+    static computeAnchorSummary(neuronIds: string[], projectId?: string): string;
+}
+//# sourceMappingURL=hash.d.ts.map

package/dist/utils/hash.js

@@ -0,0 +1,53 @@
+// ============================================
+// 哈希工具 - 区块链风格链接
+// ============================================
+import { createHash } from 'crypto';
+export class HashUtils {
+    /**
+     * 计算字符串的 SHA-256 哈希
+     */
+    static sha256(content) {
+        return createHash('sha256').update(content).digest('hex');
+    }
+    /**
+     * 计算神经元的 self_hash
+     * 基于内容、时间坐标和空间坐标生成唯一哈希
+     */
+    static computeSelfHash(content, timestamp, spatialCoords) {
+        const payload = JSON.stringify({
+            content,
+            T: timestamp,
+            S: spatialCoords
+        });
+        return this.sha256(payload);
+    }
+    /**
+     * 计算 prev_hash（区块链风格链接）
+     * 新神经元的 prev_hash 指向前一个神经元的 self_hash
+     */
+    static computePrevHash(prevNeuronSelfHash) {
+        if (!prevNeuronSelfHash) {
+            // 创世区块：使用固定前缀
+            return this.sha256('GENESIS');
+        }
+        return prevNeuronSelfHash;
+    }
+    /**
+     * 验证神经元的哈希完整性
+     */
+    static verifyNeuronHash(neuron) {
+        const computedSelfHash = this.computeSelfHash(neuron.content, neuron.coordinates.T, neuron.coordinates.S);
+        return computedSelfHash === neuron.self_hash;
+    }
+    /**
+     * 计算记忆锚点的摘要哈希
+     */
+    static computeAnchorSummary(neuronIds, projectId) {
+        const payload = JSON.stringify({
+            neuronIds: neuronIds.sort(),
+            projectId,
+            timestamp: Date.now()
+        });
+        return this.sha256(payload);
+    }
+}

package/dist/utils/text.d.ts

@@ -0,0 +1,2 @@
+export declare function lexicalSimilarity(a: string, b: string): number;
+//# sourceMappingURL=text.d.ts.map

package/dist/utils/text.js

@@ -0,0 +1,19 @@
+export function lexicalSimilarity(a, b) {
+    const aTokens = tokenSet(a);
+    const bTokens = tokenSet(b);
+    if (aTokens.size === 0 || bTokens.size === 0)
+        return 0;
+    let overlap = 0;
+    for (const token of aTokens) {
+        if (bTokens.has(token))
+            overlap++;
+    }
+    return overlap / Math.max(aTokens.size, bTokens.size);
+}
+function tokenSet(text) {
+    return new Set(text
+        .toLowerCase()
+        .split(/[\s,，。！？、:：/._-]+/)
+        .map((token) => token.trim())
+        .filter(Boolean));
+}

package/dist/utils/vector.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 序列化向量：Float32Array → Buffer
+ * @param vector 浮点数组（384 维）
+ * @returns Buffer（1536 字节，384 * 4）
+ */
+export declare function serializeVector(vector: number[]): Buffer;
+/**
+ * 反序列化向量：Buffer → Float32Array
+ * @param blob SQLite BLOB 数据
+ * @returns 浮点数组
+ */
+export declare function deserializeVector(blob: Buffer): number[];
+/**
+ * 计算向量大小（字节）
+ * @param dimension 向量维度
+ * @returns 字节数
+ */
+export declare function getVectorByteSize(dimension: number): number;
+/**
+ * 验证向量维度
+ * @param vector 向量
+ * @param expectedDimension 期望维度
+ * @returns 是否匹配
+ */
+export declare function validateVectorDimension(vector: number[], expectedDimension: number): boolean;
+//# sourceMappingURL=vector.d.ts.map

package/dist/utils/vector.js

@@ -0,0 +1,38 @@
+// ============================================
+// 向量序列化工具 - Float32Array ↔ Buffer
+// ============================================
+/**
+ * 序列化向量：Float32Array → Buffer
+ * @param vector 浮点数组（384 维）
+ * @returns Buffer（1536 字节，384 * 4）
+ */
+export function serializeVector(vector) {
+    const float32Array = new Float32Array(vector);
+    return Buffer.from(float32Array.buffer);
+}
+/**
+ * 反序列化向量：Buffer → Float32Array
+ * @param blob SQLite BLOB 数据
+ * @returns 浮点数组
+ */
+export function deserializeVector(blob) {
+    const float32Array = new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / 4);
+    return Array.from(float32Array);
+}
+/**
+ * 计算向量大小（字节）
+ * @param dimension 向量维度
+ * @returns 字节数
+ */
+export function getVectorByteSize(dimension) {
+    return dimension * 4; // Float32 = 4 bytes
+}
+/**
+ * 验证向量维度
+ * @param vector 向量
+ * @param expectedDimension 期望维度
+ * @returns 是否匹配
+ */
+export function validateVectorDimension(vector, expectedDimension) {
+    return vector.length === expectedDimension;
+}

package/examples/hermes-backend/AGENTS.md

@@ -0,0 +1,218 @@
+# Hermes Agent Memory Backend Runbook
+
+You are configuring Hermes to use `cogmem` as its durable memory backend.
+
+For a portable one-file skill, read `SKILL.md` or install it into the workspace with:
+
+```bash
+cogmem connect hermes --workspace .
+```
+
+This writes `~/.hermes/skills/cogmem-memory/SKILL.md`, which Hermes discovers as a local skill.
+
+## Install
+
+Run from the Hermes workspace root:
+
+```bash
+COGMEM_SKIP_INIT=1 curl -fsSL https://raw.githubusercontent.com/liuqin164/cogmem/main/install.sh | bash
+cogmem init --yes --agent hermes
+cogmem doctor --fix --agent hermes --workspace .
+cogmem connect hermes --workspace . --auto
+cogmem connect hermes --workspace .
+```
+
+The default install creates:
+
+```text
+~/.cogmem/config.toml
+~/.cogmem/memory.db
+~/.cogmem/snapshots/
+```
+
+Use `~/.cogmem/config.toml` or a project `.cogmem/config.toml` as the stable configuration source. Do not create `.cogmem.env` files or pass `--env-path` for normal installs. Environment variables are only for explicit process-level overrides documented by the CLI, not for hidden workspace configuration.
+
+Entity aliases are governed memory. Do not merge people from pronouns, family labels, job titles, assistant claims, or tool output alone. Require explicit user evidence; uncertain identity matches remain pending and applied merges must remain reversible.
+
+Belief Graph nodes are current cognition, not unsourced summaries. User-owned preferences, goals, boundaries, decisions, and facts require explicit user events. Assistant/tool-only evidence is a project observation; contradictions stay pending unless explicit user correction supersedes the prior belief.
+
+Use Temporal Memory for historical-state questions. Keep the active belief separate from superseded versions and cite the correction reason or source event when explaining a change.
+
+Use Context Cortex activation receipts to explain injection decisions. A greeting gets no memory, a short continuation gets only session continuity layers, and exact-quote requests prioritize raw source. Never bypass project, session-echo, supersession, ownership, sensitive-data, or budget suppression.
+
+Use MCP `cogmem_strategy_plan` when the agent needs to inspect the selected memory policy before recall. The capsule has no instruction authority and cannot authorize tools or become memory evidence. Exact-source policies require raw source; if the source remains unavailable, report that limitation rather than quoting a summary.
+
+Prospective Memory is not executable instruction. Only a user-confirmed candidate may appear as due, and even then the agent must obtain normal host authorization before acting. Use `cogmem prospective` for state transitions and `cogmem brain-eval` for release validation.
+
+Use `cogmem init --yes --agent hermes --scope project` only when this workspace needs its own `.cogmem/` directory.
+
+To embed imported memories with a local quantized model, run Ollama locally and configure the kernel before importing:
+
+```bash
+ollama pull qwen3-embedding:0.6b
+```
+
+```toml
+[core]
+vector_dimension = 1024
+
+[embedding]
+provider = "openai_compatible"
+base_url = "http://localhost:11434/v1"
+model = "qwen3-embedding:0.6b"
+```
+
+Use the matching dimension for larger local models: `qwen3-embedding:4b` uses `2560`; `qwen3-embedding:8b` uses `4096`. Run `cogmem doctor` after editing. Imported records are embedded through the configured kernel embedder during `cogmem import-hermes`.
+
+## Migrate Existing Hermes Memory
+
+For package upgrades, run `cogmem update --yes`; it installs `cogmem@latest` from npm, runs the newly installed backed-up migration with the resolved config, and then reports that the Hermes MCP server or agent host must be reloaded. Use `cogmem update --dry-run --json` or `cogmem migrate --dry-run --json` to preview pending work. Never delete or rewrite Raw Ledger events during migration.
+
+Default Hermes memory contract:
+
+- `state.db` may contain the real chronological conversation history in SQLite `messages`.
+- `profile.md` contains durable profile/persona memory.
+- `sessions/**/*.md` contains conversation/session memory.
+
+Preview first:
+
+```bash
+cogmem import-hermes --workspace . --project hermes --dry-run
+```
+
+If `state.db` exists, default import scans it automatically. If the database is elsewhere:
+
+```bash
+cogmem import-hermes --workspace . --project hermes --state-db ./state.db --dry-run
+cogmem import-hermes --workspace . --project hermes --state-db ./state.db
+```
+
+The SQLite importer prefers message-level `occurredAt`, `timestamp`, or `createdAt`; numeric `timestamp` values below millisecond range are epoch seconds. It can read WAL-mode `state.db` through SQLite immutable mode. `InsertTime` is only a fallback. Do not use `InsertTime` as proof of the original conversation date when better message timestamps exist.
+
+Then migrate:
+
+```bash
+cogmem import-hermes --workspace . --project hermes
+```
+
+Use `--json` when another agent needs structured output:
+
+```bash
+cogmem import-hermes --workspace . --project hermes --json
+```
+
+If Hermes stores memory somewhere else, pass explicit paths:
+
+```bash
+cogmem import-hermes --workspace . --project hermes --profile ./memory/profile.md --sessions ./memory/sessions
+cogmem import-hermes --workspace . --project hermes --session ./one.md
+cogmem import-hermes --workspace . --project hermes --session ./one.md --session ./two.md
+```
+
+For Hermes JSONL session exports where each line has a `messages[]` array:
+
+```bash
+cogmem normalize-transcript --input ./hermes-sessions.jsonl --output ./hermes.normalized.md --family jsonl --dry-run --json
+cogmem normalize-transcript --input ./hermes-sessions.jsonl --output ./hermes.normalized.md --family jsonl
+cogmem import-hermes --workspace . --project hermes --session ./hermes.normalized.md
+```
+
+After import, inspect the batch-sealed episodes, run one conditional curation tick, then invoke CPU governance separately:
+
+```bash
+cogmem episode status --project hermes --json
+cogmem dream tick --project hermes --mode auto --json
+cogmem memory govern --project hermes --json
+```
+
+## Active Memory Search
+
+If the current prompt does not include enough Cogmem memory context, query Cogmem directly before searching legacy files:
+
+```bash
+cogmem memory recall --query "<user question>" --project hermes --agent hermes --json
+```
+
+For inventory or product questions, use recall first and raw search as a forensic fallback:
+
+```bash
+cogmem memory recall --query "我们记录过哪些库存" --project hermes --agent hermes --json
+cogmem memory search --query "エルビ 库存" --project hermes --json
+cogmem memory show --event <event-id> --before 2 --after 2 --json
+```
+
+`vectors: 0` does not mean Cogmem has no memory. It means the dense vector index has no hot vectors yet. `memory recall` still falls back to governed raw ledger search and returns `sourceContext` locators. Broad inventory questions are expanded into structured cues such as `库存管理`, `在库`, `产品コード`, and `数量`; if compiled-memory candidates miss those cues, raw ledger evidence is preferred.
+
+`sourceContext` and `memory show --json` now share the same replay contract: each event has a `label`, optional `charRange` / `sourceRange`, and `sourceContext.window` / `window` metadata with requested counts, actual counts, `excludesAnchor`, `ordering`, `roleFilter`, and `overlapHandling`. Use those fields before quoting exact wording or explaining what happened before/after a recalled point.
+
+Check status with:
+
+```bash
+cogmem memory status --project hermes --json
+```
+
+For automation, read the top-level fields `rawEvents`, `vectors`, `dreamedRawCount`, `undreamedRawCount`, and `dreamCoverageRate`.
+
+## Runtime Wiring
+
+Use `KernelAgentMemoryBackend` for turn storage and recall:
+
+```ts
+import {
+  KernelAgentMemoryBackend,
+  createMemoryKernelFromConfig,
+} from 'cogmem';
+
+const kernel = createMemoryKernelFromConfig();
+const memory = new KernelAgentMemoryBackend(kernel);
+
+await memory.rememberTurn({
+  agentId: 'hermes',
+  projectId: 'hermes',
+  sessionId: 'current',
+  userText,
+  assistantText,
+});
+
+const recall = memory.recall({
+  agentId: 'hermes',
+  projectId: 'hermes',
+  query: userText,
+});
+
+const preparedContext = {
+  mode: recall.recallMode,
+  narrative: recall.narrative,
+  pulseTrace: recall.pulseTrace,
+  temporalLabels: recall.temporalTraversal?.labels,
+  memories: recall.items,
+};
+```
+
+Recall behavior:
+
+- `recall.recallMode === 'universe_navigation'` means core already ran pulse activation, temporal branch search, graph traversal, and narrative assembly.
+- Use `recall.narrative` as the compact context summary for the next model prompt.
+- Use `recall.items` as cited memory evidence.
+- Use `recall.temporalTraversal?.labels` when the user refers to a day, session, or adjacent work period.
+- Do not run a separate vector search before calling `memory.recall()`. The backend is the first-class memory retrieval path.
+
+The migration command is idempotent. Re-running it skips records already imported into the same memory database.
+
+Hermes integration is currently a skill plus MCP bridge. It does not replace a native Hermes memory provider and it does not patch Hermes runtime internals. `cogmem connect hermes --workspace . --auto` writes or updates the `mcp_servers.cogmem` entry in the Hermes config. Restart or reload Hermes after patching MCP config.
+
+For active memory search through MCP, call `cogmem_recall` with `projectId: "hermes"` and `query`. `agentId` is optional for project-scoped Hermes calls; the MCP bridge infers it from `projectId`. The tool returns the same `items` shape as `cogmem memory recall`, including `raw_ledger` fallback, `sourceContext` locators, and `decisionTrace`. Inspect its selected lane, reason, and candidate counts before claiming memory is absent. For equal raw matches, prefer the original user anchor and inspect `sourceContext.after` rather than relying on a later assistant retelling.
+
+Hermes has no automatic observation path in this integration. Use `cogmem_episode_append` for one message or bounded `cogmem_episode_import` for a session batch after meaningful conversation, and call `cogmem_recall` before memory-dependent answers. Supply stable external message IDs so retries are idempotent; never split/retry an auto-ID batch after `auto_identity_not_safe_across_split_batches`. These tools write Raw Ledger and episode control metadata only; they do not run Dream or create durable beliefs. Inspect `recommendedActions` and per-message checkpoints. On `no_recent_episode_ingestion_detected`, ingest recent messages; on `semantic_memory_may_lag`, inspect open/soft-sealed episodes and Dream failures before claiming freshness.
+
+Use `cogmem_topic_operate` with actor `user_explicit` only for explicit user naming/organization instructions. Model suggestions use `model_candidate` and remain reviewable; alias collisions fail closed. Use `cogmem_episode_repair` for split/merge/move/reclassify/requeue work so receipts, stale candidates, cross-references, Dream jobs, and audit records stay synchronized. Do not hand-edit the database.
+
+Use `cogmem memory map --project hermes --json` or MCP `cogmem_memory_map` to inspect Memory Binding and Graph Recall counters. Bindings attach high-value user raw events to stable topic/entity paths, fuse same-claim evidence into claim-key clusters, and create graph anchors for source drill-down only; they are not verified facts, user preferences, or instructions. Correction bindings expose review flags and correction edges. If `cogmem memory tick --project hermes --json` suggests `bind_raw_events`, run `cogmem memory bind --project hermes --json`. Re-run `cogmem connect hermes --workspace . --auto` after upgrades to patch existing MCP allow-lists with new Cogmem tools.
+
+Dream correction records require explicit user clarification; assistant self-correction and questions containing `是不是` are not user-owned contradictions. Invalid provider output is a rejected diagnostic. Maintenance ticks supersede `needs_confirmation` entries older than the default 30-day TTL and retain their evidence rows.
+
+## Memory Atlas navigation
+
+For broad inventory or historical questions call `cogmem_graph_explore`. Use `cogmem_graph_search` and `cogmem_graph_node` for known concepts, `cogmem_graph_neighbors`/`cogmem_graph_path` for relations, and `cogmem_graph_timeline` for ordered reconstruction. Use `cogmem_recall` for a direct fact and follow event IDs to `cogmem memory show` for exact wording.
+
+Combine the filters present in the user's message, including project, time, topic, entity/target, memory kind, and ordinary cues. Do not force an entity + time + action tuple. A cold result is newly visible, not newly verified or promoted.

package/examples/hermes-backend/README.md

@@ -0,0 +1,153 @@
+# Hermes Backend
+
+Use cogmem as a Hermes-compatible durable memory backend through MCP and imports.
+
+Entity resolution is evidence-backed and reversible. Person aliases require explicit user evidence; Hermes must not auto-merge pronouns, relationship labels, role names, assistant claims, or tool observations.
+
+Belief Graph writes keep ownership and evidence roles. Hermes may record assistant/tool project observations, but only explicit user events can establish user-owned preferences, goals, boundaries, decisions, or facts.
+
+## Default Contract
+
+- `profile.md` contains durable profile/persona memory.
+- `sessions/**/*.md` contains conversation/session memory.
+
+## Install
+
+```bash
+COGMEM_SKIP_INIT=1 curl -fsSL https://raw.githubusercontent.com/liuqin164/cogmem/main/install.sh | bash
+cogmem init --yes --agent hermes
+cogmem doctor --fix --agent hermes --workspace .
+cogmem connect hermes --workspace . --auto
+cogmem connect hermes --workspace .
+```
+
+Hermes integration is currently a skill plus MCP bridge. It does not replace a native Hermes memory provider and it does not patch Hermes runtime internals.
+
+## Local Quantized Embeddings
+
+Imports use the configured kernel embedder. To import existing Hermes memory through a local quantized model, configure the kernel before running the import command:
+
+```bash
+ollama pull qwen3-embedding:0.6b
+```
+
+```toml
+[core]
+db_path = "memory.db"
+vector_backend = "sqlite-vec"
+vector_dimension = 1024
+
+[embedding]
+provider = "openai_compatible"
+base_url = "http://localhost:11434/v1"
+model = "qwen3-embedding:0.6b"
+```
+
+Use the matching vector dimension for the selected model. `qwen3-embedding:4b` uses 2560 dimensions and `qwen3-embedding:8b` uses 4096 dimensions.
+
+## Migrate
+
+Upgrade and migrate the Cogmem database itself before importing host memory:
+
+```bash
+cogmem update --yes
+```
+
+`cogmem update --yes` installs `cogmem@latest` from npm, runs the newly installed backed-up migration, and then tells the operator to reload the Hermes MCP server or restart the agent host. Use `cogmem update --dry-run --json` to see the install and migration commands first.
+
+Preview:
+
+```bash
+cogmem import-hermes --workspace . --project hermes --dry-run
+```
+
+Import:
+
+```bash
+cogmem import-hermes --workspace . --project hermes
+```
+
+If Hermes stores memory somewhere else:
+
+```bash
+cogmem import-hermes --workspace . --project hermes --profile ./memory/profile.md --sessions ./memory/sessions
+```
+
+Single session files and batches can be imported explicitly:
+
+```bash
+cogmem import-hermes --workspace . --project hermes --session ./one.md
+cogmem import-hermes --workspace . --project hermes --session ./one.md --session ./two.md
+```
+
+The import command is idempotent. Re-running it against the same database skips records already processed by the cursor store. Imported raw records enter the same Episode Assembler used by live turns and are sealed at the explicit import batch boundary.
+Imported records are embedded through the configured kernel embedder during import.
+
+MCP recall JSON includes `decisionTrace`. Check its selected lane, reason, and candidate counts before concluding that a memory is absent, and use `sourceContext.locator.command` for exact wording. Raw text fallback searches the fully scoped ledger and prefers original user anchors over later assistant retellings when cue scores tie.
+
+Dream stores explicit user clarification as organizational correction evidence rather than an automatic contradiction. Assistant self-correction and negative-form questions do not create user-owned corrections. Resolve `needs_confirmation` with `cogmem_candidate_review` or `cogmem memory review`; maintenance only supersedes entries left stale past the default 30-day TTL.
+
+After upgrades, reload MCP. Rerun `cogmem connect hermes --workspace . --auto --force` when MCP wiring, allow-listed tools, or the installed skill bundle changed.
+
+Cogmem 3.6.2 exposes seven read-only/idempotent Memory Atlas query tools plus explicit `cogmem_graph_touch`, and installs from npm by default. Use explore for broad memory inventory/history, search and node for a known concept, path/neighbors for relations, timeline for ordered reconstruction, and normal recall for a direct fact. Query facets combine the user's actual project, time, topic, entity/target, memory-kind, action, and keyword conditions like table filters, so cold memory can be revived without requiring an entity-time-action tuple. Touch only nodes actually used, and follow returned event IDs to raw evidence before quoting exact wording.
+
+## Runtime
+
+```ts
+import {
+  HermesWorkspaceProfile,
+  KernelAgentMemoryBackend,
+  createMemoryKernelFromConfig,
+} from 'cogmem';
+
+const kernel = createMemoryKernelFromConfig();
+const memory = new KernelAgentMemoryBackend(kernel);
+const profile = new HermesWorkspaceProfile(process.cwd());
+
+const sources = profile.buildSourceDefinitions({
+  projectId: 'hermes',
+  profilePath: 'profile.md',
+  sessionDir: 'sessions',
+});
+console.log(sources);
+
+await memory.rememberTurn({
+  agentId: 'hermes',
+  projectId: 'hermes',
+  sessionId: 'current',
+  userText: 'Remember the release gate command.',
+  assistantText: 'Stored.',
+});
+
+const recalled = memory.recall({
+  agentId: 'hermes',
+  projectId: 'hermes',
+  query: 'what is the release gate?',
+});
+
+console.log(recalled.items);
+```
+
+If a Hermes workspace uses different paths, pass explicit `profilePath` and `sessionDir` values instead of changing core.
+
+For agent-facing instructions, run `cogmem connect hermes --workspace .`. It installs `SKILL.md` plus `references/operations.md`, a complete command-selection, migration, import, recall, Atlas, review, repair, backup, and maintenance handbook.
+
+`cogmem connect hermes --workspace . --auto` patches the Hermes MCP config with a `cogmem` server command. Re-running it after an upgrade updates existing allow-lists with strategy, topic, episode repair, candidate review, graph touch, conditional Dream, memory-map, maintenance, and prospective tools. Cogmem cannot observe Hermes conversations unless Hermes calls append/import. Episode append/import never run Dream; MCP Dream tick mutates only with `maintenanceMode: true`, never executes tools, and durable semantic changes still require governance. After running it, restart or reload Hermes so the MCP server list is re-read.
+
+Use MCP append/import only for bounded traffic. Supply `externalMessageId` for every message that may cross request boundaries; if a batch returns `auto_identity_not_safe_across_split_batches`, assign IDs before splitting or retrying it. MCP reports per-message progress/failure checkpoints. Large JSONL histories belong on `cogmem episode import` with checkpoint/resume plus `--start-line`, `--end-line`, `--max-lines`, `--skip-errors`, and `--max-errors`.
+
+Recall warnings are operational signals: `no_recent_episode_ingestion_detected` means the hookless host has not supplied recent conversation evidence, while `semantic_memory_may_lag` means open/soft-sealed high-value work or Dream backlog/failures remain. Ingest or repair before claiming current semantic memory. Use `cogmem_topic_list` / `cogmem_topic_operate` for audited user-shaped topic structure and `cogmem_episode_repair` for synchronized boundary surgery.
+
+The MCP `cogmem_recall` tool uses the same backend as `cogmem memory recall`. A Hermes MCP call with only `projectId: "hermes"` still infers `agentId: "hermes"` and can return `raw_ledger` items with labeled `sourceContext` events, `sourceContext.window`, and locator commands when vectors are empty. Pass `collection: "theseus"` only when Hermes wants creative artifacts instead of normal operational memory.
+
+Useful host-owned inspection commands:
+
+```bash
+cogmem memory map --project hermes --json
+cogmem memory tick --project hermes --json
+cogmem memory bind --project hermes --json
+cogmem episode status --project hermes --json
+cogmem dream tick --project hermes --mode auto --json
+```
+
+`memory map` includes Memory Binding and Graph Recall counters. Bindings attach valuable user raw events to stable topic/entity paths, fuse same-claim evidence into claim-key clusters, and create graph anchors for raw-ledger drill-down; they are not verified long-term facts. If `memory tick` suggests `bind_raw_events`, run `memory bind` to backfill imported Hermes raw user events into the binding graph.