The line that matters:
learn and decision log record what happened. rule add changes what happens next. If you want future sessions to actually follow something, it is a rule; if you are writing down what you found out, it is a note or a decision.
Recording a decision
--rationale is required, not optional, and that is the whole point of using decision log rather than learn. A decision without its reasoning can only be obeyed or ignored later. With the reasoning attached it can be revisited, which is what you actually want six months on when the constraint that produced it has changed.
The gotcha. The decision gets a stable slug of the form {domain}.{decision}. Note it, or find it later with decision search, because that slug is how you edit it.
Next rung. --recall adds extra text to help the decision surface later. Use it for the words you will actually search with, which are rarely the words in the decision itself.
Fixing a decision you got wrong
decision update edits in place, addressed by the slug or by the exact decision text. The node keeps its address and every edge pointing at it survives.
The gotcha. Prefer this over base decision delete. Delete is keyword-matched with no preview, and it removes the decision’s history rather than correcting it. Search first, update second.
Recording anything else
--type takes insight, correction, decision, commitment or shift, and defaults to insight. --project and --entity add extra edges.
Why it works. A note is a graph node with edges to its domain and to anything else you attach it to, so it can be reached from more than one direction later. That is the difference between this and a text file.
The gotcha. --domain is required unless you are using --mention. It is the anchor that keeps notes findable rather than accumulating unattached.
Editing and removing notes
--list gives you the slugs. Both --update and --remove take one.
Recording that something came up again
base graph purge --stale. That measures lastRead, and mentions write a different timestamp. Verified from source at 4866996, the commit the shipped 0.13.2 binary was built from.
Getting it back
base recallsearches notes, literally and quickly. Use it when you roughly know what you are looking for and want the raw hits.base decision searchis the same idea, scoped to decisions and their reasoning.base graph queryretrieves a subgraph and synthesizes an answer across it. Use it for open questions where the answer is assembled from several facts rather than found in one.
base recall writes, despite being a search. It stamps lastRead on every note it returns, and that is the timestamp base graph purge --stale measures. Recalling a note therefore protects it from the next purge.Injection during a turn deliberately does not do this, so the hot path never pays for a graph write. Only the explicit command stamps.People and organizations
--domain is required, deliberately, so an entity always has something to be relevant to. An entity with no anchor would never surface.
Goals and reminders
--in, --at or --due.
The gotcha. A due reminder surfaces at every session start until you remove it, and base reminder remove is a hard delete with no preview. It is exempt from both the suppression check and the character budget for the same reason handoffs are: an open loop that stops reminding you is one you have lost.
Flat-file memories
base memory list shows the loose-file memories on this machine with their paths. base memory purge removes the ones whose content the graph already holds.
The gotcha. There is no preview on purge. Run list first and read it, because that is the only look you get.
Next
Rules and domains
Writing something that fires on its own, rather than something you look up.
Graph and memory reference
Every flag on every command here.