Thenwise 0.3.1

• A paused project (thenwise off --project) no longer gets a brief of its past work when a session starts there. The sync for your other projects still runs.
• thenwise asof --clean removes a checkout again after a sync. The sync made every file in the data folder readable by you only, which also took away a checkout's run permissions, so git saw changes and kept the folder.
• Codex: every file in a patch gets its history before the edit, not only the first one.
• A decision or rule accepted from the inbox keeps the date its evidence gives, such as the commit that wrote a Decision: line. Before, it was dated when you accepted it, so asof missed it before that day. Accepting a "changed since decided" question closes the decision on the commit's date.
• A decision note about files stays in step with them: when its files change, the old file links go, and a sync with nothing new says so instead of updating.
• thenwise status works on a store built with --until.
• A vault path written with a trailing slash names its notes as without one.
• thenwise setup --notes (or another setup flag) with no value is an input error, as in the other commands. Before, setup --notes --yes saved "--yes" as a notes folder.
• A project already in your roots is no longer listed as new when the paths differ only in slashes.
• Old failure notices are not told again after a week.
• A vault inside a git repo is dated with one git call per sync, not one per note.
• Fixes for rare cases: a chat file that disappears during a session start, or a sync lock released at that moment, no longer drops the start's text; restoring a team backup refuses while a server under another user runs; stored paths of instruction files and memory files use forward slashes on Windows.

Thenwise 0.3.0

• Test history. When a test runs, the agent hears once per session which files' edits it failed right after in past chats of this project (another clone of the same repo counts), most often first. Before an edit, the file's hint names the tests that failed after edits to it. thenwise tests <test> shows the same. A run of several test files counts for each, and a test command is now recognised with any spacing.
• thenwise cost and /thenwise:cost: what the chats spent lately (only the part spent in the window, also for a chat that began earlier or was resumed), per tool and per project, and how much went into chats that hit a dead end. Claude Code gives dollars (at API prices, which a subscription does not bill) and tokens; Codex gives tokens; a tool whose chat files hold no cost is named as such. The first sync after updating reads the token counts of Codex chats archived earlier again from their files, once.
• The memory keeps what each chat did, not only what it said: every edit (the file, and whether a later turn put it back) and every test run (when, whether it failed, the file edited just before, the command with secrets masked). Nothing of a file's contents is kept, only short fingerprints of the edited text. The first sync after updating rebuilds the store once.
• A database error now names the file that cannot be read, with advice that fits it: the store in your data folder (delete and rebuild), a store given with --db (rebuild it there with thenwise ingest --db), the team chat cache (delete it; the next sync fetches the chats again) or the team server's database (restore it from a backup, never delete). Before, every such error said to delete graph.db in your data folder, even when another file had failed, which could throw away a healthy store.
• A flag that takes a value, given without one (thenwise status --db, thenwise distill --since), is an input error that names the flag, with exit code 2. Before, the command ran with its default and said nothing, so a typo could work on data you did not mean.
• thenwise asof with a date it cannot read now exits 2 and says so on stderr. Before, it printed the message as an answer and exited 0, so a script or agent could not tell it from a result.
• thenwise asof <date> --checkout puts the code as it was on that date in its own folder, next to the chats of that day, so you can read both together. Your working tree is not touched. thenwise asof --clean removes the folders and keeps any you changed.
• thenwise digest and /thenwise:digest show what each chat did since a time (the last 24 hours unless --since says otherwise): the first prompt, files edited, commits, PRs and dead ends, newest first. No model reads anything. The vault gains a Digest note per project for the last 7 days, which names changes and never chat text.
• thenwise export --out <file> writes one project's chats to a single file you can hand to a contractor or a new teammate, with no team server. It holds what Teams would share (masked, redacted, repo-relative paths, no tool output, nothing marked [no-memory]), shows a preview first and writes only after you type yes. thenwise import <file> checks every chat and adds them to another memory, where answers name them as chats of the sender, marked (imported); thenwise import --remove <name> takes them out.
• A chat turn in a memory answer now says what it changed, in one line: the files it edited, the commit it made and the PR it opened (did: edited src/cache.ts; commit 4c12308 "Split the cache"). "What did we try" is answered by what the turn did as much as by what it said. Rankings are unchanged; answers grow about 1.4%.
• Rule proposals. When dead ends keep happening at one file in three chats or commits, or you write the same [dead-end] line in two chats, the inbox gets a rule proposal with the evidence, for you to accept or reject. Only dead ends Thenwise saw happen count (a failed test, an undone edit, a revert, a closed PR, your own [dead-end] lines), never a sentence from a reply. No model is involved, the same evidence never proposes twice, and a rejected proposal stays rejected. thenwise mine runs it by hand.
• Decisions that may be out of date. When a later commit changes the files a decision is about, the inbox asks whether it still holds, naming the commit. Accept to close the decision as superseded; reject to keep it. It watches accepted decisions and Decision: lines in commits, asks once per decision while the question waits, and uses no model. thenwise mine runs it by hand; the background sync runs it after each ingest that found something new.
• thenwise decide and thenwise deadend record the files their chat edited in the last 30 minutes (up to ten), and any named with --file <path> (a path not on disk is kept and named, so a typo shows; --file with no path is an error). The note then shows in those files' history, so it reaches whoever opens them next.
• In a Copilot or Antigravity chat, a shell command that fails (a test that exits 1) now counts as failed. Before, the tool's mark that the call ran was read as the command passing, so the handoff said the last test passed and no dead end was kept. The first sync after updating reads those chats again.
• An edit that failed (its text was not in the file, or the tool denied it) no longer counts as an edit of that file in its history, hints and handoffs. The first sync after updating rebuilds the store once.

