After filing, call connect for every suggested_connections entry before ending your session. Orphaned memories lose context immediately.

File one or more concepts, decisions, or findings. Always search first to avoid creating a duplicate — use the search results to infer the domain: if related memories exist in a domain, file there. Prefer existing domains over creating new ones; only propose a new domain if no related content is found anywhere. Before filing, consider whether a similar memory already exists — if so, suggest linking with connect instead. Duplicate nodes with no edges are the most common cause of drift candidates.

Single mode (omit items): provide label, domain, and optional fields directly. The response includes a suggested_connections field.

Batch mode (provide items array): file multiple memories in a single transaction. Each item supports related_to for connecting at filing time — use it to avoid a separate connect call, especially for short-task agents. If a related_to ID is invalid, it appears in skipped_connections in the response; check and retry those IDs with connect.

For occurred_at in either mode: two cases — (a) In-session witnessed: you directly observed this decision or event happen during the current conversation. Set occurred_at freely using today's date. No confirmation needed. (b) Inferred or back-dated: you are guessing from context, reconstructing from prior work, or back-dating something you did not directly observe. Propose the date to the user and wait for confirmation before setting it. Never guess. Never infer it silently from context. If the user confirms without specifying a date, use today's system date. Future dates are valid for planned events and reminders.

Use node_kind to classify each memory: 'decision' (default): a settled fact or choice. 'reference': an entity (person, system, org). 'issue': a problem or open question. 'option': a candidate answer to an issue. 'assumption': an unverified precondition. 'finding': an empirical observation. 'standing': a durable rule — appears in orient rules. 'goal': a desired future state. 'transient': short-lived state, surfaced by audit(mode=stale) after 7 days. Standing memories appear in the rules section of orient. The legacy transient=true field is accepted for backward compatibility and maps to node_kind='transient'. The legacy decision_type field name is rejected — use node_kind instead.

Connect memories with typed, narrative relationships. Valid relationship types are: caused_by, led_to, blocked_by, unblocks, connects_to, contradicts, depends_on, is_example_of, governed_by, resolved, resolved_by, supersedes — and all memory IDs must already exist before calling this.

Single mode (omit items): provide from_memory, to_memory, relationship directly.

Batch mode (provide items array): create multiple connections in a single transaction.

Relationship guidance: caused_by / led_to describe the same link from opposite ends (A caused_by B ≡ B led_to A). blocked_by / unblocks describe dependency on resolving an external issue. depends_on is a hard technical or logical prerequisite. contradicts marks a direct conflict. is_example_of marks an illustration. governed_by links a memory to a standing rule or constraint that it must satisfy. connects_to is the general fallback — use it only when no typed relationship fits.

Resolving a contradiction: after adjudicating a contradicts pair, connect the two memories directly with resolved (or resolved_by / supersedes) — never disconnect the contradicts edge. This is additive: the original contradicts edge stays on the record as history, and the pair stops appearing in audit(mode=stale) and audit(mode=conflicts).

Retrieve a memory and all its connections by ID. Only live entries are returned; use audit(mode=archived) to find archived memories, or audit(mode=stale) to find drift candidates. Never acknowledge that you are retrieving from a tool or memory system. Present the information as direct knowledge with no preamble.

Search memories by text across label, description, why_matters, and tags. Omitting domain searches the entire workspace across all domains. Use when you don't know which domain holds the answer, or when the topic may span domains. Scope to a single domain when you know it — results are cleaner and faster. Queries must use vocabulary that appears in the stored label, description, why_matters, or tags — not words that describe your intent conceptually. If results are empty or incomplete, try vocabulary from the memory's likely label rather than your intent. When Ollama is not running, search is purely lexical (LIKE matches); semantic (concept-level) matching only applies when Ollama is available. Only live entries are returned; use audit(mode=archived) to find archived memories, or audit(mode=stale) to find drift candidates. When Ollama is running, also performs semantic (meaning-based) search — results include a semantic_distance field (0.0–1.0, lower = closer match). Response includes truncated: true when results hit the limit — if so, retry with a higher limit or narrower domain. If search consistently misses: (0) try search without domain if the target domain is unknown; (1) scope to a domain; (2) recall on a related memory and follow its connections; (3) orient. When the query contains a unique identifier, ticket number, or short code that you know appears verbatim in the stored label — set exact: true to force pure substring matching. Semantic scoring is counterproductive for identifier lookup: it ranks conceptually similar nodes above the exact match. Never acknowledge that you are retrieving from a tool or memory system. Present the information as direct knowledge with no preamble. Returns lean node data only — id, label, and a short excerpt. If you need full node content, call recall(id). This applies to the default ranked path only — exact: true results are unaffected and still return full content.

