Read a node IN FULL — every field plus the complete, untruncated body. drill / search / recall only show short excerpts; reach for at when you need a node's whole content. Optional when time-travels to a past moment (unix seconds, RFC-3339, or 5m / 2h ago); omit it for the node as it is now.

Add a node to another initiative (additive multi-membership) — repair initiative fragmentation by giving a node captured under the wrong or a stale initiative a second home, without moving or copying it (same id, edges, history). The node is resolved across all initiatives. Idempotent. Local only. For a whole initiative rather than a few nodes, merge_initiative is the one-step version.

Restore session context: pinned set, recent episodes (24h), open reviews, plus the read-back of unfinished work — open tasks (overdue first), claims awaiting a verdict, and the saved reasoning trails. Run this when re-entering a project.

Show every edge between two nodes, both directions, at NOW — answers "are A and B connected, and how?". Edges are typed (refers_to, causal, derived_from, contradicts, part_of, blocks, targets, supersedes, verifies, falsifies, temporal), so the answer says what KIND of connection it is. path finds a route when there is no direct edge; drill lists neighbours rather than edges.

Show the initiative's task board: status columns (from its registry, in order, empties included) with the tasks bucketed into them. Requires initiative. Optional when rewinds the whole board — columns and cards — to a past moment (unix seconds, RFC-3339, or 5m / 2h ago).

Customize the initiative's board columns: action add (key,label?) / remove (key) / relabel (key,label) / reorder (order = all keys permuted). The board is created from defaults [open, in-progress, done] on first edit.

Save the shortest weighted path between two nodes as a knowledge chain — an ordered, recallable reasoning trail. Stronger links (higher link weight) make shorter paths. Pass summary to note why the trail matters (it labels the chain for later triage). Idempotent — an identical chain is reused, not duplicated. Reports if the two are unconnected.

Record an archival reference. Two flavours: external source (pass url for papers / gists / dashboards) OR persona / entity (skip url for people, places, books without links). Both land in archival tier — long-term recall. Pass visibility=shared (in a team initiative) to capture and push to the cloud in one call. Pass link_to (with weight) to connect it to an existing node in this same call — an island is found only by exact name.

Record a hypothesis. Auto-named. If you ALREADY know how it turned out — the usual case, since you reach memory after the check has run — pass verdict (supported/refuted/inconclusive) and by (the evidence node) and it lands settled in this one call. Without a verdict it is an open question, and awake will keep surfacing it until one arrives. Optional about links via refers_to.

Close an open review on a node — retracts its contradicts edge(s) so it leaves the review queue; the doubt stays in history. Optional resolution note is recorded as provenance.

List the initiatives a cloud holds, with how many nodes each has shared. The map of the second tier: use it when you don't know what the team has, before cloud_recall on one of them. Note an initiative in the cloud is INDEPENDENT of the local one with the same name — same name, different contents. (clouds lists the clouds this daemon can reach; this lists what is inside one.)

Resolve a node's cloud soft links — fetches the cloud nodes they point at, live, so you see what they say NOW rather than what they said when the link was made. The read half of link_cloud. Routes each link to the cloud it was created against.

SEARCH or list what the cloud holds for an initiative — the second tier your local search cannot reach. Pass query to match shared names and excerpts; omit it to list everything. Then pull <id> brings one into the local vault. Reach for this whenever a team initiative's local answer looks complete: the cloud may hold nodes this machine has never seen. Paged at 25, reporting the true total and the exact call for the next page. In a multi-cloud setup cloud is required.

List the clouds this daemon can reach, with their endpoints and which one is default. Ask this before any cloud verb in an unfamiliar setup: with more than one cloud configured, share / pull / cloud_recall and the initiative verbs require cloud named explicitly, and nothing is routed to a default you did not choose.

Show resolved configuration: vault path, the configured clouds and which is default, and every cap (initiative not relevant).

Mark a hypothesis as supported. by (the verifying evidence node) is optional — record the verdict even with nothing to point at yet rather than leaving the claim open with the answer buried in its text.

Delete an initiative — drops its scoping and forgets nodes exclusive to it (bi-temporal: recoverable via at at a past time). Nodes shared with other initiatives only lose this membership. Local by default. Pass cloud="<name>" to ALSO delete it from that shared cloud, which removes it for everyone and CANNOT be undone there; with several clouds configured the name is required rather than defaulted.