Thenwise 0.2.0

• A Copilot chat stopped by a credit limit or an error reads "stopped by the tool: premium request limit reached", without a second "stopped".
• A handoff now opens with one line that names the earlier chat's tool and keeps its work apart from the agent's: when the agent continues that work, it says first what that chat had done and anything it tried that failed, then what it did itself, and it claims only its own edits and test runs.
• Memory answers are shorter. A result reads date, project and source on one line, with the passage in its id; one-line results of the same PR or commit series fold into one; a chat's next turn shows only when it has a reply. With the shorter NEWER line below, answers to a set of real questions are about 18% shorter, with the same top results.
• When no shown passage holds all of a question's rare words, the answer says so in one line (no shown passage has all of: distribution, linux), so a partial match is not read as the answer. A record read in full after that search says which of those words it lacks.
• A passage that holds only what the person typed is labelled [prompt], and weighs half in why, tried and current, which look for answers. The first sync after updating rebuilds the store.
• A hit on a title or heading alone shows the start of the text under it.
• A second clone of the same GitHub repo counts as the same project, so its chats and commits answer without the all-projects fallback.
• The skill tells every tool to ask the memory before searching files or git about past work, and to read the files directly for what they show now. Codex, which shows the model no server instructions, gets the same rule for its shell on the memory_search tool.
• File history hints no longer repeat the line about citing memory ids, which the server instructions and the skill already say.
• File history hints stay silent when all they could say is when the file last changed, and the same commit on two branches gives one line.
• Codex gets a file's dead ends and decisions before it edits the file, as Claude Code does: the hint reads the files from the patch.
• memory_resume names a handoff the session start already gave the agent instead of printing it again, until a compaction takes it away.
• A commit whose message describes dead ends (a release note of a tool that records them) is no longer recorded as a dead end itself.
• A NEWER warning needs evidence that the later record replaces the earlier one: it supersedes it, carries its title, touches the same PR, or is a later commit to the same file. Records that only share words get none. The warning is one line: NEWER: <id> (<date>), <reason>. Read it before saying what holds now.
• Codex and Antigravity load no plugin commands, so there a /thenwise: command is shown as the line that runs it.
• A handoff starts the other chat's last reply at a whole word, and names files that chat wrote outside the repo, next to what git shows uncommitted.
• Codex: the note about untrusted hooks says what still works (memory tools, the live handoff) and shows once, on the first memory answer, memory_resume included.
• A background subagent's launch notice, and the id and usage lines at the end of a subagent's report, are no longer stored as part of the chat.
• You can see what Thenwise does. In Claude Code and Codex a session start says what it added for the agent, such as "Thenwise added: where a Copilot session stopped 20 min ago". Copilot and Antigravity show no plugin text, so there the agent says it in one line. /thenwise:shown lists exactly what went to the agent this session, block by block.
• A failed background sync or memory call is told once at the next session start, with where to look. In Codex, Thenwise says when its hooks are not trusted, and thenwise doctor checks it.
• The first run says, in every tool, how many past chats Thenwise reads from which tool, where the copy lives, that secrets are masked and nothing leaves the machine, and how to pause it.
• /thenwise:status opens with six lines: memory, this session, hooks, team, inbox and errors. The full detail follows.
• thenwise notices all|important|off, or notices in config.json, sets how much Thenwise tells you. THENWISE_NOTICES overrides it.
• Google Antigravity. Install with agy plugin install https://github.com/dheerajponnaganti/thenwise/tree/main/plugin. Chats from its CLI and app join the same memory, labelled by tool.
• OpenAI Codex. Install with codex plugin marketplace add dheerajponnaganti/thenwise and codex plugin add thenwise@thenwise, then trust the hooks in /hooks. Codex chats join the same memory, labelled by tool.
• thenwise connect antigravity|codex|cursor|gemini|opencode gives those tools the memory tools, so they can read this memory and what your team shared. --dry-run shows the change and --remove takes it back.
• GitHub Copilot CLI. Install with copilot plugin marketplace add dheerajponnaganti/thenwise and copilot plugin install thenwise@thenwise. Copilot chats join the same memory as Claude Code chats, with the same memory tools, hooks and privacy rules, and answers say which tool a chat came from. Copilot gets its own manifest and hooks file; the Claude Code files are unchanged. The first sync after updating rebuilds the store once. If you set your own include_entrypoints, add copilot-cli to read Copilot chats.
• Before this release, the plugin blocked every file edit in Copilot CLI, because Copilot denies an edit when a pre-edit hook fails and the released hooks could not run there. Copilot now gets no pre-edit hook at all, so a broken install can never block an edit.
• Teams with mixed tools: a shared chat carries the tool it came from, and a teammate's results say "Copilot chat of alice" or "Claude Code chat of bob". The team server adds one column at its next start; older Thenwise versions keep working and send no tool.
• thenwise forget and thenwise uninstall name Copilot's own chat files and the copies Copilot keeps on GitHub, which Thenwise cannot reach.
• The /thenwise: commands work in Copilot CLI with any model. Copilot leaves ${CLAUDE_PLUGIN_ROOT} empty, so each command now falls back to Copilot's install folder by itself; before, it depended on the model rewriting the path.
• Pick up where another session stopped, in any of the tools. When a session starts, Thenwise reads the newest chat another session left in the project, straight from Claude Code's, Copilot's, Codex's or Antigravity's own file, and tells the new agent where it stopped: a usage limit, a step that never finished, or its last reply; the task; the last prompt and reply; the files it edited; the last test and whether it passed; commits; dead ends; and what is uncommitted now. It needs no sync, so it works the moment you switch. /thenwise:resume and a new memory_resume tool start with the same block. Chats marked [no-memory], paused projects and forgotten chats never hand over.
• A usage limit or an API error that stopped a chat is no longer stored as a reply. The turn ends with a stop line instead, so search, resume and teammates see that the work paused there. The first sync after updating rebuilds the store once.
• You can see the first sync. Claude Code and Codex say when it starts, show how far it got after a prompt at most once a minute, and say once when it is done, with the number of chats remembered. A rebuild after an update shows the same. /thenwise:status shows the progress any time. While the first sync runs, memory answers say the memory is still filling up.
• Teams: a teammate's half-finished chat shows in your session brief and in /thenwise:resume, with their tool and where they stopped. A team member's chat now syncs after a reply (at most every 10 minutes) and right after a usage limit, so it reaches the team while it is fresh. A chat that arrives after your session started is given at your next prompt.
• After a compaction, the resume block no longer comes out empty when the last turn was very long, and it now also gives back what the session did: the files it edited, the last test and its result, open questions, and what is uncommitted.
• Leave a question for whoever picks the work up next. A line [question] why did you skip the migration? in any tool's chat, shows in the next agent's handoff and session brief, and in /thenwise:resume, with an id such as q-3f2a. It stays open for a week until a later chat answers it with [answer q-3f2a] ... or an [answer] line that names it. Teammates' questions show the same way.
• Teams: when you open a file a teammate worked on in the last day, its history hint now starts with who, in which tool, how long ago, and whether their chat was stopped by the tool, so the work there may be half done.
• Every tool now installs the plugin from one plugin/ folder in the repo, the way claude-mem and Ponytail ship theirs. Claude Code clones once instead of twice, so the extra clone can no longer fail with a permission error on a machine with no GitHub SSH key.