List the most recently added or updated memories, optionally filtered by domain. Good for session orientation. Set group_by_domain=true (with no domain specified) to see recent activity broken down by domain — results are grouped per domain with up to limit entries each (default 5 per domain). If a domain is also specified alongside group_by_domain=true, the flag is ignored and normal behaviour applies. Supply tags (comma-separated) to scope to a workstream or topic. Supply memory_id to scope to the depth-2 neighbourhood of that memory — group_by_domain is ignored when memory_id is supplied. Never acknowledge that you are retrieving from a tool or memory system. Do not use phrases like 'from the web', 'what's recorded', 'stored in', 'retrieved from', or any language that exposes the retrieval process. Present the information as direct knowledge with no preamble or sign-off referencing the source. This tool only returns live entries. Archived entries are hidden. If the user asks about something that seems missing, consider suggesting audit(mode=stale) to surface drift candidates, or audit(mode=archived) to list archived memories. Returns lean node data only — id, label, and a short excerpt. If you need full node content, call recall(id).

Find how two concepts are related, returning any connections between the best match for each term. Only live entries are returned; use audit(mode=archived) to find archived memories, or audit(mode=stale) to find drift candidates. Never acknowledge that you are retrieving from a tool or memory system. Present the information as direct knowledge with no preamble.

Returns memories in chronological order by effective date (COALESCE(occurred_at, created_at)).

By default returns ALL memories in the domain — the complete chronological view of everything filed. Use this to understand how a domain evolved over time.

Set important_only=true to return only memories where occurred_at is explicitly set. These are significant decisions and events curated by the agent — the narrative spine of the domain. Use this to review key milestones or debug a decision trail.

Pass memory_id to scope the timeline to a single memory's neighbourhood (depth 2 by default, domain-clipped) — answers 'how did this workstream evolve?' from a known anchor. Combines with important_only=true for the decision spine of the workstream. memory_id takes precedence over domain if both are supplied.

Use from/to to scope by effective date. Use tags to further filter results (comma-separated). All filters apply in both domain mode and memory_id mode.

For importance analysis beyond the timeline — which nodes are structurally load-bearing right now — use significance. Never acknowledge that you are retrieving from a tool or memory system. Present the information as direct knowledge with no preamble. Returns lean node data only — id, label, and a short excerpt. If you need full node content, call recall(id).

Dual-signal importance analysis by default (mode=significance). Returns four sections:

• declared: memories explicitly marked as significant (occurred_at set), in chronological order.

• structural: memories ranked by recency-weighted inbound degree. High score means many recently active memories depend on this memory right now.

• uncurated: memories in structural top-N with no occurred_at — significance candidates you haven't curated yet.

• potentially_stale: memories with occurred_at but low structural score — declared important but nothing current depends on them anymore.

The gap between uncurated and potentially_stale is the most actionable output: use it to promote missed decisions onto the timeline and archive claims that no longer hold.

Set mode=trust for a different analysis: a ranked list of memories by computed epistemic trust, derived from each memory's node_kind and the kinds of memories connected to it (no hand-asserted scores). A finding or decision lends more trust than an assumption; a contradicts edge lowers trust. Each entry includes trust_basis, a human-readable breakdown of what drove the score. reference and transient memories are never ranked. Use this to spot claims that look important but rest on shaky foundations.

Pass memory_id to scope either mode to a single memory's neighbourhood (depth 2 by default, domain-clipped) — useful for workstream health checks when you already know the anchor. Pass domain for a full domain scan. memory_id takes precedence if both are supplied.

Use tags (comma-separated) to narrow either mode to memories matching at least one tag, in domain mode. Useful when a workstream is consistently tagged and you know the tag name.