Mark a task done — the id, name and manual tags survive; only the status moves, and history shows the transition. Accepts a task name or a UUIDv7 id. For any other column of the initiative's board use set_status; done is the shortcut for the terminal one.

Drill into a node — its brief plus one hop of children (sources via derived_from, parts via part_of). The fast way to see what a memory is attached to. Bodies come back as EXCERPTS: use at <name> when you need the whole text, and between a b when you want the edges rather than the neighbours.

Write a deliberately-named operational episode. Use when you know you'll want to recall by exact name. Pass visibility=shared (in a team initiative) to capture and push to the cloud in one call. Pass link_to (with weight) to connect it to an existing node in this same call — an island is found only by exact name.

Record what you actually checked, and attach it to a hypothesis. Past tense — this documents a check that already ran, it does not schedule one (and it is not cargo test). Pass method to write the result up as a new experiment node, or node to point at something you already captured.

Snapshot the substrate as an Obsidian-friendly markdown vault (README + INDEX + LOG + pages). Output dir is created if missing.

Flag a node as doubtful — writes a review episode carrying your REASON and a contradicts edge to the target. The target itself is untouched: the doubt is recorded beside it, not written into it. It then shows up in awake's under-review list until close_review or resolve settles it. Not the same as link contradicts, which records the edge without the reason.

Bi-temporal forget — retract a node and every edge connected to it. Historical reads still see it; reads at NOW skip.

Print every assertion / retraction recorded for a node, chronologically — + asserted, - retracted. This is how you see that a node CHANGED, and when. Accepts a former name too: a node renamed by revise or supersede is still reachable by the name it used to carry. Pair with at <name> when=<t> to read any of those versions in full.

Hygiene status for an initiative: node and core counts, when the last pass ran, whether one is due, and exactly what the next pass would move. Passes run on their own — when writes accumulate, when core grows past its threshold, or on the sweep timer — and only ever change a node's layer, reversibly. force=true runs one now.

List the initiative's archival IDEAS — proposals that settled without yet becoming results. Part of the cortex awake loads every session, so this is the deliberate deep read when you want them all rather than the layered slice. outcomes is the sibling for results; settle is how a node gets here.

Read FIRST before bulk-importing knowledge. Returns the import playbook: scope by initiative, pick the verb by epistemic status, stamp the memory layer at creation by importance, and link after capturing.

Mark a hypothesis as inconclusive — the check ran and did not decide. A real third verdict, not a failure to answer: it closes the claim out of the open queue while recording that the question stayed open on the merits. Writes no verdict edge, so by is not needed.

List initiatives that have at least one node attached. Use this first when re-entering, then pick one for subsequent calls.

Low-friction episode write — auto-named from body's first words plus a unique id suffix. Defaults to observation/low. Pass visibility=shared (in a team initiative) to capture and push to the cloud in one call. Pass link_to (with weight) to connect it to an existing node in this same call — an island is found only by exact name.

Set a node's memory layer — controls recall priority (injected Core → Hot → Warm → Cold → Frozen). Accepts name or id; layer one of core/hot/warm/cold/frozen.

Create a typed edge between two nodes (by name or id). Endpoints resolve in the active initiative first, then across all initiatives, so a link may span initiatives. Edge type defaults to refers_to. weight (0..1) is REQUIRED — it is HOW LOAD-BEARING the edge is and the only signal knowledge chains route on (path cost is 1−weight); there is no default because an unweighted graph makes every chain rank on noise. State it by the scale: 0.9–1.0 load-bearing (a cause, a source a conclusion rests on, a supersession — the edges a chain should follow); 0.6–0.8 supporting but not decisive; 0.3–0.5 loose / associative. DIRECTION matters for supersedes: link <new> <old> --edge_type supersedes — the replacement points at what it replaced, so an INBOUND supersedes means this node is obsolete.

Soft-link a local node to a cloud node by id — a reference, with NO copy in your vault. Use it instead of pull when the cloud node is someone else's to maintain and you only need to point at it: a pull makes a copy that silently goes stale when the owner revises it, while a soft link resolves live through cloud_links. Pull when you need the content locally; link when you need the citation. Edge type defaults to refers_to; in a multi-cloud setup pass cloud to record where the dst lives.

Diagnostic snapshot of graph hygiene: orphan nodes (no edges at all), unresolved reviews, and dangling edges whose endpoint was retracted. Read-only. reflect is the fuller version — it pairs each finding with what to do about it, and adds overdue tasks, stale chains and cortex candidates.

