Yes. codeaf keeps short lines — a preference, a rule, a correction, a decision, a lasting fact about you, this machine or this project. Explicit pins always ride in their scope. Other lines are selected by activation: past use, recency and the current project or topic help decide what rides. A protected share of the prompt keeps durable rules from being crowded out by progress updates; specific matches to your message get space before generic topics. A line that does not ride stays stored and searchable; the Memory tab explains why.
Lines get kept three ways, and all three tell you:
- you keep one:
/remember <text>(or/always <text>, the same thing); - you ask in words — "remember that I deploy on Fridays" — and the model keeps it;
- codeaf notices something durable you said and keeps it, saying
noticed and remembered · <line> · <where>, followed by a reminder that you can see or forget it on the Memory tab.
The commands:
/memoryor/memories— open the Memory tab (alt+8)./memory <words>or/memories <words>— print the lines those words name./remember <text>— keep one line.
There is no /forget: a line is forgotten on the Memory tab, where you can see
it, or by asking — "forget that I use npm".
The words themselves are not memory: everything said in every conversation on this machine is also kept and can be searched (see "What did we decide last week" below).
Yes. Typed or said, it is kept straight away — no model decides whether to keep
it. /remember <text> answers with exactly what was kept and where it holds:
remembered · uses pnpm, not npm · for this project
Typed on home, it holds for you everywhere instead. The same words twice say
already remembered · … and keep one line. Said in words ("remember that…"),
the model uses its remember tool and you see
remembered · <line> · <where>, with a reminder to see or forget it on the
Memory tab. The model can also drop a line you ask it to with its forget tool,
and says forgot · <line>, with a reminder that the Memory tab can put it back.
It does either only on a turn you typed: a turn opened by a task's report, a team member's message or
a watch's news keeps and forgets nothing — until you type into it — so words
someone else wrote cannot plant a line in every future conversation. Answering
one of its questions after its turn has ended counts the same way, because the
clock can answer one for you: say "remember that", or /remember it.
The remember tool can label a standing rule, decision, lasting fact or
project progress directly, rather than infer every kind from wording.
Capture instructions keep what you stated or explicitly accepted, preserving
conditions without adding the assistant's suggestions. Wording may be normalized;
this is model guidance, not a verbatim or lossless-capture guarantee.
The Memory tab shows the stored kind.
A line is one sentence, at most 512 characters, and a credential pasted into it is redacted before it is kept.
Anything with a time in it is not a memory: "remind me at six", "every
Monday", "tell me when CI goes red" are automations (see automations).
Always do it this way — make it always do something: a rule like always use tabs, coding style, conventions for this repo
A rule is a memory. "Always use tabs here", "never touch the public API", "our
conventions for this repo: tests beside the file" — keep it with /remember or
/always (they are the same command), or say it and the model keeps it.
Lines you keep with /remember, /always, or the Memory tab are pins:
they always ride conversations in their scope, even when the ordinary memory
budget is full. Other automatically kept lines compete by activation. Bare
/always prints every line kept here (on home, the ones that hold everywhere).
There is no rule for one conversation only.
The memory prompt tells the model to preserve every condition: requirements stay mandatory, prohibitions stay prohibited, and preferences stay preferred. A rule requiring both approval and a complete checklist must not make the checklist optional.
Current user instructions outrank saved lines. Current authoritative evidence, such as the manual, can correct stale factual claims. Narrow exceptions coexist with broader rules unless revoked. These are prompt instructions, not a perfect-recall guarantee; inspect actual admission on the Memory tab.
Is that an instruction or a rule? How it knows you mean always, how to make it permanent, and when it didn't notice a rule and did it once
A sentence with no time in it that you want to hold from now on is a memory; something you want done once is just done; something tied to a time or an event is an automation.
When it did something once and you meant it to hold — it didn't notice this was
a rule — make it permanent: say "remember that", or type /remember <the rule>.
When it kept something you only meant for now, forget it on the Memory tab, or
say "forget that". Noticing reads every turn you type, so a rule you state plainly ("always…",
"never…", "from now on…") is usually kept and says so.
Where a line holds — you everywhere, this machine, or this project? Does this rule apply to all my projects? Not in this project
Every line holds in one of three places:
- for you everywhere — every conversation, every project;
- for this machine — every conversation on this machine;
- for this project — every conversation in this project, and nowhere else.
/remember typed in a conversation keeps the line for this project; typed on
home, for you everywhere. The model keeps a line for this project unless you
said it holds everywhere or only on this machine. A conversation with no project
of its own (home, or a folder codeaf could not identify) keeps a project line
for you everywhere and says so: … · for you everywhere, since this conversation has no project of its own.
Can I change everywhere to just this project? Yes: on the Memory tab, → on the
line offers hold it everywhere, hold it in this project and hold it on this machine — whichever it is not. There is no "everywhere except here": move the
line to the projects it should hold in instead.
A project is known by its git origin (so every clone and worktree of one
repository is one project), or by the folder when there is no remote.
Open it with alt+8, the Memory word on the tab bar (the fifth word; its number is 8
all the same), or /memory. It is
drawn like the Activity tab: groups, each a row of its own in the heading ink
with its fold mark after it, and every line hanging under its group on the
tree's connectors:
you, everywhere,this machineandthis project · <name>— what a conversation here can draw on, open from the start;- each other project, by its name, and
couldn't tell which project— lines an earlier build kept without naming the project — folded; let go— forgotten and replaced lines, folded, ready to put back.
Two columns, headed on the filter row: kept by (you, the model,
noticed, or on a let-go line forgotten / replaced) and age. The head
row omits zero counts: with no kept lines and two let-go lines it says 2 let go.
It counts what is kept, and says N more in memory for lines not admitted
to this conversation. Each line starts with riding or archived; open its pane or card for
the full reason. Admission reflects the conversation's most recent prompt.
With an older engine that cannot report admission, the heading explicitly
says project working set preview; that preview can differ from a live turn. + remember something
keeps a new line; what you type is drawn in that row. When more rows exist,
load more memories appears above the groups. Press enter on it to load
the next 500 active and archived rows; repeat until every row is available.
Filtering searches the rows loaded so far. memory mix shows the share of
the actual prompt occupied by project progress, corrections, preferences,
decisions and facts. Open a line to see its kind; an older line reclassified
as project progress also says its original kind, without changing its words.
When codeaf cannot ask which project this conversation is in, the foot says
couldn't ask which project this is · every project's lines are shown by name,
no group is this project, and the head row counts nothing that doesn't fit.
On a frame 110 columns or wider a pane beside the list reads out the row under the cursor: the whole line, where it holds, who kept it, and where it was learned.
→on a group opens it;←folds it back up.enterdoes not open groups.enteron a line opens its card; on+ remember something, starts a line.→on a line opens its verbs (fix, forget, move, ask, put back).- Typing filters every group at once;
escclears the filter, then leaves. deleteforgets the line under the cursor. A click on a group opens or folds it.
Every change the tab makes happens beside the screen, so a slow engine never freezes the keyboard, and its receipt appears on the line at the foot.
On a machine that has kept nothing yet, the Memory tab draws its heading and
one line — the lines codeaf keeps in front of every conversation · /remember adds one — and its foot offers only the way out. There is no 0 kept: nothing
kept is drawn as nothing. Once there is a first line, the groups and the
+ remember something row appear.
On the Memory tab, put the cursor on the line and press →, then e fix the wording — or open its card with enter and press → then e. The line's
words load into its own row, where you edit them; enter saves and esc
cancels. The line keeps where
it holds and who kept it; its title follows the new words, so the list and the
model both read the corrected line. The receipt says fixed · <line>; new
words another line already says are refused with already kept · <words> · nothing was changed.
To change where a line holds instead, → offers the moves (see "Where a line
holds").
How do I make you forget something? Forget a memory, undo forgetting one. Can a forgotten memory come back or be relearned?
On the Memory tab: → on the line, then f forget it — or delete. The
line moves under let go, marked forgotten; open let go with →, and
→ then u put it back on the line restores it, whenever you like — unless the
same words are kept again since, which says already kept · <line> · nothing was changed and leaves one line.
Or ask in words — "forget that I use npm". The model's forget drops the
one line those words name and says forgot · <line>, with a reminder that
the Memory tab can put it back. When the words name more than one line it forgets
nothing and lists them; when they name none it says nothing remembered matches "<words>".
There is no /forget command (there was one until 2026-10-14) and no undo key:
every change — kept, noticed, replaced, forgotten — is a line on the tab you can
forget or put back.
Nothing is ever deleted outright, so a forgotten line comes back only if you put it back or keep the same words again. Searching an old conversation does not bring a forgotten line back or re-activate it: search is reading, not remembering. Noticing only reads turns you type from now on.
enter on a line opens its card: all of its words, where it holds, who kept it,
and when. The verbs on the line's → strip include a ask me about it, which
starts a new conversation that opens with about something you remember: <the line> — the place to ask why it was kept, whether it still holds, or what it
means for something you are doing. esc on a card returns to the list.
The card says who kept the line — kept by you, kept by the model or kept by noticed (the pass after a turn) — how long ago, and the conversation it was
learned in: 2h ago · in 'Editor setup'. When that conversation is on this
machine, → then o open where it was learned opens it. A line kept by an
earlier build may not know its conversation, and then the card simply says less.
With learn from chats and jobs on (the default unless saved off), after each turn
you typed, one small call reads what you said and the answer
and may keep one line: a preference, a standing rule, a correction, a
decision, or a lasting fact. It is shown what is already kept, so it does not
keep the same thing twice. It never keeps something only the assistant said, the
work in progress, code, or anything with a time in it — and never anything from a
task's report, a watch's news or a team's message, because you did not type
those. An ask here exchange from home is not noticed either, and neither is a turn
in which a permission question was denied, dismissed or left unanswered: one answer to
one question is not a rule, so nothing is kept about you from that turn.
Every time it keeps a line it says so in the conversation:
noticed and remembered · wants the change made directly · for you everywhere
The receipt also points to the Memory tab to see or forget the line.
If you have moved to another conversation or home by then, the line waits and is drawn in its own conversation when you come back to it.
The tab marks it noticed, and → then f (or delete) there forgets it. Most
turns keep nothing. Turn noticing off with the learn from chats and jobs row
(see "How do I turn memory off").
When something you said corrects a line already kept — "we deploy on Tuesdays
now" against deploys on Fridays — noticing replaces the old line with the new
one and says so:
noticed and remembered · deploys on Tuesdays · replaces deploys on Fridays · for this project
The receipt also points to the Memory tab to see or forget the line.
The replaced line waits under let go on the Memory tab, marked replaced:
put it back there, and forget the new one, to undo the change. When the
correction is already kept, the old line is let go and nothing new is written:
noticed · deploys on Fridays is let go · already kept: deploys on Tuesdays,
followed by the reminder to see or forget it on the Memory tab.
Nothing merges or rewrites lines while you are away any more. An earlier build
ran a background tidy that merged and retired lines and said memory tidied · …; it stopped on 2026-10-14, because a change to what you are remembered by
that you never see is exactly what this memory does not do.
Memory selection uses activation: applying, confirming or merging a line
strengthens it; merely showing it or finding it in a search does not. A
correction contradicting a remembered line counts against it. Unrehearsed
lines lose activation with age. A low-activation line stays stored;
archived in the Memory tab means it is not riding this conversation, not
that it was deleted. Forgotten and replaced lines remain under let go.
Near-duplicate writes can merge with an existing line instead of filling the store with copies. Ephemeral observations are not kept as durable memories. Local daily maintenance refreshes activation and associations while the clock is running, with catch-up after reopening. It makes no model call. Semantic status consolidation and write-time embeddings are not implemented.
The ordinary working set shares a 4,800-rune prompt budget across your, this machine's and this project's lines. Memory storage is not capped by that budget: keeping, editing, moving and restoring a line are no longer refused because a prompt is full. A line remains at most 512 runes.
Explicit user pins always ride, even when they alone exceed the prompt budget.
After pins, at least 40% of the remaining budget is reserved for durable
corrections, preferences and decisions when they need it. Remaining space
is available to relevant facts, project progress and other durable lines.
Within each group, specific phrases, identifiers and nearby matching
words take priority over generic topic repetition, with activation breaking
ties. A line must still meet the activation threshold. The block says · N more in memory for stored lines that do
not ride. Open the Memory tab to see riding or archived and a reason for
each line; archive does not mean forgotten. Admitted lines stay with the
conversation while its context is unchanged, so adjacent turns do not
randomly swap remembered facts. Short related follow-ups such as “why?” or
“give an example” keep that context. A meaningful topic change or a change to
saved memory can refresh the working set; a greeting alone does not freeze
the selection for the real request that follows.
An older build sometimes saved a release update or progress paragraph as a preference. A local migration derives a corrected kind alongside the original kind; the saved words, source and original label are preserved. Admission uses the derived kind so a long progress update does not consume the protected rule share just because it was once called a preference. The line's card shows both kinds when they differ. New noticing also distinguishes progress from a lasting preference before keeping it.
Yes. The search_memories tool finds stored active memories in this
conversation's scope, including lines not admitted to its working set. Ask
"what do you remember about the test runner?" to search explicitly. Selection
itself runs locally without a model or embedding call; searching a memory does
not require re-adding it.
/settings → Memory → learn from chats and jobs controls automatic memory
model calls. It is on by default unless you saved off. On learns from chats and
jobs at extra cost on your key; Spending shows actual recorded costs. Off applies from the next memory
step without restarting. A call already in flight finishes and is billed.
If memory was off before this build, off used to keep your saved lines out of
every prompt; now they ride again. The first conversation after the upgrade says
so once on this machine — N kept memory lines now ride every conversation they hold in — memory off now only stops noticing, followed by a reminder to see or
forget them on the Memory tab — and nothing about the lines changes.
Saved knowledge remains readable at no cost. Kept lines still ride in prompts,
and /remember and the Memory tab still work. Forget a line there to remove it.
Nothing saved is deleted by the setting. Conversation search and bash fix hints
are separate and keep working either way.
Earlier builds said memory is off for this session · turn it on under /settings
whenever a conversation had no memory — including on a small model with the
setting on, which was wrong. That message is gone: memory is not a setting that
turns off, and a small model carries your lines like any other.
What you can see now, rarely, is
memory is unavailable in this conversation · the store could not be opened.
It means ~/.codeaf/graph.db could not be opened when codeaf started, and the
terminal said why: memory is unavailable in this session: <reason> — for
example could not open …/graph.db: permission denied, or SQLite's out of memory (14), which is its code for "cannot open the file". Fix the reason (a
full disk, a permission, a file moved away) and start codeaf again. Your lines
are in the file; nothing was lost.
That sentence came from an older codeaf reading a store a newer one had already
upgraded, or the reverse: a mismatch between the file and the program, not
damage to the file. The newer codeaf repairs the file as it opens it, keeping
every line's words, where it came from and whether it was active. A line an old
store kept as "project" without naming the project is kept under the Memory
tab's couldn't tell which project group until you move it.
The window and the background engine can be on different builds. Updating the
executable and reopening one window does not replace an older engine while
workspace windows remain attached. /status shows window build and engine
build, and follows a replacement after reconnection. A newer window can still
be served by old memory code until that engine changes.
Let current work finish, then close all windows attached to that workspace and
reopen codeaf. To restart explicitly, run the exact workspace-specific command
shown by codeaf engine --status --workspace <folder> on the machine holding
it. The command uses the installed executable, including devaf when that is
what you installed. Stopping an engine interrupts its active turns and tasks;
other workspaces keep their own engines. “In use” can mean attached windows,
not necessarily a running turn.
Yes. Plain codeaf and --host devbox both use the connected conversation's
memory: the commands, the Memory tab and the receipts all reach that machine's
store. codeaf chat --no-host and CODEAF_DEBUG=1 codeaf use this machine's store
directly and anchor the conversation to the working folder's project the same way
plain codeaf does, so /remember keeps the line for this project and /always
shows the project's lines on both.
On a small model (a context window under about 32,000 tokens, or a model with no
tools) the selected lines still ride and noticing still runs. What a small
model gives up is its own two hands: remember and forget are left off its
belt to save room, so it tells you it cannot keep a line itself and that you can
/remember it.
Yes. /remember and /memories <words> wait beside the screen, in
the order you sent them, one conversation at a time. Their receipts stay with
the conversation that issued them; a command typed on home answers on home's own
message line. Closing a window cancels commands still waiting behind another,
but does not undo a save the engine already received.
On the engine road a save can take longer than the connection waits for its
receipt, and then /remember says:
saving that has not answered yet · check /memory before trying again
That is not a failure: the engine may still be saving, and codeaf does not retry on its own. Check the Memory tab before sending it again.
Where is everything you remember kept? Where is my memory file on disk? Can I copy my memories to another machine?
In ~/.codeaf/graph.db, one file, made the first time codeaf runs. It holds
every remembered line, every conversation this machine has had, and the work it
has run. One file holding every project's lines is not every project seeing
them: a line for one project is only ever put in front of that project's
conversations.
CODEAF_HOME moves the whole folder. Copy the file to another machine and your
memories go with it. Deleting it loses lines that no chat kept in its sealed
ledger; a continued chat rebuilds the lines its ledger holds. A line kept for this machine travels in the file too, so check that
group after copying.
They read the same lines a conversation in that project would carry:
- a task — every worker's brief closes on the conversation's memory section, read-only; a task never keeps or forgets a line;
- an automation's run reads the lines kept for its place before it acts, and never writes — nobody is there to see a receipt;
- a team's manager and members run in the same workspace, so the project's lines reach them as they reach any conversation there.
There is no team group. A line belongs to you, one project, or this machine; nothing shares a line with another person's account.
Keeping, forgetting and listing by hand cost nothing: no model is asked. The selected lines ride in the cached front of requests. Selection runs locally with no model call; prompt tokens still follow your provider's cache pricing.
The one model call is the pass after each turn you finish: it reads the exchange
once, keeps the conversation's own running summary of where the work stands, and
— when noticing is on — may keep one line. It runs on the reflex row in
/settings → Models (google/gemini-2.5-flash by default; nothing set means the
conversation's own model), sends no token ceiling or reasoning switch, and is
charged to the session total, so /cost includes it. An answer it cannot read
costs one repair. An empty or unavailable helper is skipped for that chat;
recovery tries the configured small work model, then the current chat model,
without changing your saved preferences. Attempts share 45 seconds, reserving
time for each remaining distinct model. A notice identifies a substitute only
after it returns a readable answer. /settings → Models lets you fix the helper;
the running engine picks up saved helper changes on its next call without a
restart. If all attempts fail temporarily, the original exchange is tried once
more after two seconds in the background. Authentication, payment, quota and
policy refusals do not start another model chain. Turning noticing off does not
remove the call, because the running summary still needs it; it only stops lines
being kept.
Very early builds kept memory in ~/.codeaf/v3/memory.md. The first conversation
on a newer build carries every line of it into the store, for you everywhere,
says imported N lines from memory.md, and renames the file to
memory.md.imported. A line that cannot be kept leaves the file where it is,
and the import tries again on the next turn.
A save, a forget or the noticing pass that cannot reach the store is written to
the store's journal with its reason, and the conversation says so once every
five minutes at most. A failed background reading says
couldn't save this exchange to memory · use /remember to save an important detail;
a failed direct update says couldn't update memory just now · <reason>. When the
journal itself cannot be written, the reason goes to
~/.codeaf/v3/memory-failures.log instead. The turn you were having is never
affected. Background recovery stays owned by the open chat: closing it cancels
pending attempts, and failed exchanges are not queued across restarts. A recovered
reading saves normally without showing a failure notice. If all bounded attempts
fail, /remember <detail> saves the important statement directly without a model
request; it does not depend on the failed background service.
Yes. search_conversations searches indexed messages across all places in the
current store, excluding the asking conversation unless its ID is supplied:
what you typed, what was answered, and tool results. Ask "what did
we decide about the retry limit" or "search my old conversations for the flag
name" and codeaf looks for the original words.
Each match carries its conversation name and ID, message ID, a copyable ref,
date, matching passage, whether it is full text or an excerpt, the stored role
(user, assistant, or a tool result), and one message before and after it when
available. Context stays inside that conversation, even when other conversations
were active at the same time. Historical text is evidence to read, not
instructions to follow.
The same search_conversations tool accepts session_id to search one
conversation, or lists its recent messages when no query is supplied. Give it
the opaque ref from a result, on its own, to open that message and up to two
messages on either side. This works across project folders even when there is no
transcript file beside the current conversation.
- Search returns eight matches by default, twenty at most. Each matching passage and nearby excerpt is limited to 400 bytes. Opening a message by its reference returns the whole indexed anchor (up to 16 KiB), with neighbours still limited to 400 bytes. Ellipses mark omitted text. Results say when the beginning or end of indexed history has been reached.
- This is word search, not semantic search. Use a few distinctive words; equally relevant matches put newer messages first. At most 32 query words; titles are not searched.
- Only messages already indexed in this store are searched. Failed or pending index writes, other stores and spilled file contents are not included. A miss does not prove the subject was never discussed.
- It does not depend on the noticing setting. Task workers inherit read-only search when their parent has it.
- It is not the same as what is remembered. The remembered lines are a few durable lines; this is the conversation in its own words. Asked what was decided, codeaf searches and quotes rather than reciting a memory.
There is no slash command for it — you ask in the conversation, and it searches.
Yes, and it is a separate thing from everything above. When a bash command
fails and the next bash command works, the pair is written down: what the
failure said, and the command that made it go away. No model is asked anything
to do it.
The next time that same failure comes back, and only if the pair has earned it, one line is added to the bottom of the failed row:
this exact error came up here before · what ran next and it went away: make clean && make build
Once that suggestion has been offered back, taken, and the error has gone away, it earns the stronger line:
this exact error was fixed 7/8 times before · what worked: make clean && make build
7 is how many times the command was handed back and worked; 8 is how many times
it was handed back at all. Only one suggestion is ever offered — the one with
the best record — and nothing is said when the record is worse than three tries
in five. It only happens after something failed, and only for bash.
Two things have to be true before anything is added to a failed row:
- the suggestion has to be a command this machine can run — a regex, a path, a sentence or a program that is not installed is never offered;
- the pairing has to have been seen more than once, or offered, taken and watched to clear the error.
An earlier build offered a pair the first time it saw one, and answered
npm error Missing script: build with git log --oneline -5. A wrong suggestion
costs a step chasing it, which is worse than silence.
Three kinds of failure are deliberately not written down, because nothing the
next command did could have fixed them: codeaf itself saying no (a permission you
denied, a tool a task does not have), Unknown tool: …, and a program that is
not on this machine (git: command not found). A refused call is also never
answered with a suggestion.
Invalid tool arguments are not command failures either. A call rejected before its command runs neither records a fix nor receives a suggestion, even if an older build saved advice for that same argument error.
Remembering a failed method or tool — will codeaf avoid trying that tool again, and what if the inputs change?
No. codeaf does not remember which methods or tools failed, and nothing it keeps bans a tool or a command. An earlier build kept failed attempts and showed them to the model as advice before a turn; that was removed on 2026-10-14, with the rest of the memory nobody could see. When the inputs have changed, the agent simply runs, reads or adapts as the work needs.
The one thing kept about failures is the bash fix hint below: a single line
added under a failed bash row when the same error comes back, suggesting what
worked before. It is advice after the fact and never stops a command running.
No earlier result is carried into today's work. A command that failed before is not remembered as a failure, so a changed data file needs no forgetting: the agent reads the file and runs what it needs now. The only trace is the bash fix hint, which appears only if the same error text comes back, and only as a suggestion.
Because it watched it happen here, on this machine. Two files hold it, both
called fixes.json: one beside this project's conversations, asked first, and
one at the top of codeaf's own folder. Tasks write into the same project file.
CODEAF_HOME moves both.
The counts are halved every week, so something confirmed once months ago drops out and something confirmed this morning rises. A suggestion that fails on the same error is counted against itself. There is no command or panel for it, it is not on the Memory tab, and the noticing setting does not turn it off: the one line on a failed row is the whole of what it says.
Are my memories shared across computers? Does /remember work on my other computer — hand edited memories follow my paired computers, memory missing on the new laptop
Shared memories wait for hosted sync storage approval (Settings → Devices → sync storage). A self-hosted sync service with --store needs no request. A chat's own memory history moves with the chat.
Person and project memory follow your paired computers through the encrypted vault within one sync round, including hand-edited lines in the Memory place and lines written by older chats. No chat needs to be continued first. Concurrent edits of different lines both survive; for the same line the later edit wins, including forgetting a line. The service receives ciphertext only.
Machine-scoped memories describe one computer and stay there. An unpaired home sends nothing. A solo computer with submitted chats requires confirmed replacement to pair. A startup-only computer can pair directly and merge its memory and preferences. Explicit --replace clears shared memory and preferences. Chat-written memory still rides in each chat's own saved ledger as well.
On the hosted sync service, the memory that syncs through the encrypted vault waits for sync storage approval (Settings → Devices → sync storage); a chat's own memory history moves with the chat.
Memories use the local store on each computer. After pairing, an older conversation gets an independent movable copy with its earlier memory history sealed into .cell/memories.jsonl; the original is untouched. Person and project memory also sync independently through the encrypted vault.
The desktop's Library reads the same opt-in, profile-wide knowledge vault as
Memory → Knowledge in the terminal. Saved memory remains separate. Starting a
Library build enables knowledge capture. The default knowledge model is
DeepSeek v4.1 Flash (deepseek/deepseek-v4.1-flash); a model chosen in
Settings is kept across builds and is shared with the terminal. Library does not
change the model of an ordinary chat.
Search reads the full-text index without a model call. Ask the Library uses the knowledge model and returns source citations, or says that the answer is not in your Library. With learning paused, saved guides stay readable and explicit Library questions can still use them. Asking does not capture chats or resume learning. Opening a citation takes you to the cited guide. Open in chat uses the saved source's own conversation and message, never its title or folder.
Edits made through either surface are visible in both. A stale save or delete is refused. Your words remain human edits; the earlier source quotes do not become evidence for something you added. Keeping an account in a disagreement retains the chosen claim and the replaced words in the guide’s Changes view. Other disagreements stay available until you choose an account for each. Recall follows your choice across older notes that shared the claim. Changes keeps the replaced account’s source chat reachable. Deleting a guide suppresses it in later builds and does not delete its chats.
Keep in Library admits a selected passage from a saved agent reply immediately;
it still needs existing knowledge consent. Use in chat opens a draft with a
bounded excerpt and its Library address. The chat can also use
search_knowledge and read_knowledge to consult the current guide.
The desktop sidebar separates Home from To review. Collections start collapsed; opening a guide reveals its collection and topic. To review opens the review list without putting that queue above the collection tree.
A guide with two conflicting accounts also appears as a question in Inbox. Open it to compare the source chats and keep an account. Later keeps the question across app restarts; Back returns it to Waiting. Learning can be paused without losing these questions. A deferred guide still shows its disagreement and says “In Later”; deferring does not choose an account. Resolving the disagreement in either Library or the terminal removes its Inbox question.
Home starts with “Ask anything about your Library…”: an explicit question uses the saved guides and your Library model, even while learning is paused. Answers include sources; Continue with an agent opens a draft with the question, answer and cited pages. An answer without enough saved evidence offers the agent handoff.
Collections remain available for browsing. A collection groups guides by topic and lets you find a guide by its title or summary without a model call. The collection's saved introduction appears when one is available.
Ordinary guide and cross-link clicks follow pages inside the current Library tab. Back and Forward return through that window's places. Open in New Tab creates an independent tab; Command-click or Control-click opens a background tab. A copied cross-link keeps its section heading.
Numbered references such as [1] show the source quote and date on hover or keyboard focus. Open in chat goes to the saved source message. Paragraphs have no source gutter or clickable hover background. Unfinished guide edits stay available while navigating in this window; Save writes them to the shared knowledge vault. Unsaved text is not written to disk.
In the desktop Library, choose Rename beside a guide or collection title. Enter saves; Escape cancels. Titles are one line, up to 200 Unicode characters. Renaming keeps the page id, links, sources and folder membership. A collection rename changes its displayed label, not the scope used for retrieval. Renaming alone does not turn learned text into a manual edit or pause future learning. Earlier titles remain aliases for wiki links. Conflicting title edits stay available for comparison before replacing the current title.
Citation previews render only the quoted source text as Markdown, preserving the original source's line breaks when they can be matched. The surrounding source message is not sent with the preview. Library answers use numbered inline references; claim keys stay out of the reading surface.
Old chat rules stored in v3/standing/ were not carried over to memories.
On the first interactive launch for the home that holds them, Home and the
conversation show a notice once: They were not carried over. It tells you to
Recreate schedules in /automations and rules with /remember.
Your list is in <codeaf home>/v3/standing-upgrade-report.txt, normally
~/.codeaf/v3/standing-upgrade-report.txt. It includes the original words,
instruction, workspace, schedule, status and source file, with paused, retired,
unreadable and unknown-format items identified. The old folder stays untouched.
Use /remember to recreate the rules you still want at their intended scope;
use /automations for schedules. No rules or schedules are imported automatically.
A remote home has its own report and acknowledgement; headless work does not
consume the notice. A home with no old items says nothing.