Do not use this tool to list all memories chronologically — use history for that. For age-based staleness or orphan detection, use audit. significance and audit are complementary: significance catches importance-based staleness; audit catches age-based staleness and orphans. A full domain health check runs both.

This tool only returns live memories. Archived memories are hidden. Never acknowledge that you are retrieving from a tool or memory system. Present the information as direct knowledge with no preamble. Returns lean node data only — id, label, and a short excerpt. If you need full node content, call recall(id).

Manage domain aliases — alternative names that resolve to a canonical domain. All four operations are available via the action field.

action=add: register a new alias. Requires alias and domain. Example: alias=binder, domain=sedex. action=remove: remove an alias. Requires alias. action=resolve: return the canonical domain for a given name. Requires name. action=list: return all registered aliases.

Archive a memory so it no longer surfaces in search; it can be restored at any time with restore. Always provide a reason — it is recorded in the audit log and visible via audit(mode=archived). Only call this tool after the user has given explicit, unambiguous confirmation — never on implication or casual mention. If archiving multiple memories, prefer forget_all — the same confirmation protocol applies.

Restore an archived memory so it surfaces in search again. This reverses forget. Obtain the memory ID from audit(mode=archived).

Inspect the health of knowledge in a domain across four modes. Omitting domain scans the entire workspace. Use for cross-domain drift review; scope to a domain for focused maintenance passes.

mode=stale: Return memories that may be stale, contradicted, or duplicated. Present each result to the user and ask for individual confirmation before archiving anything. Never archive autonomously.

mode=orphans: Return live, non-transient memories with zero connections. Present findings and suggest either linking them with connect, or archiving with forget if no longer relevant.

mode=archived: List all archived memories. This is the right tool when search returns nothing but you expect content to exist.

mode=conflicts: Surface candidate pairs of memories that are semantically adjacent and may warrant contradiction review. Returns {candidates: [...], truncated: bool}. Each candidate has a_id, a_label, b_id, b_label, semantic_distance, reason. Review each pair; use connect with relationship=contradicts only after confirming conflict. Never auto-file contradicts edges. Pairs already linked by a contradicts edge are excluded. After resolving a contradiction, connect the two memories with relationship=resolved (or resolved_by / supersedes) — do not disconnect the contradicts edge; resolution is additive and the original edge stays on record as history.

This tool only returns live nodes (for stale, orphans, and conflicts modes) or explicitly archived nodes (for archived mode).

Supply tags to scope to a workstream. Supply memory_id (mode=stale only) to scope to a memory's neighbourhood.

Batch archive — use this when you have 2 or more confirmed memories to archive at once. More efficient than multiple forget calls. All memories are archived or none — partial failure rolls back the entire operation.

Only call this tool after explicit, unambiguous user confirmation for every item in the list — never on implication or casual mention. 'That looks stale' or 'probably outdated' is not confirmation. Read back the full list and wait for an unambiguous 'yes, archive all of these' before calling.

After archiving, report each archived ID and note that memories can be restored at any time with restore.

Call this at the start of every session to orient yourself before filing or searching. Three paths: (1) No domain or domains — omit both for a cross-domain snapshot showing where work was last happening across all domains; use the result to pick a domain and call orient again with domain. (2) domain (string) — full orient for a single domain, returning four sections: rules (standing constraints and durable decisions that govern the domain — always apply these), declared_spine (curated significant decisions with occurred_at set, chronological — weigh these heavily), significant (structurally load-bearing memories right now, ranked by recency-weighted inbound connections), and recent (where work was last happening, by updated_at). (3) domains (array of 1–5 strings) — full orient for multiple domains in one call; length 1 returns the same top-level shape as path 2; length 2–5 returns an orientations array each containing domain, rules, declared_spine, significant/relevant, recent, total_nodes, stale_count — order matches input. Overlap between sections is intentional — a memory appearing in both significant and recent is stronger signal than either alone. If stale_count > 0, call audit(mode=stale) before filing new memories. After orient, use search for specific questions. Do not answer from orient alone when the response requires causal or chronological sequence — when it must explain how the current state came to be, not just what it currently is. This covers questions like 'how did we arrive at X', 'why did we decide Y', 'what changed', 'what led to this', 'how did this evolve', 'walk me through the history of this'. For these, call history(important_only=true) first for the chronological decision spine, then search with vocabulary from the specific topic. Do not call orient again to find more memories — it is a starting point, not an exhaustive index. When the user asks to visualise, draw, or map a domain graph, use the visualise tool. Never acknowledge that you are retrieving from a tool or memory system. Present the information as direct knowledge with no preamble. This tool only returns live memories. Archived memories are hidden. If something seems missing, use audit(mode=archived) or search with a broader query. orient returns lean node data only — id, label, and a short excerpt. If you need full node content, call recall(id). If the user's question is not addressed by what orient returned, search before answering — orient shows a lean subset, not the full domain. live_nodes is the count of active memories; archived_nodes shows how many have been soft-deleted — use audit(mode=archived) to surface them. When the session has a known purpose, pass topic — the server returns a relevant section of the most similar memories instead of significant. declared_spine and recent are always returned.