Merge one initiative INTO another — the fix for a project whose memory ended up split across two names (a typo, a separator, a translated alias). Re-homes every node and edge of source into target in ONE step and removes source. Nothing is forgotten: a merge only moves memberships, so unlike attach-then-delete_initiative it cannot lose a node you missed. target must already exist (use rename_initiative to move to a fresh name). target keeps its own share policy. Local only. reflect lists the candidates.

List every node ONE HOP from a node, in BOTH directions, across ALL edge types — the way to discover what a memory is connected to. drill follows only derived_from and part_of; this follows all twelve (refers_to, contradicts, supersedes, causal, temporal, blocks, targets, verifies, falsifies, part_of, derived_from, consolidated_to), so a contradiction or a supersession shows up here even when drill reports nothing. Each line names the edge TYPE and which way it points: —[type]→ outgoing, ←[type]— incoming. Optional edge_type (one or more, comma-separated) narrows to certain types; omit for all. between a b answers about a specific PAIR; drill shows the derived_from/part_of tree.

List the initiative's archival OUTCOMES — what the work actually concluded. This is the highest-value read for a fresh agent: results, not the working notes that produced them. trace walks any of them back to its sources; ideas lists the proposals that have not become results yet.

Print a terminal-readable map of the substrate: counts by tier/type, provenance forests, open questions, edge stats.

Compute the shortest weighted path between two nodes WITHOUT writing anything — a preview. Edge weight is the cost, so stronger links (higher weight) make shorter paths. chain saves the same path as a recallable trail; use path to look first when you are not sure the two are meaningfully connected.

Pin a node to the active window. Accepts either a name or a UUIDv7 id.

Read or set an initiative's cloud sharing policy (Gate 1). Omit both arguments to read. policy says WHETHER it may leave: private (default for any initiative — never leaves), team (shared nodes may sync), ask. clouds says WHERE TO: a comma-separated list restricting the initiative to those clouds, empty string to clear. An initiative with no list may go to any configured cloud, so this changes nothing until you ask for it.

Pull a shared node from the cloud into the local vault by id, attaching it to the given initiative — the recall mechanism for team knowledge you don't have locally yet. In a multi-cloud setup pass cloud to target a specific cloud.

Look up a node id by EXACT name — no fuzziness, no stemming. Returns the id alone, so follow it with at <name> for the full text or drill <name> for its neighbours. When you don't know the exact name, search is the verb; a miss here tells you whether the name lives in another initiative, is spelled differently, or is absent.

List what was CAPTURED within the time window (defaults 24h) — every kind of write, not only episodes: references, claims, tasks and jots all count. This is the verb that answers "did what I just write land?", so a zero here really means nothing was captured. Use since like 30m, 3h, 2d, or raw seconds.

Refresh a chain the graph has outgrown. With no to, regenerate it — recompute the shortest path between its current endpoints (picks up new edges / re-weights). With to, extend the trail out to that node. Keeps the chain's id, name, and summary.

Reflect on the store: a computed maintenance work-list with how to act on each part — orphans to link, open reviews to resolve, chains gone stale (rechain), settled work to promote into cortex or drop to cold, and shared/cloud items that need YOUR sign-off (never auto-rebalanced). The last two are candidates to judge one at a time, not a batch to apply: cortex loads whole into every session, so the report prices the move (cortex N -> M). Run it when a piece of work ends, and before a session stops — that is the moment nothing else marks.

Mark a hypothesis as refuted. by (the falsifying counter-evidence node) is optional, same as for confirm.

Rename an initiative — moves all its nodes, edges, and sharing policy to the new name (fails if the new name already exists). Local by default. Pass cloud="<name>" to ALSO rename it in that shared cloud, which is team-wide and affects everyone; with several clouds configured the name is required, because this cannot be undone in the wrong one.

Resolve an open question by recording that by answers it — a supersedes edge from the answer to the question, so the question stays readable as history instead of being deleted. For a doubt raised by flag, close_review is the matching verb.

Rewrite a node's body and/or rename it IN PLACE — the id survives, and history shows both versions. This is the verb for correcting or extending a node. Use supersede instead when the change is big enough to deserve a new identity, and settle when the node is not changing at all, just finished.

Set an existing edge's connection strength (weight 0..1) in place. Stronger edges make shorter knowledge-chain paths; use to tune which links matter after the fact.