Thenwise 0.1.28

Windows no longer flashes console windows, and resume stays on the project you are in. Memory answers point agents to the memory tools.

• Windows: Thenwise no longer opens blank Node.js console windows. Every process it starts (the background sync, memory lookups, git) now runs hidden; before, windows flashed open with each hook and the sync's window stayed until you closed it.
• Resume is about this project. Another project's to-do list no longer fills it, it shows at most three open items with where to read the rest, and in a repo with no recorded chat it says so instead of showing a chat from your home folder.
• Memory answers point to the memory tools (memory_read, memory_current) instead of CLI commands, which an agent cannot run as tools.

Thenwise 0.1.27

Memory pointers now reach more past questions and long prompts, a too old Node says what to do, and team sync is steadier. In a new eval, answers held level with 0.1.26 on 6% fewer tokens.

• A team sync no longer loses its fetch when the server resets a reused connection. A request that is safe to repeat is sent once more; before, the sync brought in nothing that time.
• A too old Node now shows a notice at session start with what to do. Before, the plugin stayed off with no clear message. If Node is missing or /thenwise:status cannot run it, Claude now says what to install.
• Long prompts, such as a pasted log with a question at the end, get memory pointers again. Before, the search used the whole prompt, ran past the hook's time limit and gave nothing. It now searches only the sentences that ask about the past.
• Memory pointers now also appear for past questions like "why was the cache split" and "what did we decide". Before, only a few phrasings such as "why did we" got them.
• Asked why something is the way it is, Claude now checks memory before grep and git log. Past chats hold reasons that code and commits do not.
• The team server refuses a shared file path that starts with a scheme such as file: or with a home folder, and the client never sends one. Before, such a path from a buggy or newer client was stored and shown to every teammate.
• Installing and updating the plugin works on a machine with no SSH key on GitHub. Before, it could fail with a permission error.