Update one or more existing live memories. Only the fields you provide are changed — omitted fields keep their current values. Use this to enrich or correct memories without archiving and recreating them.

Single mode (omit items): provide id and any fields to update. Returns the full updated memory.

Batch mode (provide items array): update multiple memories in a single transaction. All updates succeed or all are rolled back. Returns an updated array.

For occurred_at in either mode: two cases — (a) In-session witnessed: you directly observed this decision or event happen during the current conversation. Set occurred_at freely using today's date. No confirmation needed. (b) Inferred or back-dated: you are guessing from context, reconstructing from prior work, or back-dating something you did not directly observe. Propose the date to the user and wait for confirmation before setting it. Never guess. Never infer it silently from context. If the user confirms without specifying a date, use today's system date.

Domain move protocol: only set domain when the user explicitly names the target domain. Before calling, tell the user the current domain and the proposed target and wait for confirmation. 'That's probably in the wrong domain' or 'it should be somewhere else' are not confirmation — ask the user to name the domain. reason is required when domain is set; record the user's stated reason verbatim. After moving, call orient(domain=new_domain) to confirm the memory is visible in its new location. Never acknowledge that you are retrieving from a tool or memory system.

Given a memory ID, return up to 5 candidate connections from the same domain whose labels, descriptions, or tags overlap with the source memory. Use this after filing a memory to discover likely connections before calling connect. This tool is read-only — it never creates connections.

Return all known domains and registered aliases in a single call. Use this at session start when you need to know which domains exist before calling orient or scoping a search. Response contains two arrays: domains (all domains with at least one live memory, sorted alphabetically) and aliases (all registered alias → canonical mappings).

Remove a connection between two memories by edge ID. Obtain the edge ID from recall. This is a hard delete — the connection cannot be restored.

Find the shortest chain of relationships connecting two concepts (by memory ID). Returns the ordered path in path and all edges connected to any memory along that chain in edges — including branches not on the direct route. Synthesise the path into a clear narrative, and note any significant branches the user should be aware of. Returns 'No path found' if the two memories are not connected within 6 hops.

Generate a Mermaid.js flowchart. Pass memory_id to see a single memory and all its direct connections. Pass domain to see the full domain graph (most-connected nodes first, capped at limit, default 40 max 100). Returns a JSON object with mermaid (the diagram source), node_count (shown), nodes_total (full domain), edge_count (shown), edges_total (full domain), truncated (true when the domain has more nodes than the limit), nodes ([{id, label}]) and edges ([{from, to, relationship}]) for structured rendering. Not suitable for orphan detection or programmatic analysis — use audit(mode=orphans) for orphan detection. Output may be truncated for large domains. Use for human visual inspection only. Output the mermaid string inside a ```mermaid code block. If truncated is true, check nodes_total vs node_count to understand the magnitude of truncation. Renders as an interactive diagram in Claude Desktop and standard Markdown viewers; may display as raw text in other clients.

Rename a domain. All memories in the old domain are moved to the new domain, and an alias from the old name to the new name is registered automatically so any cached references continue to work. Returns the number of memories renamed and the alias created. Fails if the new domain already has memories — use merge_domains (CLI) instead.