Full-text search across name and body via Cozo FTS. No stemming — search the form you wrote. For inflection-tolerant matching across any language append *: утечк* finds утечку/утечке, token* finds tokens/tokenize. Search in the SAME language as the original capture, not in English. Results are ordered by score, then newest-first within equal scores.

Move a task to a board column: sets its status:<key>, strictly validated against the initiative's board registry (unknown status is refused). The general form of done.

Promote a node that stopped changing from the operational tier into the archival one — this is how knowledge hardens. settle <name> ALONE IS ENOUGH: with no new_* the node keeps its name and its full body, and the type is derived (episode/task/experiment/hypothesis → outcome; draft/scratch → idea). Provenance via derived_from is replicated across the tier boundary, and manual tags come with it. Don't demote finished work to a cold layer instead — a layer is how eagerly a node loads, a tier is whether it is still in flight.

Share a node to the team cloud. Gated: the initiative must be team (set via policy) AND the node must pass the pre-share secret guard. On success the node is marked shared locally and a copy is pushed to the cloud under the same id. Pass force=true to override the guard. In a multi-cloud setup pass cloud to target a specific cloud (default: the configured default).

Make a node the live holder of a ROLE in an initiative — handoff, entrypoint, queue, prod-state. A role holds exactly one node: taking it archives the previous holder to cold and links supersedes from the new holder to it, so a project can never end up with three current handoffs. Nothing is deleted; the predecessor stays readable via at / surface layers=cold.

List the filled roles of an initiative and which node holds each.

Replace a node with a fresh one carrying new content, connected by a supersedes edge from the successor to the node it replaces. Use when the change is large enough to warrant a new identity; revise edits in place instead. new_type is optional — it defaults to the old node's.

Explicit layered recall — surface nodes from specific memory layers (default cold,frozen) that awake does not load. Use when you deliberately need archived/not-surfaced material. layers is a comma/space list; scoped to initiative when given.

Batch sync-review of a team initiative's still-local nodes: splits them into PROPOSE SHARE (guard-clean) vs KEEP LOCAL (secret-guard flagged). Review once, then share the approved ones — low-friction periodic sharing instead of deciding per capture.

Many-to-one consolidation — write one durable node from several seeds, with a derived_from edge to each so trace can walk back to them. Use when scattered observations have converged into a single finding; settle is the one-to-one version, which promotes a single node in place.

List nodes whose tags array contains the given tag — exact match. Common tag families: kind:<type> (observation, experiment, idea, reference, …), sig:<level> (low/medium/high), role:<role> (jot/review/synthesise/revised), lang:<code> (ru/en/mixed/other — auto-detected from body), topic:<word> (up to 5 auto-derived tokens — a node's MOST-MENTIONED words, weighted toward a name somebody chose; a compound like figma-макет is also tagged by its parts), status:<state> (hypotheses and tasks). Exact match, no stemming — but a miss comes back with the near tags that DO exist in scope, so an empty answer tells you what to ask instead. For loose matching over text use search prefix*. Newest-first when multiple match.

Capture a todo as a Task node. Auto-named from body. Tags: kind:task, status:open, optional due:YYYY-MM-DD. due accepts ISO date, RFC-3339, or future duration like 3d/2w. Pass link_to (with weight) to connect it to an existing node in this same call — an island is found only by exact name.

Walk derived_from ancestors of a node back to its sources — where a conclusion CAME FROM. Use it before trusting a synthesised or settled node: it shows the raw material the claim was built on. why is the sibling verb for the reasoning trail; trace is the material one.

Retract a previously-asserted edge. Bi-temporal — historical reads still see it.

Unpin a node. Accepts name or id.

Bring an archival node back into the operational tier — settle's mirror, for settled knowledge that turned out to still be in flight. unsettle <name> alone is enough: name, body and type all carry over unless you say otherwise.

Withdraw a node from a cloud: retracts the cloud copy and marks the node local again. The inverse of share, which had none. Use it for a node sent to the wrong cloud, one the pre-share guard should have caught, or anything that should not have left the machine. The cloud retraction is bi-temporal — the node leaves cloud_recall and the listings while its history stays intact. To CORRECT a shared node instead of withdrawing it, revise it and share again: the push is an upsert under the same id.

Free a role without touching the node that held it — its layer stays as it is.

Why is this here? Reads the saved reasoning that leads to a node — the state → reasoning → decision trail, not an isolated record. Give it a chain to read its ordered steps, or any node to see the chain it belongs to (read directly when there is only one, listed for triage when there are several). Replaces the former chains + read_chain pair.