Thenwise 0.1.26

A full rebuild now uses far less memory, and answers hold up in new evals.

Why this release: one very long chat could push a full rebuild past 2.5 GB of memory, enough to slow or stop a sync on a smaller machine. Sync should never be the thing you notice.

• Long chats take far less memory: a full rebuild on a real history with a 260 MB chat fell from about 2.6 GB to about 500 MB, and the store it builds is the same. The first sync after updating rewrites older long chats in the archive once, which peaks around 1.8 GB. Their text does not change.

New evals, graded blind on hidden answers:

	Plain Claude Code	Thenwise	Difference
Your own history: correct	37%	93%	2.5 times more
Your own history: raw tokens	7.1 million	3.6 million	50% fewer
Your own history: seconds per answer	26	14	1.9 times faster
A teammate's shared chats: correct	17%	88%	5.3 times more
A teammate's shared chats: raw tokens	5.0 million	3.1 million	39% fewer
A teammate's shared chats: seconds per answer	24	16	1.5 times faster

Every source was frozen before the questions were written, and a sandbox blocked everything else on the machine. On your own history, this build scored 93% against 87% for 0.1.24, with the same token use. How we measured.

Why these numbers changed: earlier rounds scored 83% against 47% on your own history, and 88% against 25% on shared chats. Plain fell because it can no longer read live repositories, live pull requests or anything written after the questions: all of that once helped it. Thenwise rose on your own history because its test store now holds every chat and note from before the cutoff, where earlier rounds missed some. Token figures also moved from a weighted count per answer to raw totals, so they don't compare directly with earlier numbers.

Thenwise 0.1.25

One security fix, Windows fixes with Windows tests now required in CI, fixes for search, setup and sync, and a notice when a new version is out. The first sync after updating rebuilds the store once. This is the first release published from CI, with provenance.

• Thenwise tells you when a new version is out, once per version at the start of a session, and says when it has been updated. Once a day the background sync asks npm for the newest version and sends nothing about you or your work. Turn it off with thenwise update-check off. Search, tools and foreground hooks stay offline.
• One empty chat file no longer stops all memory updates. Before, every sync failed while that file existed.
• The default vault folder is made on the first write. Before, a fresh setup recorded ~/Thenwise but never made it, so no notes were written and every sync logged an error.
• The sync log says why a step failed when the step reports it on standard output.
• Search finds a word that appears only in a title, such as the subject of a commit that also has a message body. Before, it said the word was not recorded. The first sync after updating rebuilds the store once.
• Windows: project folders, notes and file paths are compared with forward slashes everywhere, so a chat from a deleted repo keeps its project and a note's links resolve.
• Windows: thenwise uninstall stops a running background sync.
• Windows: thenwise team share-chats no longer hangs on a chat that started outside a repository.
• thenwise team join works on a fresh install, before anything has made the data folder.
• Windows: thenwise distill and automatic capture start Claude Code when npm installed it as claude.cmd.
• Security: Decision: and Dead-end: lines in commits and PRs now wait in the inbox. Anyone who lands a commit could write one, and it became a trusted note. Accept them with thenwise accept --all-of decision.
• thenwise decide and thenwise deadend name a similar note you already have.
• thenwise doctor says when gh is not installed, in place of asking you to sign in.
• thenwise doctor checks for git, which reads your commits on any host. Having no gh only fails when GitHub PR reading is on.

Thenwise 0.1.24

Thenwise 0.1.24

More secrets masked in shell commands, and shell commands now link files and commits on every system.

• More secrets are masked: --password value, -Token value, setx, SetEnvironmentVariable, ConvertTo-SecureString and PSCredential. Older chats are masked again at the next sync.
• Shell commands link files on Linux and Windows as they do on macOS, including relative paths. Commits are linked when written as git -c x=y commit, git commit -F file or --amend. The first sync after updating rebuilds the store once.

Thenwise 0.1.23

Fixes from an npm package review and a Hub test, a Hub on another host, and a README that shows Thenwise at work.

• Team server: a Hub on another host works with --allow-origin. Its session cookies can travel with a cross-site request, and the new GET /v1/session/csrf hands the Hub the value it cannot read from the cookie (API 1.1 addition; v1 is unchanged).
• Windows: a full rebuild no longer fails while Claude Code holds the store open. The new store waits beside it as graph.db.next, and the next process that opens the store swaps it in.
• Masking: long text with many hyphens is masked in linear time. Before, a 100 KB note could hold the team server for about 9 seconds, and a long hyphenated line slowed the archive and hooks.
• thenwise --help and thenwise --version print to stdout and exit 0.
• uninstall stops only the background sync itself, never another process that happens to reuse its pid.
• Team server: an export past 65,535 files answers 413 with a clear message instead of failing.
• Teams: a chat marked [no-memory] after it was shared leaves the team server at the next sync, and teammates drop it.
• Teams: a Markdown file shared as a note keeps its kind (decision, dead end, rule or finding) from type: or kind: in its front matter.
• Teams: a teammate's note shows its project in search results instead of "global".
• Team server: /v1/health reports the Thenwise version.
• Messages: archive names chats left out for [no-memory] as such, and team share-chats mentions later syncs only when chats are left.
• README: what Thenwise is, the install lines and the results open the page. Three recordings of real Claude Code sessions show the same question with and without Thenwise, three questions in one session, and a dead end caught before an edit.
• How we measured: docs/eval.md explains the questions, the two arms, the blind grading and the results, and how to run the harness.
• npm: a clearer description and more keywords.

Thenwise 0.1.22

Five bug fixes from a code review, and a corrected measurement.

• Off the record: [no-memory] added to a chat after it was archived now drops the archived copy at the next sync, so the chat leaves the memory. An excluded project's old copies still wait for thenwise archive --prune-excluded.
• Sync: an update waits for a running search instead of failing into a full rebuild.
• Sync: an empty or half-written sync.lock no longer blocks syncs for an hour.
• Git history: an update bounds commits by your own first chat, as a rebuild does, so a teammate's older shared chats no longer pull in extra history.
• File hints: cat -n <file> and bat -n <file> get the file's dead ends and decisions, as cat <file> does.
• README: plain Claude Code's individual score is corrected from 63% to 47%. In the round behind the old number, plain found leftover copies of our records on the test machine: saved tool output holding vault notes and old chats, the prompt history file, and Claude Code's own memory notes. 5 of its 19 right answers came from those copies. The re-run blocks the vault and its copies, and plain scored 47% in both of two runs. The plate now reads 1.8 times more questions answered right (83% against 47%) and 2.2 times faster answers (23 seconds against 51).