Changelog
What changed, and when
The viewer and the engine ship together. Anything marked unreleased is built and notarised but not public yet.
2.1.4 (72)
October 2026- **Gemini CLI sessions are read.** What you write in Gemini CLI now reaches your mind (`~/.gemini/tmp`, one folder per project). The environment notes Gemini adds itself, tool output, images and file contents pulled in with `@file` are left out; only what you wrote is read. Setup switches the source on when it finds records; in an existing mind it stays off and the choice is yours.
- **An off source says when it has records.** In Settings › Sources, a source that is off but has something to read on this machine now says *There are records for it on this machine*. Codex or Gemini CLI switched on later showed as "empty" while being read; they now show where they look and how many files they found.
- **Turkish left in the English window.** The batch queue's answer, an error from a decision or question button, cortex and export errors, and the quick note's answer now follow your mind's language. "Codex oturumları" in the source list is "Codex sessions" in English.
- **No Full Disk Access asked for a source that is off.** On macOS, if you switched Messages or Apple Notes off, Settings › Engine no longer asks for access on their behalf.
2.1.3 (71)
October 2026- **A repair button for warnings.** Two warnings in Settings › Engine ended in a terminal command: old duplicates where the same message counted twice for a memory, and masking rules that changed since events were written. They now have *Merge duplicates* and *Mask again* buttons; both change the database for good, so each says what will happen and asks first.
- **False warnings gone on Windows.** A source switched on but never pointed anywhere (WhatsApp exports, note folders) became a permanent "cannot be read" warning on the main screen; it now counts as a setting still to make. A source that is off, or does not exist on this computer, is no longer reported as "genuinely silent". Messages and Apple Notes, which exist only on macOS, are gone from the Windows source list.
- **The weekly digest mentions pending decisions.** If the inbox has decisions waiting, the digest's last line says how many.
- **Readable numbers.** With a single event pending, consolidation showed "0.0 million tokens"; the unit now follows the size. The engine's Turkish sentences use a dot for thousands (24.824), and its waiting sentence is in English in English.
2.1.2 (70)
October 2026- **Settled conflicts close by themselves.** When a behaviour contradicted a memory, the question it opened kept the memory under question until answered: it reached assistants flagged and stayed out of what you give chat assistants. If the memory has been confirmed three more times since the question opened, that behaviour was an exception; the question now closes itself with "the memory holds", and the reason is recorded. Questions with no later confirmation are left for you.
- **Give your mind to VS Code as a file.** Settings › Assistants › *Also hand it over as a file* now includes VS Code: the mind is written to `~/.copilot/copilot-instructions.md`, which Copilot reads every session. GitHub Copilot CLI reads the same file. Whatever you wrote in it yourself is left alone.
- **The weekly digest switch stays on.** macOS answers the permission question before you press *Allow*, and the switch turned itself off because of it. It now stays on; without permission a note and a button to Notification settings appear under it.
2.1.1 (69)
October 2026- **A quick note.** One line about yourself without opening the window: under the search box in the macOS menu bar panel, and *A note about yourself…* in the Windows tray menu. The line goes into the journal; being your own word, it can become a memory on its own at the next cycle. Assistants only read the mind; you are the one who writes to it.
- **Give only the new ones.** Under *Give to chat assistants*, Claude and Gemini get an *Only the new ones (N)* button when memories have formed since the last time: both merge an import with what they already know, and sending the same memories again is noise. ChatGPT does not get it; its custom instructions box is replaced. From a terminal: `coredence handoff claude --new`.
- **Weekly digest.** Turned on in Settings, a notification on Sunday evening says how many new memories formed this week and the strongest of them; clicking it opens the window. It stays on your computer. Off by default.
2.1.0 (68)
October 2026- **Open at login.** A new switch in Settings: when it is on, Coredence starts without its window when you log in — in the menu bar on macOS, in the tray on Windows. After a restart the last cycle and what is pending are still there. On Windows it shows in Task Manager's Startup tab, and uninstalling removes it.
- **A darker, narrower tray menu.** On Windows the menu now opens in the same dark as the window. This week's memories sit in a submenu: in the main menu they stretched it to the width of the longest sentence. Two short lines remain at the top — how many memories, how many pending, and when the last cycle ran.
2.0.9 (67)
October 2026- **A tray icon on Windows.** Coredence now sits next to the clock: hover for how many memories it holds, right-click for the last three it learned this week, what the last consolidation cycle said, *Open window*, *Update now*, *Open pending* and *Quit Coredence*. Clicking a memory in the menu opens the window on it. Closing the window no longer quits the app; it goes to the tray (Settings › *Stay in the tray when closed*, on by default), the counterpart of the macOS menu bar icon. The consolidation cycle runs either way.
- **One window on Windows.** Opening Coredence from Start while it is running no longer starts a second copy; the running window comes forward.
2.0.8 (66)
October 2026- **See when you last gave it.** Settings › Assistants › *Give to chat assistants* now shows, under each assistant, when your mind was last given to it and how many new memories have formed since. Only memories that could actually go to that assistant count; drafts, memories under question and the cortices you hid do not. From a terminal: `coredence handoff --last`.
- **The Claude app no longer shows as "never read".** The Claude app never asks the server on its own, so even after taking your mind through *Copy and open* it showed "not read yet" in the menu bar and "connected but has never read it" in Settings. It now shows "took your mind by paste" and when; the needless warning is gone too.
- **Giving to ChatGPT is a step shorter.** *Copy and open* opens ChatGPT's settings window instead of its home page.
2.0.7 (65)
October 2026- **Giving your mind to Claude is one step.** *Copy and open* used to land on Claude's introduction page, one more button away from the import. It now opens Claude's memory import window directly. The instruction is clearer too: don't copy the prompt in the window's step 1 (it would replace your mind on the clipboard); paste straight into the box in step 2.
- **The Mac tab is called Assistants.** The "Connection" tab in Settings is now "Assistants", as on Windows; connecting coding assistants and giving your mind to chat assistants both live there.
2.0.6 (64)
October 2026- **Give your mind to Claude, ChatGPT and Gemini.** These chat assistants never read your mind on their own, and ChatGPT cannot reach a local server at all. Each has its own door for outside text: Claude's memory import, Gemini's *Import memory*, ChatGPT's custom instructions. Settings › Assistants (called Connection on the Mac in 2.0.6) › *Give to chat assistants* now copies your strongest memories at the length that door accepts, opens the assistant and says in one sentence where to paste. Traces, the cortices you hid and memories under question stay out. Nothing is sent; you paste it.
- **A local model without a terminal.** Choosing "a model on this machine" in setup used to end in `ollama pull qwen3:8b`. Setup now checks for Ollama: if it is missing, *Download Ollama* opens its page; if the model is missing, *Download the model* has Ollama fetch it, with a progress bar. Setup continues once the model is ready.
2.0.5 (63)
October 2026- **No more false "source cannot be read" warning.** Switching on every source in Settings › Sources turned sources with nothing to read yet — Codex on a machine without it, a ChatGPT or Claude export not downloaded yet — into a permanent warning. A source whose file is simply not in its usual place yet is now waiting, not broken; it is read the moment the file appears. A path you typed yourself that leads nowhere still warns.
- **Says why nothing was read.** With every source off, *Update now* used to finish without a word. It now says no source is switched on and where to turn one on.
- **The engine speaks the same language as the app.** Setup and update logs, the menu bar summary and the checks now say memory, trace, cortex, consolidation, signal strength, conflict and mind.
2.0.4 (62)
October 2026- **Your mind's digital twin.** Coredence now speaks the language of what it is: a mind built from what you write. In both windows and the menu bar a rule is now a **memory**, and you search with *Search memory*; evidence is a memory's **traces**; a topic is a **cortex**, and the links between cortices are **synapses**; distilling is **consolidation**, the hourly run the **consolidation cycle**; confidence is **signal strength**, a contradiction a **conflict**; and the identity is your **mind**.
- Nothing about how it works changed: the same engine, the same file, the same traces behind every memory. Command names (`coredence distill`, …) stay as they were.
2.0.3 (61)
October 2026- **One answer per rule.** A contradiction is a question about the rule, not about one observation. When a rule had several open contradictions, answering one left the others behind: the same rule was asked again on the next card, or a dropped rule kept its questions. Now one verdict closes all of them, and the inbox shows them together on one card, with all their evidence.
- **Duplicates are asked sooner.** The search for rules that say the same thing does not call a model, so it now runs every hour even while distilling waits — the pairs no longer wait a day.
- **How each assistant reads you (Mac menu bar).** Claude Code loads your identity from the skill file every session, so the panel says so instead of showing an old server read. Codex and Gemini read it from their instruction file when that is on; where nothing reaches them yet, *Give as a file* switches it on in one click.
2.0.2 (60)
October 2026- **Rules that say the same thing.** Now and then the engine writes the same rule twice. It now finds such pairs — rules that rest on the same messages or share their words — and asks in the inbox with the two sentences side by side: *Same, keep the top one*, *Same, keep the bottom one*, or *Different rules*. Merging moves the evidence to the rule that stays; nothing merges on its own, and a pair you answered is not asked again.
- **Move events out of a topic.** The counterpart of merging: a topic's panel has *Move events out…*, with search and a checklist, into a new topic or an existing one.
- **A fuller menu bar on the Mac.** The icon is now the brain from the app icon. The panel shows what Coredence learned this week, which assistants read your identity and when, when the next hourly run starts, and a search that opens the window on a rule.
2.0.1 (59)
October 2026- **The hourly run no longer skips while the Mac sleeps.** It was scheduled by interval, and launchd drops an interval that falls during sleep: over 31 days, 408 of 745 runs happened. It is now scheduled by the clock, and a missed run happens once on wake. Existing installs switch over by themselves.
- **Merge two topics that are the same subject.** A topic's panel has *Merge into another topic*, closest neighbours first. It asks first, because a merge cannot be undone.
- **A failed update on Windows says why.** The window used to close and not come back. Now the installer keeps a log, and the next time Coredence opens the strip on the main screen says what went wrong — or, if the installer never ran (Windows Defender can delete unsigned installers), where the file is. Applies to updates started from this version on.
- **Export the whole identity on Windows.** Settings › Identity › As Markdown / As JSON, the counterpart of the app menu on the Mac.
- **Easier to read on Windows.** Faint text now meets the WCAG AA contrast ratio.
- **Errors that looked like empty states.** A rule whose evidence could not be read no longer says it has none. On the Mac a failed *Update now* stays until you close it, and a failed topic rename is shown. An empty identity no longer hands assistants a file that says "0 rules".
- **`coredence` on PATH with Homebrew.** `brew install --cask coredence/tap/coredence` now links the `coredence` command, so plugins that start the server with `coredence mcp` find it even where `~/.local/bin` is not on PATH.
2.0.0 (58)
October 2026- **Check for Updates… in the app menu (Mac).** Right under Settings…, as in other Mac apps. It asks the engine, says "Coredence is up to date" or offers *Download and restart*.
- **The update check no longer trips over GitHub's limit.** GitHub's API allows 60 anonymous requests an hour per network; when another tool on the same network used them up, *Check now* said "could not reach github.com" for an hour. The engine now reads the latest version from the releases page, which has no such limit, and keeps the API as a fallback.
1.9.9 (57)
October 2026- **Correct a rule, or say it is not you.** Every rule's panel now has *Correct* (write the sentence the way it really is) and *This is not me* (the rule leaves your identity and stops reaching your assistants; its sentence and your decision stay on the engine's record). Until now a wrong rule could only be waited out.
- **Old "right now" rules retire.** State rules ("preparing the launch") are meant to fade after about a month without being seen, but a well-supported one could never drop below the threshold. Now it does; if it is still true it is seen again and comes back fresh. Assistants also get the date each rule was last seen when they search.
- **Update from the main screen on Windows.** The new-version strip has *Download and restart*, as on the Mac.
1.9.8 (56)
October 2026- **Codex sessions are read.** What you write in Codex is now read (the terminal tool and the desktop app, `~/.codex/sessions`). Task specs pasted in from another assistant — headed, numbered, full of file paths — are not counted as your words. On for new installs that have Codex; existing installs find it off in Settings › Sources.
- **Hand your identity to Codex and Gemini as a file.** A switch in Settings › Assistants, off by default, also writes your identity to the file the assistant reads in every session (`~/.codex/AGENTS.md`, `~/.gemini/GEMINI.md`) and refreshes it on every run. Only Coredence's marked section is written or removed; what you wrote in that file is left alone.
- **English all the way through setup.** In an English identity the setup log, reading, distilling, model checks, connecting and the update check now speak English; before, most of those lines were Turkish. Source names are translated on Windows too.
- **Smoother map.** Moving the mouse no longer rebuilds the whole scene, and on the Mac a clicked node no longer jumps.
1.9.7 (55)
October 2026- **Assistants know when to read you.** The MCP server now tells the assistant to read your identity at the start of a task and search your rules before a decision; until now it only listed tool names, and assistants never called them. Tool descriptions carry those triggers, `identity` returns rule ids and takes a project, an empty identity says what to do next, and state rules past their half-life no longer reach the assistant. Settings › Assistants shows what to tell an assistant that has never read your identity.
- **Setup that tells the truth.** On Windows a failed step no longer ends in "Ready" and an empty map. On the Mac the window no longer freezes while the hourly update is checked, a failed model check returns to the model step, and errors show their last lines rather than the whole log. Claude Code installed with npm is found and connected on first run.
- **Safer and steadier.** The hourly run recognises Claude's session limit and an expired login. Hugging Face, Replicate, Groq and xAI keys are masked. Opening the sharing settings no longer rewrites them, and sliders save on release. A chosen identity file is now also the one the engine writes to, with a way back if it will not open. The Windows window fits the screen at 125-150% scaling.
1.9.6 (54)
October 2026- **Add Coredence from your assistant.** The public repository is now a plugin for Claude Code and Codex, an extension for Gemini CLI, and an Agent Plugin for VS Code and GitHub Copilot. Install the app, open it once, and in Claude Code `/plugin install coredence --marketplace coredence/coredence` is enough. The plugin carries no code; it starts the read-only server inside the app with `coredence mcp`. On macOS the app makes that command available at `~/.local/bin/coredence` each time it opens.
- **The plan option says what to do while sales are closed.** Setup now says that if the pricing page shows sales are not open yet, you can start with Claude Code or your own key.
1.9.5 (53)
October 2026- **Your key goes where you chose.** Switching from the Coredence plan to your own API key kept the plan's address, so the key went to our relay instead of your provider and distilling failed. Switching to a local server that needs no key sent it the previous key. A model choice now replaces the previous one completely: address, model name and key are never carried over.
- **Another server, done properly on Windows.** "OpenAI-compatible server" promised OpenRouter, Groq and Together but always used api.openai.com. There is now a separate "Another server" choice with its own address and model name, as on the Mac, and both windows take a model name.
- **Button labels centred on Windows, for real.** 1.9.4 adjusted line spacing, which does not move the letters: Windows' own font sits low in its box. The window now carries its own font, Geist, the same one the site and the browser demo use.
- **First run.** The identity language starts from your interface language instead of always Turkish; the steps scroll on small screens; the plan option no longer claims the licence never reaches us (it authorises model calls). The short reasons inside engine warnings are in English too.
1.9.4 (52)
October 2026- **Silent updates on Windows.** "Download and restart" now installs without showing any window; Coredence closes and reopens on the new version. The change is in the engine that starts the install, so it shows from the update after 1.9.4.
- **Engine warnings in English for English identities.** The strip above the map and the Engine settings page showed Turkish warnings.
- **Small, visible fixes.** Button labels are centred on Windows (Segoe UI sat them low). Setting descriptions were drawn in a code font and cut off with an ellipsis; they are now plain and complete. Switches line up with their label. An empty source list no longer reads as "the engine's answer could not be read". "System language" is translated in the English interface.
1.9.3 (51)
October 2026- **The monthly summary talks to you.** The heading is the month's name ("October 2026") and new rules are written as sentences; no internal names, no domain tallies. Axes that moved are described by their poles. The last line counts everything waiting in the inbox: contradictions, questions and rules to confirm.
- **Contradiction cards read properly.** Instead of "«…» … (evidence: [134])" they say "Behaviour contradicting this rule was observed: …"; the evidence itself is right below.
- **Decision axes:** A card's heading is the axis's two poles, with the verdict underneath. An axis with a leaning says so in colour ("Leaning: …").
- **Map:** The "Constellation" layout is now "Clusters", and the two option groups are labelled "Layout" and "Colour". With no bridging rules, the "reaches 12+ subjects: 0" row is hidden.
- **English identities:** Axis poles are in English; a Turkish verdict was left in the identity your assistant reads. The MCP server reports the right version.
1.9.2 (50)
October 2026- **Version number corrected.** 1.8.10, 1.8.11 and 1.8.12 should have been 1.9.0, 1.9.1 and 1.9.2; numbering continues from here. The contents are the same as 1.8.12. If you have 1.8.12 on Windows, Settings › New version › "Download and restart" brings you this one.
1.8.12 (49)
October 2026- **Updating on Windows from inside the app.** In Settings › New version, a "Download and restart" button appears when there is one: the engine downloads the installer, checks it against the SHA-256 checksum GitHub publishes and starts a silent install; Coredence closes and reopens on the new version. A file whose checksum does not match, or cannot be fetched, is deleted and never run. The button works for versions after 1.8.12; 1.8.12 itself has to be installed once from the site.
1.8.11 (48)
October 2026- The Windows installer asks for the install location every time again; it used to hide the page when Coredence was already installed, which took the choice away. The welcome text is clearer, and the logo at the top right is the drawing alone, without its square background.
1.8.10 (47)
October 2026- **The Windows window finds the engine again.** 1.8.9's new installer, while cleaning up the old installer's entry, also deleted the value the window used to find the engine: the Settings button disappeared and the decision axes would not open. The window now looks for the engine next to itself first; if it still cannot find it, the buttons say why instead of doing nothing.
- The switch between the scene and the list is now called "Map", not "Constellation": that was also the name of one of the four arrangements. The decision axes button's tooltip says what it is for. The setup window's text is plainer; an update no longer asks about the folder, and file paths no longer scroll past during installation.
1.8.9 (46)
October 2026- **The Windows installer has been rebuilt.** It is no longer Windows' old grey wizard: it is a dark window in Coredence's look, title bar included. The pages are short (welcome, install location, progress, finish); an update skips the location page, and the finish page comes with "Open Coredence" ticked. No licence, components or folder pages. The old installer's entry in the Apps list is cleaned up; your identity, the hourly round and your assistant connections stay as they are.
1.8.8 (45)
October 2026- **Installing on Windows is one click.** The five-page setup wizard is gone: double-click the installer, a few seconds of progress, and the Coredence window opens. First-time setup (your name, the model, reading, the first distillation) happens in the window's own screen; an update only refreshes the hourly round and reopens the app.
- The in-app first-time setup now connects your installed assistants too, and on Windows it also installs the hourly round. Only the Windows wizard used to do these. If connecting or installing the round fails, setup does not stop: it says why and leaves it to Settings.
1.8.7 (44)
October 2026- **The Windows setup wizard has been redone.** The welcome and finish pages show the site's network scene on the left, and the inner pages carry the app icon at the top right; both are drawn at twice the resolution so they stay sharp on high-DPI screens. The welcome text is no longer the stock sentence: it says what Coredence does, that your identity stays on this computer, and that updating leaves it untouched.
1.8.6 (43)
October 2026- **Updating on Windows no longer takes minutes.** Setup ran the first-install flow on every version, and that flow ended with a draft distillation: at the "Preparing your identity" step, with Cancel disabled, it waited for the model. If an identity already exists the step is now skipped; the hourly round handles new events.
- Turkish letters in the setup window came out garbled ("kapalı"): the engine wrote UTF-8 and the window read it in Windows' own code page. Setup now asks the engine for the encoding it reads. The engine's raw output is hidden by default, the step labels follow the setup language, and the product name replaces "Nullsoft Install System" at the bottom.
- On macOS the pending distillation showed "0 million tokens" below one million; it now shows one decimal place, as the Windows window does.
1.8.5 (42)
October 2026- **"Check now" now says what it found.** The button was checking, but nothing showed the result: if the app was up to date, or the daily check had already found the new version, the screen looked the same before and after. On Windows the "Released" line was not even refreshed after the check. The engine's answer and the time now sit under the button.
- When the network could not be reached, a manual check could say "the installed version is up to date" — an answer to a question that was never asked. It now says it could not reach it, and names the last known new version if there is one. On macOS the "karaca exit code 1" prefix on engine errors is gone too: the engine's own sentence shows as it is.
1.8.4 (41)
October 2026- **A menu bar item on macOS.** Without opening the window: when the hourly round last ran and what the engine wrote ("distillation waiting, at the latest in 5 hours"), how many things are waiting for a decision, and the engine's warnings. If something is waiting, its count sits next to the icon. "Update now" and "Open what is waiting" are there too. Settings › Scene turns it off.
- **The scene opens where you left it.** Zoom, where the scene was panned to and the nodes you placed by hand are back next time; if the arrangement changed, the scene opens fresh. This is written to the window's settings, not to the database. Settings › Opening turns it off, and has one more option: if something is waiting for a decision, open straight to that list.
- The two windows behaved differently on launch. Windows remembered an arrangement chosen on the bar and macOS forgot it; macOS remembered the list view and Windows always opened on the scene. Both now remember both.
- The Windows window remembers its position and size; left maximised, it opens maximised, and if the saved position is on a screen that is no longer attached it opens in the middle. Settings › Engine can open another identity file (a backup, another machine's export). On macOS that choice did nothing until the app was reopened, and the screen did not say so; the chosen file now opens at once.
- **Installing the hourly round on Turkish Windows could crash.** Task Scheduler writes its errors in Turkish and in the console code page, and the reader expected a different one. When "access denied" could not be decoded, the person saw a stack trace instead of a message. A new test line running on a real Windows machine found it; the engine's tests now run on both platforms on every push.
- Three new engine commands. `coredence voice` checks a commit message against your measured voice and can be installed as a hook in a repository. `coredence disk` reports the engine's own footprint and the size of your repositories, with the day the identity last saw you touch each; it deletes nothing. `coredence defaults` says what to choose when starting a new project: the stack from your repositories' dependency files, the rest from your identity's rules.
- Correcting a rule by hand (`coredence review revise`) had failed on every call since 18 September. Fixed, with a check that catches that kind of mistake. The updater never deleted the images it downloaded; it now removes the old one once the new one is verified.
1.8.3 (40)
October 2026- **The terminal window that opened every hour on Windows is gone, this time for real.** 1.8.1 moved the hourly pass to the windowless interpreter, but the pass calls `claude`, `git` and `schtasks`, and all three are console programs. When a process without a console starts a console program, Windows opens a new window for it; the fix had taken the window away from the interpreter and handed it to the processes it started. The window's title read "claude", which gave it away. Every subprocess the engine starts now goes through one place and starts without a window on Windows, and a test fails if a direct call is added.
1.8.2 (39)
October 2026- **The search box now searches your history too.** Rules describe an identity, not facts: "Railway's environment variable format" never becomes a rule, yet it appears seventeen times in what you wrote. The window answered that question with an empty scene, and an empty scene reads as "you never talked about this". The search panel now has an "Earlier" section under the rules: up to three moments where the same words appear, with date, source and project. It opens even when no rule matches, which is the case it exists for. The text can be selected and copied, because what you are looking for here is usually a command or a format.
- **What search shows is masked by today's rules.** Events are masked when they are written, but the masking rules have grown since; on a real identity, 204 events would be masked differently today. The rules and the surface your assistants read were re-masked on the way out, search was not. Now it is, and the snippet is cut only after the whole text is masked: half a key left at the edge of a snippet would not match the pattern and would leak as it is.
- On macOS the list view kept showing an event you had hidden as evidence for a rule. Hiding means "keep it in the archive, but do not let it shape my identity", and the scene panel honoured that; the list used a different query. Both views now show the same evidence in the same order, corrections first.
- The two windows showed the same identity differently in a few places. Windows drew a rule that had faded below the floor and macOS did not; the macOS scene carried links to rules awaiting review, inflating the rule count in the topic panel; evidence and rules were ordered differently. An audit found all of them and each was checked against the code and fixed. The Windows list detail now has the "Topics" section macOS already had.
- The Windows window never waited to read the database while the engine was writing; macOS waits five seconds. A window opened in the middle of a distillation could fail with "database is locked" and show a full identity as empty. The watcher behind automatic refresh also fell silent for good after a single error, and the window stopped refreshing for the rest of the session; it now reconnects.
1.8.1 (38)
September 2026- **The read counter was counting its own reflection.** The health check really does exercise the MCP surface: it opens the server, calls a tool, and sees the answer come back. A correct check — but that call was being written to the counter too. Measured on a real machine: all one hundred records in the counter were the check itself. So the product was answering "is an assistant actually reading your identity" with its own reflection, when avoiding exactly that illusion is why the counter exists: the connection said "installed", and installed is not read. The real number on that machine, once filtered, was zero: seven clients connected, not one of them had read the identity over MCP even once. Records already in the log are skipped on read as well — stopping the writes alone would have left the counter lying for another week, and editing somebody's own log is not ours to do.
- **The window threshold was making new identities wait too.** It looked only at the window budget, which turned somebody who had just set up their identity into a product that updates once a day. Measured: on a ten-rule identity the repeated context is 704 tokens per window; on a 565-rule identity it is 36,248. Skipping a pass on the first saves seven hundred tokens — and what it costs is the product's own first-day promise, that everything after setup moves on its own, met with the least movement on the day people watch most. The rule now: waiting is right only when waiting saves as much as it costs. The threshold is capped by the context itself. Nothing changes for a mature identity; on a new one the threshold disappears by itself — except it does not disappear, its ceiling drops, so a pass carrying less than the context still waits.
- A distillation's rejection reason disappeared after the pass. The reason goes by once in the pass's output, and on a scheduled pass that output goes to a log; the next day somebody checks the status and sees "active rules: 0". The reason exists somewhere, just not where they are looking. Measured by running a from-scratch install: eight commits, one window, one rejection, zero rules — what somebody running the product for the first time sees is a product that did nothing. The reason is now stored with the pass, and said only when there are no rules at all: on a mature identity a pass with rejections is ordinary, and printing the reason every time would add a line nobody reads.
- The file holding the version-check answer was written world-readable. It contains nothing but a version number, but every file in the identity directory is written owner-only, and a rule with an exception eventually gets applied to the wrong file. The product's own health check caught it; what missed it was this: every writer had its own permission test, and nothing looked at the directory as a whole.
- A from-scratch install is now part of the suite. While two thousand tests passed, the product installed into a temporary home and actually run showed three of the faults above — the unit tests were checking the pieces correctly; what nobody was checking was the pieces combining in a user's order. Real commands run in their own processes, in their own temporary homes; the only fake thing is the model.
1.8.0 (37)
September 2026- The app can update itself. Until now the only way to learn about a new version was a banner, and everything after it was six steps: open the site, download, mount the image, drag, eject. Every step is somebody lost, and the product's fixes only reach people through a release. The button now finishes the job: the engine downloads the image, checks its signature, the app closes and the bundle is replaced. Sparkle — the standard answer on macOS — was not used. That framework goes inside the app bundle and it is the one that reaches the network; the site's claim that the window never opens a socket would have become a lawyer's sentence that day. The engine does the downloading: it is already on the network and already asks for the version once a day. The window only reads a file on disk. Verification is two commands and both were measured against real files: that the image passed Apple's notary, and that the app inside it was signed by us. Without the second, any notarised app would pass — Apple's own Calculator included, which is exactly what was tested.
- A script outside the app does the replacing, and the reason was measured: after the bundle moves, an absolute-path import from the engine raises `ModuleNotFoundError`. An engine replacing its own bundle loses itself halfway. The old bundle is not deleted but moved aside; it is removed only after the new version opens once, and if it does not open the old one comes back. The most expensive mistake an updater can make is leaving somebody without an app, and that is exactly what the test covers.
- Downloading and installing are off by default. Pulling seventeen megabytes without asking, and changing a program on your machine without telling you, are not things a product that says nothing happens behind your back gets to do. Both are switches in Settings, and installing depends on downloading.
- A "check now" button arrived. The switch turned the daily check on and off but there was no way to ask by hand: somebody who heard about a new version waited a day. The daily interval is skipped only for that one call — pressing a button must not turn every pass into a network call — and it answers even when the switch is off. Turning the switch off means not wanting the question asked every day, not never wanting to ask it.
- **The hourly pass stopped sending half-empty windows, and whether the paid plan can survive depended on it.** Every distillation window carries all of the rules; on a mature identity that is thirty-five thousand tokens, and the pass was paying it again every hour. Measured, with 558 active rules and 101 events a day: 26.3M tokens a month, almost all of it repeated context. The largest plan's allowance is 13M — gone in sixteen days without a single event distilled. And the person paying the most context is the one who has been here longest. The measure is the window, not the context, because what is wasted is a half-empty window: in a full one 55% of the spend is content, in a half-empty one 36%, in a pass carrying four events 7%. The pass now waits until a window fills or a day passes. The same events, 1.7M tokens a month — sixteen times less. Reading does not change: sources are still read every hour and no event is lost. Only distillation waits. A `distill` you run yourself does not wait either; somebody typing the command wants it now. And while it waits it says why — a silent wait cannot be told apart from a fault.
- Setup said "✓ Git repositories" and wrote `enabled = false` into the profile. A paragraph explaining this was already there, but somebody reading the list sees the tick before they read the paragraph, and a tick means yes however much text sits beside it. The mark is now different. For every other source, found and read are the same thing; git is the only place they part.
- The reading pass said "git reading… git: 0 events" for sources that were switched off. A collector returns nothing when it is off, and the pass did not tell that apart from a source that had nothing to give. People read it as "there was nothing in my repositories" when in fact nothing had been looked at — and switching the source on was theirs to do. For a developer, the source carrying the most data was dropping out in exactly this silence.
- Distillation now says why it rejected a rule. The reason was being collected and going nowhere: the screen showed "1 rejected" and people ran everything and came away with no rules. A rejection usually comes from something fixable — evidence outside the window, a layer name that is wrong — so what is lost by not saying it is the rule itself.
- The health check was naming a remedy without naming the problem. When the MCP server does not answer, the reason was taken from the last line of stderr, and that line is the remedy: "MCP server is not answering: to set it up, run coredence setup." The cause itself sat one line above and was thrown away.
- `review` and `interview` printed their usage text when typed bare. `topics` lists directly: what somebody typing a command's name wants is almost always to see what is there. The cost was measured — on a real identity eighteen open contradictions and eight questions were waiting, and the most natural way to look at them returned an error. `export --format markdown` is accepted now too.
- On Windows a terminal window opened and closed on the screen every hour. The pass was running, so nothing looked broken; what people saw was a window appearing by itself every hour — in a product that says it works in the background, something invisible reminding you it is there. The cause was the interpreter: `python.exe` is a console application, and Windows opens a console every time Task Scheduler calls it. The task now calls the windowless face sitting next to it. The log is unaffected; the pass already writes its output to its own file. Installed tasks count as stale too: fixing only new installs would have left the window in place for everybody who sees it today.
1.7.0 (36)
September 2026- Distillation on Windows had never worked, not once since it was written. The prompt was passed as a command-line argument and Windows caps `CreateProcess` at 32,767 characters — the rule list alone was 124,552, so every call died with `[WinError 206]` before it began. This was the one thing the product does on Windows. The prompt now goes over standard input, verified with a real 43,350-character call against a real identity.
- Turkish text was being corrupted silently on Windows. Subprocess output was decoded with the system's local code page, which in Turkey is cp1254; a sentence written as UTF-8 came back as different letters with no error anywhere. Once corrupted text enters an identity there is no way back to the source. Seven calls were fixed and a check was added: forgetting the encoding on a new subprocess call is no longer possible.
- One failing source took the whole round down with it. If a collector hit something unexpected while reading, the round ended there and nothing was read that hour — nine sources lost because of one. Each collector now fails on its own, the reason is recorded, and the round continues with the rest. A database error is the exception: stopping there is right, because continuing has no meaning when there is nowhere to write.
- The macOS permission dialog came back every hour. The hourly round kept touching a source that had been refused and the system kept asking; people saw the thing they had said no to twenty-four times a day. A refused source now backs off and is retried once a day — granted later, it is found on its own; never granted, nobody is disturbed.
- Nothing showed whether the identity was actually being read. The product's promise is that your identity reaches all of your tools, and `connect` only said a client was *installed*; installed is not read. It happened once: the connection was there, the server opened, no assistant ever asked. Reads are now counted and the screen says "reading · 14 reads · 3 min ago". The text of the question is not written down: recording what somebody asked is not something this product sells.
- Nothing showed that the identity was accumulating. The hourly round reads something every hour and rules harden, but the only place that said so was the monthly summary, and that is not written until the month ends. The top bar now carries a chip: new rules, reinforcements and contradictions over the last seven days. It stays hidden when there is nothing to say — writing "0 this week" in a place people look at daily would leave a sign that says nothing.
- The main screen did not answer "what does my identity say". The scene answers how large it is, and 538 rules sat there as dots; the question somebody asks on first opening it is a different one. There is now a list view: split by layer, strongest first, with each rule's rationale and evidence one click away. The same arithmetic in both windows, because computing one screen twice is how two windows drift apart in silence.
- The cost on screen was 23% higher than what the engine would actually spend. From the second window on, the engine reads the repeated context from cache, and the screen was showing the uncached figure: $24.98 on a seventy-three-window round where the engine would spend $18.97. This screen answers the product's entry barrier, and overstating it is worse than not answering. Both windows now show what the engine will really spend.
- Redaction moved to the point where text leaves the machine. Every step on the way to a rule was redacted, but the exits themselves had never been audited: exported evidence text, the raw answer going to an assistant over MCP, and the delivered identity document all skipped it. The exits were inventoried and all three were closed. The redactor itself got harder too — card numbers, PGP blocks, Firebase server keys and the token on an `Authorization: Bearer` line went unrecognised; they are recognised now.
- The redactor locked up on a single long word: measured at 217 seconds. A pasted base64 block or a long hash stopped the entire round. The pattern was fixed and the same input now finishes in milliseconds.
- Identity files were world-readable. Measured: seven files on this machine. The whole identity is in them and another account on the same machine could open it. Files are now written owner-only, and the health check repairs the old ones.
- Hitting a usage limit counted as "could not complete". When a Claude subscription's weekly limit ran out, the round treated it as a fault and retried five times an hour, hitting the same wall each time. It is recognised now: the work waits in the queue, resumes when the limit renews, and the screen says what it is waiting for.
- An answer starting with a dash vanished silently. The command line read text like `-nope` as a cluster of short options, saw `-h`, printed help and exited with code **zero** — so everything calling it saw success. An interview answer was reported as "answered" while nothing had been recorded. Commands that take free text now take the text as it is.
- The paid plan became something you can buy. Prices are settled across three plans and the capacities were measured from the engine's own cost model. The app now says where a licence comes from, tells a plan user how much of their allowance a round will take, and shows that running out leaves two paths besides waiting: bring your own key, or move up a plan.
- The interview — the part that closes the silent areas of an identity by asking — had never run since the day it was written. Neither the hourly turn nor either window called it: the taxonomy, the priority calculation, the question generator, the queue table and the inbox card were all in place, and no question ever reached the queue. The only way to find out was to type the command in a terminal yourself, and the product mentions it nowhere. Underneath sat a second cause: three pieces of evidence were enough for a cell to count as "strong", an absolute number, and a mature corpus clears it by itself. Measured — across 19,853 events all 35 cells were strong and there were no gaps, while in the same table humour sat at 5 pieces of evidence next to interface design at 1,425: a 285-fold difference, the same label. The threshold is now a quarter of the typical cell — the median, because the distribution is skewed and one swollen cell must not make half the grid look thin — and the turn asks: never while an unanswered question is in the queue, and never more than once a week about the same area.
- Once questions actually started arriving, a new lock appeared: a single question you cannot answer stops the whole queue, because the turn will not pile a new one on top of an open one. Skipping existed in the engine from the start but only by sending empty text — typing `interview answer 3 ""` in a shell — and both windows reject an empty answer themselves, so it could never be reached from there. Skipping is now its own command, and both windows have a "Skip" button on the question card. The label was a small trap of its own: the sentence I was about to use already meant something else in the phrase table, and an English reader would have seen "Switch" on the skip button.
- The question generator could not see what it was supposed to avoid repeating. The prompt's "already known" list takes sixty rules from the start of the identity; rules arrive ordered by layer then confidence and the layers are alphabetical, so all sixty come from a single layer. The questions, meanwhile, are asked about the gap cells, and none of those are in that layer. Measured: the gap cells held 13 rules and the list contained none of them — the model was about to ask "what is your sense of humour like" while two rules already describe it. The list now takes the gap cells' own rules first, then the strongest rules for the remaining room, and its limit is a measure rather than a count: sentence lengths vary threefold and what is being limited is the size of the prompt.
- The change screen was dead. The windows offer only the months the engine has written — deliberately, because somebody looking at a month the engine never wrote reads the blank screen as a fault — and the only thing that filled that table was typing the summary command in a terminal. So the change screen, the summary card in the inbox and the whole of "what did my identity learn this month" sat somewhere nobody could reach; the module's own opening sentence says "each month returns something concrete, which is also what makes a subscription worth renewing". The summary never calls a model — it is plain queries and a template — so the turn now writes every finished month once, and never the current one, which would be summarising half a month. The monthly reading of the decision axes had the same problem: a shift is the difference between two months' readings, and the reading was taken only by the summary command and by batch distillation, so anyone using neither had no readings at all and the axis section of the summary never appeared.
- The system prompt of the agent that works on your behalf wrote a balanced decision axis as a leaning anyway. A check existed for exactly this — for not claiming a direction when the measurement cannot be told apart from zero; one axis stood at +0.04 across 210 observations and the identity said "I delegate", where −0.01 would have said "I do it myself" — but the reading was written in two places and the check had been applied only to the identity document, not to the agent. The agent is the identity's most expensive reader: it spends your quota and does work in your name. It also never saw how many observations backed an axis, and +0.36 with four observations is a different thing. The reading now lives in one place, and the status screen prints all six axes with their values — "axes measured: 6" said nothing, and those six lines are the part of an identity that steers the assistant in a situation never discussed.
- The hourly turn is not run by the engine on your command line. On macOS the app's own job runs it, and that job calls the engine bundled inside the app: the copy frozen at whatever version the app was installed at. So a fix in a newer version only reaches the place that grows the identity when the app itself is updated — and nothing said so. The cost was not only confusion: the health check said "the skill file is over budget, the budget needs to be increased", while from the same data the newer engine produces a file that fits. The advice would have enlarged the very thing that needed shrinking. The check now reads the version of the engine that runs the turn from the app's own bundle and reports the difference, and the budget warning separates the two causes: when the versions differ it says update the app and leave the budget alone.
- The Full Disk Access warning read the program to grant access to only from its records: from programs able to say "I tried and was refused". But keeping that record is something only a newer engine knows how to do, and the turn that grows the identity is run by the engine bundled inside the app — a version that cannot record never says "I could not read" and never appears in the list. The result: a person grants access to the program named, believes it is settled, and the identity turn stays blind. Believing a silence has been explained while it continues is worse than the silence. The turn's program is now read from the scheduler's definition rather than from records, so it is known without a single attempt and always appears in the list.
- The engine tells people to run a command in twenty-two places, and the manual explained none of eight of them. Naming a command and writing nowhere what it does is worse than not offering it: the person has to run it and find out. The client list in the manual was stale too — it named five clients where the engine knows eight — and the same stale list sat in the English text of this site. Two checks were added: whether all sixty-five command lines the manual prints actually parse, and whether every command the engine suggests is explained in the manual. The same check already existed for the site and for the windows; it did not exist for the engine's own manual, which is the most read of the three.
- "Permanently delete" and "re-mask" said they had removed the text, but with another program holding the database open they had not. The chain has three links: overwriting the bytes of a deleted row, rebuilding the file, and truncating the write-ahead log. The first two were fixed earlier; the third was missing, and being last in the chain it made the other two ineffective. Measured — with a second connection open, re-masking reported "1 masked" while the key sat untouched in `<database>-wal`: the main file 4 KB, the log 573 KB. People run these commands because something private is in there, and the gap between what is said and what happens costs most in exactly this place. The log is now truncated; when it cannot be — SQLite refuses while the window is drawing its scene — the message says where the text remains and what to do, and the re-masking command exits with an error because a script calling it needs to know too.
- The product told people to type a command that would fail: contradiction alerts suggested `review answer <id> update`, while the command accepts only `keep`, `drop` and `revise`. The whole job of that sentence is to carry someone to the next step. Two guards written to catch exactly this missed it, both for the same reason: the suggestion is split across two adjacent string pieces in the source and the scan stopped at the first. It now joins them, and the alternatives inside angle brackets are checked against what the command actually accepts.
- The hourly-run status said "not installed" — while the identity kept growing. On macOS the app's own job runs the turn and the engine's is deliberately left out: installing both means two jobs writing to the same database at once. The health check already knew this and stayed quiet; the command did not, and two answers that disagree leave a person thinking their identity has stopped. Fixing the sentence alone was not enough: the window compared the answer's exact text, so adding an explanation to it would have shown the switch as off. Parsing a line written for a human is a mistake this product has made once, and it was about to make it a second time here; the status is now also available in machine-readable form, and the window reads that.
- The topic map distinguished nothing. A rule was linked to *every* topic its evidence events touched, with no threshold: a rule with a hundred and sixty-eight observations enters every place those events happened to go. Measured — 7.6 topics per rule, and the largest topic covered 61% of the identity. When an assistant asked "what areas does this person work in" the answer said nothing, and filtering by topic narrowed nothing. The weight was already recorded and unused: links covering a fifth of a rule's evidence are now marked (1.7 topics per rule, largest topic 23%), and the strongest link always survives, because a rule with no topic would drop off the map entirely. The split between display and hiding is deliberate: display looks only at telling links, hiding looks at all of them — over-hiding is safe, over-listing is useless. On the sharing side this also means sharing less, since with unthresholded links "give me my rules about X" could hand over half the identity.
- When the search widened it put the wrong answer first. When no rule carries all the words of a question the list widens to "any of them" — which is right, because an empty answer reads to an assistant not as "I didn't find it" but as "this person has no such preference". But that list was ordered by confidence: "code comment language" returned "uses casual address" at the top, "what hours do they work" returned store forms. A rule matching one word with high confidence beat one matching three — and the assistant knows the list was widened but not that the top entry is irrelevant. The order now uses three measures: how many words matched, how rare those words are (a word appearing in two hundred rules distinguishes nothing), then the rule's strength. Across five questions with a known answer, the expected rule reaching the top three went from 2/5 to 4/5.
- The windows drew the same links in their scene, which made a hairball — the file's own comment had noticed and accepted it. Four queries across the two windows now look only at telling links. The column is used only after asking whether it exists: a window can be newer than the engine, and a query against a missing column would leave the screen entirely blank — a missing distinction beats a broken screen. The probe uses `SELECT` rather than `PRAGMA`, because the macOS window opens the database read-only behind a deliberately narrow allowlist, and adding `PRAGMA` to it would open a writing path in order to read.
- The identity file an assistant loads every session carried none of the rules the person had written themselves. Measured: zero of sixteen hand-written rules made it in — "automated tests are standard on the backend" (confidence 0.97), "leave no TODOs", "no postamble", "write modular code". What the person had told the assistant was the one thing the assistant never read. The reason was already written in the engine's own comments: a declared rule cannot compete with a habit, because "never write a postamble" is never observed a second time — it is being followed, and the absence of repetition is compliance, not withdrawal. The confidence calculation gave declared rules their own floor, but a floor is not enough: beside a habit with a hundred and sixty-eight observations, a declared rule at 0.6 is never chosen. The budget now takes declared rules first, within a bounded share — if someone wrote a hundred of them the measured identity would fall out entirely, and measurement is what this product claims.
- In the same file five areas had no representation at all: stack, payments, revenue, analytics and humour. The budget balanced across layers — the reasoning is in the code, "rules about how the assistant should speak were falling below the list of preferences" — but within a layer it went purely by confidence, and since eighty of two hundred and fourteen preference rules were about interfaces, the small areas were eliminated wholesale. An assistant not knowing which stack you work in is the most expensive thing for a coding assistant not to know; "does not want jokes while working" changes behaviour directly, and that was missing too. The same reasoning was applied one level down: one representative per area — not a weak rule, but that area's strongest. The result is both broader and smaller: all thirty-five areas, 5,986 tokens instead of 7,144.
- The budget itself was a promise, and it was not being kept. When narrowing stopped changing the selection, the fitting loop returned a file that exceeded the budget and said nothing: a 6,000-token budget produced a 7,144-token file. The weakest rule is now dropped instead. If the header block alone is larger than the requested budget there is nothing to be done — there, giving more and saying so beats giving a truncated identity, and the health check says so.
- The identity database was world-readable. Measured: on my own machine the 136 MB file sat at `-rw-r--r--`. Until now only the *directory* was closed, and while the file stays there that is enough — but the moment it leaves, it carries its permissions with it: backups, sync, a Time Machine restore. The reason was written in the code itself: the function that closes the directory returns a value, and its comment said "the caller reads this and tells the user"; none of its four callers read it. The database and its side files (WAL, shm) are now closed on open — the WAL carries the same text, rows not yet written to the main file live there — and the health check measures the permissions on disk. There is no type filter: the first version looked only at files carrying a database header and missed the run's own log, which also carries sentences from the identity.
- `doctor --fix` now does the work instead of describing it, and looks at environment problems too. When the identity itself was consistent the command never reached the repair block: it printed the warnings and returned, so `--fix` did nothing in precisely the case where the only thing to repair was in the environment. Permissions are now closed rather than explained — "run this command" means waiting for the person to run it, and most people don't. What remains is measured again after the repair; showing the pre-repair list as "remaining" would mean showing what we just fixed as still broken. The exit code stays 0 deliberately: the hourly job is chained as `doctor --fix && run`, and returning anything else because of a warning that needs a human would mean never running the agent's turn at all.
- Every source now counts what it looked at. `Added: 0` told three different failures with the same line — the source could not be read, there was nothing there, the filter removed everything — and the count exists precisely to separate them, but only two collectors had it. Three new cases joined it: an unreadable git repository (one of twenty-four failing quietly shrank the harvest), a corrupt export file (an interrupted download opens but does not parse, and the person believes they handed over the file), and a database that opens but fails while reading. The last is the sneakiest: because the file opens, no "unreachable" warning fires either. Problems are now recorded and shown in the window; when they clear, the record is deleted, because a warning that never goes away is a warning nobody reads.
- The cost screen says when caching does not help. It listed three figures one under the other as though each were cheaper than the last; with a single window the opposite is true, because the prefix is written once, writing costs more than reading, and there is nothing to read back. The window count at which caching starts to pay is derived from the rates rather than written down — so the sentence changes by itself the day the provider changes its prices.
- The engine's warnings moved to the main screen. What the health check says — the hourly run is not installed, a source cannot be read, an unswept copy of the data sits on disk — lived only in Settings. Yet every one of them means the product is not keeping itself up to date, and in this product the hourly run failed silently on every run for months: the screen said "installed", the identity did not grow. Both windows now show the first warning and count the rest; writing all three on the main screen is the fastest way to have the notice ignored, and hiding the rest would be hiding something.
- The permission button now sits where the problem shows. "Open Full Disk Access settings" existed only on the setup screen: shown once, then gone. But permission can lapse later — when the app's identity changes macOS treats it as new and resets what was granted — and that is exactly when the button is nowhere to be found. It is now in the notice on the main screen, beside the source row, and in the warning list in Settings. The engine names what is needed and the window shows the button on seeing that name: reading the sentence to decide which button to show would be a link that breaks silently the day the sentence changes. Windows has no such permission, so it has no such button.
- The macOS window's source list described "no permission" and "missing" with the same line, and their fixes differ: one needs a file pointed at, the other needs Full Disk Access. The Windows window has drawn that distinction since 1.6.8. Both windows now also recognise a third state — "readable here but not by the hourly run" — because calling that "no permission" would be a lie.
- Half a screen staying in Turkish now fails a test. The macOS window had nothing checking that its translations were complete, and writing the test found a real gap: the explanation on the "What does it do?" screen — the place the product explains itself — appeared in Turkish to English readers. On the Windows side the corresponding guard did not prove its own claim: it says "a hand-edited table disappears at the next generation" while only counting keys. The table is now rebuilt from its sources and compared.
- The commands the windows send to the engine are now verified against the engine itself. A wrong flag compiles, the engine does not recognise it, the screen swallows the error and the button looks like it works — `updates --on` was written once where the engine expected `updates on`. The window tests pinned the spellings but were only true on the day they were written. The check sits in the release script right after the engine is bundled, so the engine that ships is the one doing the verifying. It does not run the commands, only parses them — testing with `source <name> --on` would change the setting while testing it.
- The place the health check sends you gave the same misleading answer. It says "look with: coredence source", and that listing printed "present" beside the source — because the listing also looks from the command's own context. When the hourly run could not read a source, the listing now says so. The place a person is sent to should be the place the real answer is.
- Every command took a write lock at startup. `CREATE TABLE IF NOT EXISTS` opens a write transaction in SQLite even when it does nothing, so read-only commands — the health check, status, rule search, the MCP server — queued behind any write in progress and failed on timeout. On my own machine the hourly job died with "database is locked" in the middle of a long maintenance operation and did nothing that turn. The schema is now stamped, and when the stamp matches nothing is written. The stamp is not a hand-maintained version number but a digest of the schema text itself: forgetting to raise a number would mean existing databases never receive a new column, with nothing to say so.
- Whether a source can be read depends on who is asking. On macOS, Full Disk Access is granted to the program, not the person: permission given to a terminal does not cover the hourly run's process. So the same file reads fine when asked by hand and comes back "permission denied" during the run — and the run is what grows the identity. This is the one place the health check can mislead itself, and it did on my own machine: the source's silence looked genuine when asked by hand, while the scheduled job's log recorded a permission denial, and the two answers never appeared side by side. Reachability is now stored with its context — what the hand-run command saw and what the scheduled run saw, neither overwriting the other — and when they disagree the check says so. It also names the program to grant access to: "add the program that runs the turn" leaves the person searching, and on macOS adding the wrong one does nothing and fails silently.
- One source had produced nothing for a hundred and eleven days, and nowhere said why. The collector's own comment confessed the reason: "if permission is missing the collector silently returns empty." The real trap is in `exists()`: with Full Disk Access denied, macOS refuses the `stat` and Python swallows that into "no such file" — so a permission denial looks like a file that was never there, and five collectors opened with exactly that line. The file is now actually opened, and if it will not open the reason is written down. A file that cannot be found inside a folder that cannot be listed counts as a permission problem, which is precisely what macOS does. It shows in three places: the run itself, the health check, and the source list. On my own identity the measured answer came back "readable — the silence is real": the source works and the quiet is genuine.
- A source that arrives incomplete says so too. Git repositories, note folders and WhatsApp exports read a list of paths rather than a single file, and when one path disappears — a repository moved, a drive not mounted — the source keeps working and nothing says a part is missing. The count drops with no reason attached. That is now its own state: the source still counts as readable, but the run names the path it could not read.
- The health check had a gap, and it fell on the worst case. The silent-source warning measures a source's own rhythm, which needs at least ten events — so a source believed to be set up but which never worked for a single day produced no warning at all. The new check asks about the file rather than the rhythm: for every enabled source, does it open.
- During setup a permission denial was reported as a malformed file. The collector returns empty on an unreadable source — deliberately, so one source cannot bring down the whole run — and the trial read interpreted that emptiness as "readable but no events came out; the file is not in the expected format." So at the moment permission was refused, the person was told the wrong thing, in the one place they could have fixed it. The trial now asks about the file first, and on macOS describes what to do.
- The hourly run went from forty-two seconds to six. Measured: the whole git history twenty seconds, three hundred and sixty session files sixteen seconds, the export file four and a half — once an hour, from scratch every time, for eighty new events. Collectors now know how far they read: git passes `--since` and does not look behind a thirty-day margin (the margin covers rebases and amends, where the commit date is old and the arrival new), and session files are not opened at all when their timestamp predates the mark. The mark is written only when a collector runs to the end — a run that dies partway leaves it alone and the next run re-reads everything, because an event silently skipped costs more than the seconds saved. A corrupt mark means reading a little too much, never reading nothing; and `ingest --full` ignores the mark entirely.
- The engine's warnings moved to the main screen. What the health check says — the hourly run is not installed, a source cannot be read, an unswept copy of the data is sitting on disk — lived only in Settings. Yet every one of them means the product is not keeping itself up to date, and in this product the hourly run failed on every single run for months: the screen said "installed", the identity did not grow, and nobody noticed. Both windows now show the first warning and count the rest; writing all three on the main screen is the fastest way to have the notice ignored, and hiding the rest would be hiding something.
- A password was sitting unmasked in the stored events. Redaction runs on everything before it is written, and it had been tested the way such things usually are — against examples written alongside the rules. This release tested it the other way: the real database, scanned with patterns written independently of the redactor, because searching with the redactor's own patterns misses exactly what the redactor misses. Out of 19,058 events came a plaintext password and a session token.
- The cause was one character. In JSON the key is written `"password"` and the colon comes *after* the closing quote, and the rule expected nothing between the name and the separator. `password = x` was caught, `PGPASSWORD=x` was caught, `{"password":"…"}` was not — and that is precisely the shape a password takes in a transcript of somebody testing an API. Those events go to the model during distillation, which in this product is the only path by which anything leaves the machine. Widening the rule must not cost the prose: "password management is hard" and "the PASSWORD_RESET_URL flow" still pass untouched, and there is a test saying so.
- Rules grow; the rows written under the old ones keep their exposure. `reredact` sweeps them and has since the beginning, but nobody remembers to run it, and the moment they would need to is the moment they do not know the rules changed. On the real identity, 487 rows still carried something today's rules would mask. Re-scanning every event takes thirty-seven seconds, so the check cannot be a health check — instead the fingerprint of the rule set is stored alongside the events, which answers the same question instantly. A database with no fingerprint counts as old: assuming clean when you don't know cancels the reason the check exists.
- The fingerprint alone is not enough either, because two engines can write to the same database — the one inside the app and the one installed on its own. The older one does not know about the note, so it leaves the newer engine's stamp in place and every row it adds looks clean. This is not hypothetical but measured: the installed app ran the previous release's engine and wrote 94 rows of unmasked password in the four hours after the fix, while the health check said the environment was clean. The note now also records how far the rules have been applied, and rows beyond that point are reported.
- The identity lives in more than one place, and cleaning one is not cleaning it. Two of them sit outside the engine's home: the skill file an assistant loads each session, and the portable document. Both are the identity in plain prose, and `uninstall --everything` deleted neither while printing "identity deleted" — a sentence read most often by the person uninstalling precisely so that the data is gone. The same command also said it whether or not the directory actually went away, because the removal ignored its own errors.
- The other copies are backups, and the health check now counts them. It separates the ones a sweep can reach from orphaned write-ahead logs, which it cannot: SQLite looks for `<database>-wal`, so a log whose name does not match belongs to no database and `reredact` can never open it. Measured on a real machine — sweeping the backup masked 531 rows and left every secret in its log untouched. For those, deletion is the only thing that clears the text, and the warning says so rather than describing a sweep that would do nothing.
- "Permanently delete" was not permanent. `forget --purge` says it deletes permanently and asks for confirmation because it cannot be undone. SQLite by default leaves the bytes of a deleted row where they were: the page is freed, but the text stays on disk until something overwrites it. Measured — the text of a purged event was still findable in the database file afterwards. The person running that command is usually running it because something private is in there. Deleted content is now overwritten as it is deleted, and the file is rebuilt afterwards so that pages freed before this release let go of what they were holding. On a real 111 MB identity the rebuild takes half a second.
- The tool an assistant is told to start with had no ceiling. `identity` returned every active rule in one call: on a real identity, 134,565 characters, about 45,000 tokens. The skill file was given a budget for exactly this reason and the same limit had never been applied here — one surface bounded and the other unbounded makes the bound meaningless. It is budgeted now, and measured against what is actually sent rather than against the skill file's line format, because a budget that says six thousand and delivers nine is not a number. What falls outside is not dropped silently: the count and the way to fetch the rest are in the answer.
- An unknown argument was ignored, and the answer was the opposite of the question. Calling the rule search with `query` instead of `search` filtered nothing and returned the whole identity — as a search result. The assistant receives not less than it asked for but more, with nothing to indicate the answer is wrong. Unknown arguments are now refused, with the accepted names in the error so the assistant can correct itself.
- A search for two words found nothing. It was one `LIKE`, so anything but an exact substring came back empty: "flutter riverpod" returned zero rules on an identity holding rules about both. An empty answer does not read as "I didn't find it" — it reads as "this person has no such preference", and that is false. Each word is now searched separately, in the rule's text, its domain and its name, case-insensitively in a way SQLite's `LIKE` is not for Turkish. If nothing carries every word, the search widens to any of them and says so in the result, because widening in silence tells the assistant its list is narrower than it is.
- Every question now opens onto its evidence. The queue asked "is this rule still true" and left the evidence as a bare number — `(evidence: [18879])`. The product's claim is that every rule opens onto what it came from, and answering that question depends on reading the moment itself. All three surfaces — the engine and both windows — now show the source, the project, the date and what was written. The same is true of a rule seen only once: it asks "is this you" about a sentence drawn from a single observation, and now shows it.
- Setup called a pass that never started a pass that ran. On a clean machine the screen printed "seen to run" while the log held one line: `ModuleNotFoundError: No module named 'coredence'`. The check looked for anything in the log and then for two Turkish words; Python's own failure trips neither, so the check passed the exact failure it was written for. It waits for the pass's own start marker now, defined in one place so that the writer and the reader cannot drift apart.
- The setup screen says which road it found and what that road costs. There are three ways to distil and they are not alike: a `claude` command spends a subscription's quota, an API key spends money directly, a local model spends neither. All three showed the same word, "ready". Cost is this product's barrier to entry, so the road that will spend has to name itself first.
- `compare` writes what it found. The command collides what you have written about yourself with what you actually do, and reported only counts — "conflicts: 3" — leaving another command to answer which three. What it finds is the whole point of running it.
- A budget now delivers the number it states. Six thousand tokens of skill file produced a file of seven thousand eight hundred and fifty: the budget measures the length of the rule lines, and the file also holds frontmatter, headings, the axis section and the closing notice. Thirty per cent over, on a file that loads into every session. Both surfaces now measure what is actually sent, and narrow by the measured ratio rather than by a fixed step — a fixed step was leaving an eighth of the budget unused, which is forty rules that would have fitted.
- The skill file's first line contradicted its last: the header said "109 active rules in total" while the footer of the same file said "378 more exist". A document that disagrees with itself leaves the reader to choose which sentence to believe, and here the reader is an assistant.
- Two windows, and only one of them was being told things. The health check went into the Windows viewer in 1.6.8, for the stated reason that most people live in the window — and it went into only one window. Everything the engine has learned to notice since was therefore invisible on macOS: a source that has gone quiet, redaction rules that have moved on, a database copy nothing sweeps, a client that is installed but not connected, a broken scheduled task, an MCP server nothing can reach. On a real machine there were two warnings and the window showed neither. The same was true of the notice that says an identity is still a draft. Fixing that turned up a fault in both windows: the number of draft rules was read from the filtered list, so hiding draft rules made the notice disappear while the identity was still a draft. Both now ask the database directly.
- A rule you write by hand was not being masked. Events have been masked since the beginning; rule statements were treated as "text the model wrote from already-masked events" and left out — but a sentence the owner types with their own hands does not come by that road. Measured: a key written through `review answer --statement` went into the identity exactly as typed. A rule statement is more exposed than an event: an event only goes to the model during distillation, while a rule is loaded into every assistant session from the skill file, sits in the portable document, and is served over MCP. Statements written by hand, by revision, and by the distiller all pass through masking now. The same was true of a rule's reasoning, which `export --format json` writes into a file you hand to somebody, and of a topic name, which you can type yourself and which reaches an assistant through the `topics` tool. Four separate fields, and each time the thinking had been "this one is text the model wrote, so it is clean". Checking them one at a time would miss the fifth, so there is now a test that checks the exit instead: a secret is written into a field, all four tools an assistant can call are opened, and their answers are searched for it. The test also checks that it is not blind, because a leak test that catches nothing is worse than no test at all: it looks green.
- A hidden topic could leave in an exported slice without a word. Export deliberately does not apply the sharing policy, because the same command is both "give somebody a slice" and "take your identity and go", and in the second case removing a hidden topic would be taking away your own data. The code said as much: you should know, before handing somebody a file, that rules from a topic you believe is hidden are in it. That warning existed only in the `--dry-run` output, which nobody runs — people type `export --out` and see only "written". Measured: the hidden topic's rule went into the file and nothing was said. The warning now appears on the path that matters, and on the macOS window too, which was the one surface of three that never showed it. The decision is still not made for you: the rule stays in the file, and the way to narrow it is printed.
- The terminal can now open a rule onto its evidence. The product's claim is that every rule opens onto what it came from, and until now that was true only for assistants: the MCP server had the tools and the window had the cards, but the person whose identity it is had no way to read a sentence in the skill file and ask where it came from. `coredence rule <words>` searches and `coredence rule <name>` shows one rule with its numbers and the real moments behind it. The sharing policy is deliberately not applied here — it bounds what goes to an assistant, not what the owner may see of their own identity.
- The cost screen rounded its own answer away. A single pending window showed "0.0M tokens" and "~$0". This is the screen that answers what the product will cost, so a number that cannot be read is the same as no answer. It now says "31K tokens" and "$0.10" — twenty cents is not the same as free.
1.6.9 (34)
September 2026- On Windows the hourly pass never ran on battery. 1.6.8 fixed the task's quoting and that was right; underneath it was a second, quieter fault. `schtasks /Create` creates a task with its own defaults, and those defaults are "do not start on battery" and "stop if the machine goes onto battery". On a laptop — which is most machines — the hourly pass skipped every hour that was not plugged in, with nothing to say so. `/TR` has no switch for that setting; giving the whole definition is the only way.
- The task is now registered from a full definition rather than a command line. A side effect is that the entire class of quoting bugs disappears: the command and its arguments are separate elements, so there is nothing left to quote wrongly. The definition also runs a pass that was missed while the machine slept — what launchd does on macOS by itself — and stops a pass that hangs, since otherwise none of the following hours can start. Tasks already installed with either fault are rebuilt on upgrade.
- That bug lived for months because no test ever created a task. They all checked the *text* of the command, and the text matched its own expectation while being wrong. Windows CI now installs a real scheduled task, reads back what Task Scheduler actually registered, runs it, and waits for the pass's log to appear. An exit code proves nothing here — the broken task returned zero too.
- Setup was counting a pass that never started as a pass that ran. A full install on a clean machine printed "seen to run"; the log held one line: `ModuleNotFoundError: No module named 'coredence'`. The check looked at two things — did anything reach the log, and does what reached it contain the word for "error" in Turkish. Python's own failure trips neither: it is in English, and because none of our code ran there is no Turkish line at all. So the check passed the exact failure it was written for. What it looks for now is the pass's own start marker, defined in one place — the day the writer and the reader drift apart, the check would tell every broken install that it works.
- The setup screen says which road it found, and what that road costs. There are three ways to distil and they are not alike: a `claude` command spends your subscription's quota, an API key spends your money directly, a local model spends neither. All three showed the same single word, "ready". Cost is this product's barrier to entry, so the road that will spend has to name itself before it spends.
- No client reading the identity is a failure too, and it is now reported. There are two ways the identity reaches an assistant: the skill file loaded each session, and MCP. The second is written into each installed client's settings, and if it was never written the identity goes nowhere — with nothing missing from the screen to show it. It is reported only when *no* installed client is connected: choosing not to connect some of them is your decision, and turning that into a warning is the fastest way to make warnings ignored.
- The assistant's door is now checked by opening it. The health check asked the MCP server to introduce itself, which it does happily with an unreadable profile and no database at all — `initialize` touches neither. It now calls a tool and asks for the identity, which is the only thing that proves an assistant would get an answer. Tested against a deliberately broken profile: the old check passed it, the new one does not.
- `coredence mcp` ignored the `--profile` and `--db` flags. Two identities on one machine is a supported thing, and the command that serves them was the one command that did not honour the flags saying which.
1.6.8 (33)
September 2026- 1.6.7 fixed half of this, and the other half was just as quiet. That release taught the scheduled job where to find the model command; it did not tell the job who is running it. launchd hands a scheduled agent no `USER`, `LOGNAME` or `HOME` — on a real machine its whole environment is a path and two Python variables — and Claude Code cannot find its credentials without them. Measured: in that environment `claude -p` answers "Not logged in · Please run /login", zero tokens, zero milliseconds, no call to the model at all; add `USER` and `LOGNAME` and the same call succeeds. So after 1.6.7 the pass found its command and then did nothing, which is the same silence one line further down. The job now carries the identity of the person it runs as.
- Worth saying how this was found: the check added in the same release — does the last round say it failed? — went red within minutes of being written. It was not written with this bug in mind; this was simply the first thing it caught.
- On Windows the hourly pass had never run at all. It was found the way these things are found: a dialog appearing on someone's desktop every hour, asking which application should open a file, with no indication of which file or why, starting the day Coredence was installed. The task's own XML gave the reason in one line — the executable and its arguments were together inside a single pair of quotes, with no arguments element at all. Task Scheduler splits that value in two, the quoted part being the program and the rest its arguments, so quoting the whole line tells Windows to open a file by that name. No such file exists, and Windows asks which application should open it.
- The task reported success throughout: `Last Result: 0`, because showing the dialog is something it manages to do. So the pass never ran once, and its only visible trace was a window appearing on the hour. The quoting is around the executable alone now, and the existing broken task is treated as out of date so that an upgrade replaces it rather than carrying it forever.
- The window says when the pass is broken. `doctor` had learned to notice a failing round and a doubly-installed job, but only in the terminal, and most people live in the window. The engine settings page now reads the engine's own check and shows what it found: a round that failed, two passes installed at once, a batch waiting to be collected, a crash log, an inconsistency inside the identity. The sentences come from the engine rather than being written again here — a sentence written in two places is how two places come to say different things — and if the check cannot be read, nothing is shown at all, because assuming "healthy" would display a guarantee that does not exist.
- A stale identity file is now noticed. Distillation can succeed while the file an assistant loads stays where it was: deleted, moved, or written by an older install to somewhere else. Nothing looks wrong — the round succeeds, the rule count climbs — except that the product's actual work is not being done, because the assistant is reading yesterday's identity. The check is the obvious one and it had never been made: was the file written after the last round?
- A draft identity now says it is a draft. The first pass became a draft in 1.6.6, which is right: a full distillation on a real archive is 66 windows, hours, and more than twenty dollars on your own key, all before seeing anything. But the window presented the result as the whole identity. The `provisional` flag existed and was used only for filtering — drafts could be hidden, never announced — so that change left a screen handing you half an identity as if it were all of it. The scene now says how many rules came from the sample and offers to run the full pass. The notice clears itself: the engine drops the flag only when a complete pass finishes from the beginning, so "are there draft rules" is exactly "has the full pass not finished", with no second piece of state to fall out of date.
1.6.7 (32)
September 2026- The hourly pass could not find the model command, and nothing said so. This was caught live while installing 1.6.6 on a real machine: every round had been ending in "`claude` could not be run: No such file or directory", the identity had stopped growing months ago, and `doctor` reported a clean environment throughout. The cause is that launchd hands a scheduled job `/usr/bin:/bin:/usr/sbin:/sbin`, while Claude Code installs itself into `~/.local/bin` — so the command a person runs without trouble in their terminal did not exist as far as the pass was concerned. Anyone distilling with the Claude CLI on macOS had this, which is the zero-configuration path and so most people.
- The engine now looks in the usual install directories when a command is not on PATH, and the app writes a PATH into the job it schedules; either one is enough, and the second also repairs installs still carrying an older engine. When a command really is missing the engine returns its bare name rather than inventing a path, so the failure still reads "not found" instead of something misleading.
- `doctor` checked that the pass was installed, never that it worked. It says two new things now. If the last round failed it quotes the reason and points at the log — being installed is not the same as working, and a check that conflates them goes quiet exactly when it is needed. And if two passes are installed at once it says so: `schedule.py` already knew that was harmful ("two jobs writing the same database at the same time") but the check only ever looked for both being absent. Both were true on the machine where this was found.
- Windows found two more of these before anyone shipped them. A command there is not `claude` but `claude.cmd`, so looking without an extension never matches; `PATHEXT` is consulted now, split on the semicolon it is defined with rather than the platform separator, which merely happened to coincide. And `os.access(..., X_OK)` returns true for any file that exists on Windows, because executability there is decided by the extension rather than a permission bit — asking the same question on both platforms meant mistaking an unexecutable file for a command. Windows behaviour is now exercised in the ordinary test run too, because a platform rule only CI knows is a rule written on the wall rather than in the code.
- What an assistant is told it can ask for, it can now actually get. The skill file ends by pointing at the MCP server for the rules it does not carry, and that promise only holds if the server returns them. It did not: the rule search stopped at sixty and said nothing about it, so a query for the preference layer returned 60 of 185 with no sign the other 125 existed. The result now carries the total, marks itself truncated, and takes an offset to continue — advertised in the tool's own schema, because an argument an assistant cannot see is an argument it cannot use. The total counts only what your sharing policy allows: a raw number would leak how many rules a hidden subject holds.
- The price is calibrated by this machine rather than by a constant. The engine counts a token as 3.5 characters, and in Turkish it measures closer to 2.7: a prompt estimated at 18,052 tokens was read as 23,284. So windows run about a third larger than intended and the quote comes out about a third low — the wrong direction for a number that is the barrier to entry. Replacing the constant with a figure measured against one tokeniser would have been no better, because the ratio depends on the language, the size of the identity and the model doing the reading. Each round now records the length of the prompt it sent, and after three of them the price comes from this machine's own rounds and the screen says where the number came from. Windows are still built by the configured rule, because that is what distillation does and a price should describe the run it quotes for.
1.6.6 (31)
September 2026- Distillation can now run on a model on your own machine. Sending text to a model is the one place data leaves the computer; if the model is local, that place is gone and "your data stays on your machine" becomes true without an asterisk. No key, no bill. `coredence model ollama` is a first-class option now, and the reason it is a separate path rather than a URL you type is three traps found by measuring: Ollama's OpenAI-compatible endpoint ignores the context setting and silently cuts the prompt to 4,096 tokens; without an explicit output budget a reply can stop in the middle of a window, and the error then reads "could not parse JSON", which sends you looking at the model's formatting when the cause is length; and a small model can lose the thread around two hundred tokens, ending a string mid-word and closing the object. Constraining generation to JSON fixes the last one — same prompt, same model, same window: malformed without it, valid with it.
- What this costs is speed and depth, and the measurements are worth stating carefully. On an M4 Pro a window takes about two minutes against seconds for a hosted model. On extraction, compared like for like — an identity still small, nothing yet to match against — Claude averaged 12.9 new rules per window on its first ten rounds where the 8B model found one. And as an identity matures the work changes shape: Claude's last ten rounds average 3.1 new rules and 43.1 reinforcements, because most of the job becomes recognising what is already known. That is the half a local model cannot do at all, since recognising it means holding the whole rule list in the prompt. So it is a real option for a new identity and a thin one for a mature identity — and the setup step now says so instead of leaving "find an API key" as the only road.
- The window is sized to the model that will read it. The fixed part of a distillation prompt is the identity itself, and it grows: at 457 rules it is 26,949 tokens, which leaves no room at all beside a 40k context. Past that point the server quietly truncates and the model returns a perfectly formed, completely empty answer — the round "succeeds", the events are marked read, and they are never looked at again. Measured, the boundary sits between 190 and 250 rules. The engine knows the size of that prefix, so it now does the arithmetic itself, and when nothing fits it refuses with the numbers rather than returning an empty round. A prompt cut short is now caught on every path, hosted ones included.
- The identity your assistant loads every session had no ceiling. It was 457 rules and about 26,000 tokens, reloaded at the start of every Claude Code session, growing every hour with nothing ever taking anything out. Three separate costs: tokens you pay for each session, an assistant asked to weigh 457 rules equally, and no bound on either. It is a budget now rather than a threshold — a threshold grows with the identity, a budget does not — and the allowance is split across layers, because ranking by confidence alone let 185 preference rules bury the 40 about how you actually want to be spoken to. On the real identity: 26,200 tokens down to 6,100, 463 rules down to 118, layers back in proportion. Nothing is lost. The portable document stays whole, and the file ends by saying how many rules are not in it and which MCP tools return them.
- What an assistant is told it can ask for, it can now actually get. The skill file ends by pointing at the MCP server for the rules it does not carry, and that promise only holds if the server returns them. It did not: the rule search stopped at sixty and said nothing about it, so a query for the preference layer returned 60 of 185 with no sign the other 125 existed. That is the same silent cut fixed twice elsewhere in this release, and this time the budget above is what made it load-bearing. The result now carries the total, marks itself truncated, and takes an offset to continue — advertised in the tool's own schema, because an argument an assistant cannot see is an argument it cannot use. The total counts only what your sharing policy allows: a raw number would leak how many rules a hidden subject holds.
- The first run is a draft. Setup ran a full distillation, which on a real archive is 66 windows, hours, and around $22 on your own key — all before seeing anything at all. The draft path already existed, down to the notice at the top of the document explaining it; it simply was not used where it mattered most. The first round now takes minutes, and the hourly pass carries on from there.
- The price was the price of work already done. `cost` counted the whole archive while `distill` resumed from the last completed round. On this machine the screen said 66 windows and about $22 when the pending work was four windows and about $1. The same mistake sat in the line printed just before a distillation, where it was worse: it quoted $22 for a round that would cost $1 and then recommended the cheap path.
- The price is now calibrated by this machine rather than by a constant. The engine counts a token as 3.5 characters, and in Turkish it measures closer to 2.7: a prompt estimated at 18,052 tokens was read as 23,284. So windows run about a third larger than intended and `cost` quotes about a third low — the wrong direction for a number that is the barrier to entry. Replacing the constant with a figure measured against one tokeniser would have been no better, because the ratio depends on the language, the size of the identity and the model doing the reading. Each round now records the length of the prompt it sent, and after three of them the price comes from this machine's own rounds and the screen says where the number came from. Windows are still built by the configured rule, because that is what distillation does and a price should describe the run it is quoting for.
- A rule that faded could never come back. State rules are retired by decay, which is right — "currently working on X" actively misleads six months on — but retirement was one-way, and a retired rule was never scored again. Someone returning to a project after two months had the rule reinforced every round, its support climbing and its last-seen moving to today, while the document stayed silent about it forever. Noticing that you changed is the fifth thing this product does; not noticing the change back loses half of that.
- Your own word was the weakest evidence the engine held. A rule you confirmed in review entered at full confidence and the first rescoring dropped it to 0.33, under the render threshold, because the flag marking it as declared was never set. In the state layer it was worse: three answers given today were retired within hours and the next comparison asked the same questions again.
- The hourly pass could be taken over without a word. `launchctl` is keyed to the user, not the home directory, so a second installation loading the same label displaces the first. The file on disk still looked right, the status still read "installed", and the pass was writing somewhere else entirely. It is checked against what is actually loaded now.
1.6.5 (30)
September 2026- A rule you know is wrong can now be corrected. Distillation opens questions and the comparison opens questions, but the person reading the identity document opens none — so a sentence you knew was wrong had no way in. The only remaining path was waiting for the rule to fade, which takes months and loses the correction along the way. `coredence review revise <slug> "<sentence>"` is that path. The correction is not silent: it is recorded in the same queue every other decision lives in, and the new sentence is tied to an evidence event, so "no rule without evidence" still holds for a sentence you wrote yourself.
- The redaction list was tested against the shapes real keys have today, and seven of them went straight through. Distillation sends text to a model. In this product that is the only path out, so a secret redaction misses is a secret that leaves the machine. All seven belong to services this stack actually uses: GitHub's current `github_pat_` format, which the older `ghp_` rule does not recognise; AWS access key ids; Slack; Stripe's live and restricted keys; npm; Google OAuth client secrets; Telegram bot tokens. A JWT rule was added too — session and service keys travel in that shape, and a `service_role` token alone grants full access. Over-redaction was treated as a defect and tested separately: a variable named `npm_modules` is not a secret and must survive untouched.
- Every path that writes an event goes through the mask. The collectors all pass through one throat, but three other files write events and none of them did. Auditing them turned up one claim of mine that was wrong — the interview answer was already masked, one line above — so that change was reverted rather than left in place looking like a fix. The remaining two are masked now, and a source scan keeps a future event writer from forgetting. The scan's reach is deliberately narrow: it sees that a file calls the mask, not that it applied it to the right text.
1.6.4 (29)
September 2026- A subject you hid was reaching assistants anyway. Hiding a subject is meant to take its rules with it — hiding the heading and leaving the rules would hide nothing. Two of the four tools an assistant can call never applied that: `identity`, the one whose own description tells an assistant to start there, returned the hidden subject's rules on the first query, and `evidence` returned the messages behind them when asked for a rule by name, ignoring the confidence floor and the layers you had switched off as well. The three questions — is this layer on, does it clear the floor, is its subject hidden — now live in one place, because written separately two of them were never asked. A rule you cannot see reads as "not found": saying "that one is hidden" would confirm that the thing you hid exists.
- The same rules were also written into the skill file your own agent loads every session, which the sharing setting never covered. It does now. The portable identity document is deliberately left whole — that one is your copy, not something an assistant reads — and so is the database.
- Exporting still writes what you ask it to, hidden subjects included, because that path is also how you take your identity somewhere else and quietly dropping part of it would be the wrong kind of help. The preview now names the hidden subjects about to go into the file, so the decision is yours and visible.
- The identity document no longer takes a side it cannot defend. One decision axis sat at +0.04 across 210 observations — a balance — and the document announced it as a definite stance, because the code only asked whether the number was above or below zero. A value that close to zero is not a leaning, and now it says so. The threshold is not invented: an axis is the mean of ±1 votes, so anything inside the standard error of that mean cannot be told apart from balance, and the band narrows as observations pile up.
- The monthly summary had the opposite problem, and a worse one. Its threshold for "this weight moved" was a fixed number that ignored how much had been measured, and the weights are cumulative — so the larger an identity grew, the less a genuine change of mind could move the average. On a thousand observations, thirty new ones pulling entirely the other way still move it by 0.03, and the old threshold never saw it. Noticing that you changed is the fifth thing this product does, and it was going blind precisely as an identity matured. That threshold now comes from the measurement too.
- The comparison was reading a file nobody had touched since May. It checks the hand-written identity against the measured one, and its default pointed at an abandoned skill file that still said the opposite of what `CLAUDE.md` says today. The questions it raised were mostly about rules no longer defended by anyone. It reads `CLAUDE.md` now, says which file it read, and each run replaces the previous run's unanswered questions rather than piling onto them — answered ones stay, because those are decisions.
- The window cannot open a socket, and the release now refuses to ship a build where that stopped being true. It is the strongest claim on the site and the privacy page invites you to check it yourself; a single future addition made in good faith would have quietly turned it into a lie. On macOS the build is checked for linking any networking framework at all — stronger evidence than watching it run, because it shows the capability is absent rather than unused.
1.6.3 (28)
September 2026- On macOS, grant Full Disk Access again after updating. The bundle identifier moved from `com.akayalabs.coredence` to `com.coredence.app` — the product has its own name and now has its own identity. macOS ties permissions to that identifier, so it treats this build as a new app and the access you granted is gone. Until you grant it again in System Settings → Privacy & Security → Full Disk Access, Apple Notes and Messages are not read. Nothing else changes: the same file in the same place, and your window settings are carried over from the old identifier on first launch.
- The window now says when a source is blocked rather than missing. Notes and Messages live in files macOS protects, and without permission the file is still there — it just cannot be opened. The engine asked "does this exist?", which answers no either way, so the screen said the source was not there and sent people looking for a file that was never lost. It now tries to open it and says "no permission — Full Disk Access is needed" when that is what happened. Checking existence was not enough, and neither was `stat`: the system allows the metadata and refuses the contents.
- The scene has a button to update the identity. Starting a distillation from the constellation view was possible only with a keyboard shortcut, which on Windows means only if you already knew. While the pass runs its output is on screen and the button waits: a round that turns silently cannot be told apart from one that never started.
- A source that takes a path opens in Downloads. It opened in Documents, which is not where a ChatGPT or Claude export lands.
- The Turkish reads like Turkish now. Both windows and the whole site were gone through sentence by sentence — they were Turkish words on English scaffolding. About a hundred and thirty were rewritten. Reading them also turned up four claims the site had outgrown, including one that said a feature shipped in 1.4.0 did not exist.
- Windows gets the real application icon; the installer had been shipping Flutter's default.
1.6.2 (27)
September 2026- On Windows, pointing a source at a path corrupted the profile. The path was written without escaping its backslashes, and TOML reads `\U` as the start of a unicode escape — the file could no longer be parsed, and a profile that cannot be parsed stops every command the engine has. Writing it now escapes correctly, and a profile already broken this way is repaired on the next run: an error saying "fix line six yourself" needs a working engine to be seen, and there was none.
- The batch queue was not actually cheaper. Three places charged the same events twice: the hourly pass came around an hour later and distilled the queued events one at a time; collecting wrote nothing to the distillation log, so even after the result was in the identity the events still looked unread; and collecting did not recompute confidence, coverage or topics, so the same events produced a different identity depending on which path they took.
- The hourly pass now collects a finished batch itself. Leaving the second half of a 24-hour round trip to a button broke the promise that this keeps going without you, for anyone who closed the window.
- The cost figure is measured now, not estimated. How long the output runs is only known once the model has run, so the engine multiplied by a ratio taken from three measured windows; a finished batch reports what every request actually spent, those numbers are kept, and after three runs the estimate is replaced by this machine's own ratio. The screen says which one you are looking at.
- Settings say more of the truth: the assistants list showed only what is installed and now names all eight; where the engine lives is on screen, which is the first thing to look at when a setting fails silently on Windows; a source that takes a path has a button to point at one; and the scene can be told to stop refreshing under you while a long distillation runs.
1.6.1 (26)
September 2026not released- "What this does" now says a fourth thing: who can read it. The names of the connected assistants and the sharing policy in one line — how evidence goes out, the confidence floor, how many subjects are hidden. It is the question that follows "what did it read, what did it produce", and the answer was on a different screen.
- The explanation is in the list view too. The button was only in the scene view, so somebody looking at the list had nowhere the product explained itself.
1.6.0 (25)
September 2026- The app explains itself. Opening the window showed you a scene full of coloured dots, and what the product reads and produces was written only on the website. Now the "?" in the top bar — and, on a first launch, the explanation itself — says three things from real data: which sources are on and what is behind them, how many rules and subjects came out of how many events, and the rule in your identity with the most sightings behind it. No invented example: if the identity is empty, there is no example.
- Four colours: Charcoal, Night, Forest, Damson, in both windows under the same names. The ground and the accent change; the ink does not, because a screen that cannot be read in one theme is a fault rather than a theme, and the node colours in the scene do not, because those describe the data.
- The Mac window has "what changed" too. The reader had been there all along with no screen to show it: on Windows a link beside the monthly summary opened what the identity gained and what faded that month, and on the Mac that link did not exist.
- The same token count means three different things, and the screen now knows which. Someone distilling on an installed Claude subscription was shown a dollar figure; they are not paying per token, it comes out of that subscription. Now a figure is shown to whoever pays per token, and "how much will be read" to a subscription or a plan. The batch buttons appear only where they work: the queue is Anthropic’s batch API, and you get in with your own key.
1.5.4 (24)
September 2026- A failed distillation was taking the thing that would have retried it. The installer returned at that point, never reaching the assistant connections or the hourly pass — and the hourly pass is exactly what tries the distillation again. For someone whose model had hit its limit, the identity was installed and then never grew. A failed distillation no longer stops the install.
- A switch in settings no longer fails silently. When "Update hourly" failed, the switch went back to where it was and said nothing: the only way to notice your identity was not refreshing was to notice it was not growing. What the engine says now stays on screen — success and failure both. The same goes for connecting an assistant.
1.5.3 (23)
September 2026- One amount in settings printed the code that was meant to produce it. Dart's escaping rule had turned the value into plain text; neither the compiler nor the analyser says anything, and no test read that row's value. A test that reads the source now forbids the spelling.
- Every row in settings carries its own description. The paragraph under a section heading does not explain what a single row is: a number with nothing beside it saying what it is, is a riddle rather than information.
- The sections are grouped: Data, Appearance, System. A flat list of seven reads fine, but it gave "What it may see" and "New version" the same weight.
1.5.2 (22)
September 2026- On Windows the list of sources in settings was empty and gave no reason. The engine writes its output in the system code page (cp1254 in Turkey) while the window expected UTF-8: decoding broke on the first Turkish letter and the section looked as if it did not exist. The engine now forces UTF-8, and the window decodes without falling over a bad byte — showing none of the output when all but one byte is readable is the wrong trade.
- Settings is now seven sections: Sources, Assistants, What it may see, Opening, Identity, Engine, New version. All of it was one long scroll, and finding a setting had become a search. The list of settings should be visible before the settings themselves.
- The red "ERROR" line in the installer is gone. On a first install there is no scheduled job yet, and the command that stops it printed an error; having nothing to stop is the normal case.
1.5.1 (21)
September 2026- The Windows installer opens the product when it finishes. The checkbox on the final screen opened the identity document instead, and the document opens in whatever handles .md on that machine — a text editor, usually. For someone finishing the install, the first thing they saw was a text file, which is the same as not seeing the product at all. The shortcuts had been pointed at the window a release earlier; this checkbox was missed.
- The installer's closing text was stale too: it said "there is no window on Windows yet", and the window has been there for two releases.
- What the colours mean is now written in every mode. The legend in the bottom left appeared only in subject mode; in layer, confidence, reach and freshness the screen was left with coloured dots and nothing to read them by. Layer mode names each layer and counts it; the sequential modes show both ends of the ramp and what it measures. The white ring on rules that reach twelve or more subjects has its own line too — a mark people ask about should have its answer on screen.
- The top bar was reworked. The way into settings was a faint icon sitting next to the view toggle, and on Windows there is no menu bar, so that button is the only way in. The buttons are now a proper size and readable, and the settings one is filled. The "monthly summary" pill was not centred inside its own box either.
1.5.0 (20)
September 2026- What distilling costs is now measured. `coredence cost` splits the waiting events into windows, builds the prompts it would send, and counts the tokens — without making a single call. Settings → Waiting to be distilled shows the same numbers in the window. This product does not set prices by guessing, and it does not report its own cost by guessing either.
- The measurement found something surprising: the cost is driven by the size of your identity, not by how much it reads. Every distillation prompt carries the list of existing rules, the subjects and the taxonomy again; on an identity of 457 rules that was 63% of the prompt. So distilling gets more expensive as the identity grows, even when the number of events stays the same.
- That repeated context is now cached. From the second window on it is read at a tenth of the price — measured, that is $0.105 per window instead of $0.178. It applies whether you use your own key or the plan: the proxy marks the same prefix on its side.
- The batch queue. `coredence distill --batch` sends every window together: noticeably cheaper for work that is not urgent, and in return the result can take up to 24 hours. When it arrives `coredence collect` writes it into your identity; a window that came back with no answer never enters the identity, and the count is said out loud.
- When the allowance runs out there is now a door. The window used to say "it resumes when the month renews" and stop there — but the plan is a convenience, not the only way: with your own key there is no ceiling and you use it at cost. Making the wall look bigger than it is would be misinformation, not salesmanship.
- If the window crashes it now leaves a trace: what happened is written to `~/.coredence/crash.log` and shown to you the next time it opens. Sending it is your decision — no crash reporter is wired in, because a window that opens no sockets is worth more to you than a crash report is to us.
- The hourly pass on Windows has a voice now. The Task Scheduler command does not go through a shell, so when the pass crashed neither its output nor its stack trace went anywhere; launchd was doing this on the Mac, so the fault was Windows-only. Jobs installed with the old definition are refreshed on update.
1.4.0 (19)
September 2026- Sharing a slice of your identity. Until now export was all or nothing: showing a friend what you think about code meant sending every rule about your personal life along with it. Now you cut a slice by subject, by layer, or by confidence. The file says at the top how many rules were deliberately left out — so that a part of your identity is never read as the whole of it.
- A typo no longer sends everything. Name a subject that does not exist and the filter does not quietly fall away and hand over the lot; nothing is written, and you are told what could not be found. The alternative was a silent disaster.
- You see what is going out, first. Before anything is shared, the number of rules and the sentence that will head the file are on screen; where to save it is asked afterwards. Sharing on purpose depends on seeing what is shared.
- What an assistant may see. You choose which layers of your identity it can read, which subjects stay hidden entirely, and whether evidence text goes with them. The line is drawn in the engine rather than in the client: whatever the client asks for, a hidden subject does not travel.
- When your identity changed. Rules that arrived, strengthened, weakened and retired, in one place. An identity is not static, and until now nothing on screen showed it moving.
- The Coredence plan. For people who would rather not enter their own key, an option that runs distillation through our proxy — offered during setup, beside the others. What is left of your allowance is shown in the window. The proxy stores neither rules nor text; the only thing it keeps is tokens spent per licence, and a test holds that line.
- If the window crashes it now leaves a trace. What happened is written to `~/.coredence/crash.log` and shown to you the next time it opens; sending it is your decision. No crash reporter is wired in, because a window that opens no sockets is worth more to you than a crash report is to us.
- The hourly pass on Windows has a voice now. The Task Scheduler command does not go through a shell, so when the pass crashed neither its output nor its stack trace went anywhere — launchd was doing this on the Mac, so the fault was Windows-only. Jobs installed with the old definition are refreshed on update.
- The Windows window in this build has not been run by a human either. It compiles on a Windows machine and passes 265 tests; that is not the same as somebody opening it.
1.3.0 (18)
September 2026- The Windows window is the Mac window now. 1.2.0 put *a* window on Windows: two panes, a list of rules and the evidence under them. The Mac has had something else — the identity as a graph you can walk around in — and every release since has widened that gap. This one closes it. The two windows are now the same product, and the sameness is held in place by tests rather than by resemblance: shared JSON fixtures, and tests on each side that name the other. Change a number on one side and the other side fails.
- The scene. Subjects are landmarks, rules are the points around them, the measured links between them are lines. Distance carries meaning: a rule sits beside the subject it leans on hardest, and connected subjects sit near each other. Four arrangements, five colour modes, search that marks what it finds, hover that lights a neighbourhood and dims everything else, zoom that opens the picture as you come closer, and nodes you can drag and leave where you put them.
- The detail panel. Click a rule and it opens into the sentence, its subjects, and the events it came from — the actual things you wrote. This is where the product's claim gets checked, and until now you could not check it on Windows.
- Waiting. Everything the engine wants to tell you, in one place: contradictions against a rule it is sure of, questions about gaps it found, rules it has seen only once, and the monthly write-up. Each one waits for your verdict, because deciding what someone is belongs to them.
- The identity filter. The engine keeps everything it has measured, including rules it is barely sure of and rules about a mood that lasted a fortnight. Whether those belong in the picture is not a question the app can answer, so it is a setting — with the number of hidden rules said out loud, because a scene that quietly shows two thirds of an identity lies about how much was measured.
- English. The window speaks Turkish and English, using the same translations the Mac app uses. The interface language is separate from the identity's own language, which stays with the engine.
- The window refreshes itself when the engine writes. The hourly pass grows the identity; before this, nothing on screen said so. Your selection and your pinned nodes survive the refresh.
- Keyboard commands. Search, zoom, reset, release pins, re-lay-out, update now. The Mac has these in its menu bar; Windows has no menu bar, but the commands had to exist.
- A bug on both platforms: the monthly summary was written but unreachable whenever the queue was empty — the only way in was a badge that appeared only when something was waiting. There is a way in now.
- Another one: the constellation arrangement's description promised that "nineteen landmarks never overlap". Nineteen was the author's own subject count. It no longer names a number.
- The Windows window in this build has not yet been run by a human. It compiles on a Windows machine and passes 214 tests, and it was checked by eye on macOS against a real identity of 457 rules. That is not the same as somebody opening it.
1.2.1 (17)
September 2026- Setup happens in the window now, not in the installer. An installer is not the place to decide what a program may read — least of all for a product whose argument is that it reads only what you allow. Obsidian gets this right: the installer is dumb, the application asks for what it needs when it first opens, and every answer stays changeable afterwards. So the installer asks nothing at all any more. The window asks two things — what to call you, and what to think with — and does the rest.
- Settings shows every source, with a switch. What is read, where it looks, and whether anything is actually behind it: "216 files", "found", or a highlighted "none" for a source that is switched on with nothing behind it, which is more misleading than one that is off. Assistant connections and the hourly refresh have switches there too. The claim on the site is that Coredence reads only what you allow; that sentence is only true if you can see what is allowed, and until now on Windows you could not.
- An upgrade no longer fails on a file it is using. Installing over a running copy stopped on …\python\python.exe — the MCP server stays alive while an assistant has it open, and the hourly job may be mid-round. The installer now ends the scheduled task and stops the interpreter in its own directory. Only that one: killing every python.exe would kill whatever you were running.
- The engine prints its source list for machines as well as people. The Mac window used to parse the human-readable table, so adding a column to it quietly turned a label into "Claude Code oturumları 216 dosya". It did not break; it degraded, and nobody noticed. Both windows now read source --json.
- An empty answer from the engine is no longer treated as an answer. An older engine does not know the --json flag and prints usage instead; showing that as "no sources" was a lie.
1.2.0 (16)
September 2026- Windows has a window. Until tonight the product on Windows was an engine and no application: it built the identity, it handed it to the assistants on the machine, and there was nothing to open. Every stand-in for the missing window failed the same way — a console that flashed, then a shortcut to a text file that opened in whatever editor happened to be registered. A shortcut to a .md is not an application, and calling it one does not make it one.
- The installer now carries the window. Two panes: your rules on the left, grouped by layer and ordered by confidence, with a search box; the evidence for whichever one you select on the right. The identity opens from the desktop and from the Start menu, and the shortcut points at the application rather than at a file whose name changes when you rename yourself.
- It is written in Flutter, which is why it exists at all: one codebase for Windows, macOS and Linux. The window reads ~/.coredence/coredence.db and never writes to it — changing the identity is the engine's job, and two writers would mean two versions of the truth. There is no network code in it. Every action it offers runs the engine's own command and shows you the output as it arrives.
- The window has not yet been run on Windows by a person. It compiles and its tests pass on a Windows runner, and it was checked by eye on macOS against a real identity of 457 rules. That is not the same as somebody opening it. If it fails to start, that is worth knowing quickly, and the engine, the installer and everything else in this release are unaffected by it.
- ChatGPT and Codex can read your identity. They share one MCP configuration (~/.codex/config.toml), so one connection covers both. It is the first client whose configuration is TOML rather than JSON, and the file holds your own settings — model, project trust levels, comments. Parsing and rewriting it would flatten all of that, so only our own block is touched. Rehearsed against a copy of a real configuration: the block goes in, the file still parses, and after disconnecting the file is byte for byte what it was.
1.1.9 (15)
September 2026- Claude Code never saw the server, and said nothing about it. coredence connect reported it as connected. The entry was in ~/.claude.json, in the right file under the right key. Claude Code ignored it, and the only way to find out was to ask an assistant a question only the server could answer and watch it fail. Comparing our entry against one that worked showed the whole difference: "type": "stdio". Claude Code drops an entry that does not declare its transport, silently. The field already existed in the client table; this one client was marked wrong.
- Setup no longer asks questions where nothing can answer. The installer runs the engine in a process with no console: input() raises there, the installer swallows it, and the install reports success having produced nothing — not even a profile. When a name cannot be asked for, the account name is used and said out loud. Crashing was the worst of the three options.
- An empty corpus no longer stops the rest of the setup. The previous release taught the engine to stop when it read nothing, which was right, but it stopped in the wrong place: before connecting assistants and before installing the hourly job. Somebody with nothing to read ended up with a finished-looking install and five unconnected clients. An empty corpus blocks distillation, nothing else — the identity can arrive from another machine later, and the connections need to be waiting when it does.
- If you already have Coredence connected to Claude Code, reconnect it once so the entry is rewritten: coredence connect claude_code
1.1.8 (14)
September 2026- Four sources were reading nothing, and nobody could tell. chatgpt, claude_code, claude_export and claude_memory took the path from your profile and used it without expanding the tilde. The profile writes those paths with one — ~/.coredence/data/chatgpt-conversations.json is the default setup produces — so the flow the documentation describes, download your export and put it here, silently read nothing at all. On both platforms, since the first release. There is now a test for each of the four that puts a file behind a tilde path and insists it is read.
- That bug was found while chasing a different one, and the detour is the theme of this release: the engine reported what it stored, never what it looked at. "Eklenen: 0 Tekrar: 0 Atlanan: 0" was the same sentence for three different faults — the folder was not found, the files could not be read, or every record was filtered out. Ingest now says how many records each collector examined, so the three come apart. A collector that keeps no count is left out of that line rather than reported as zero: saying "looked at 0" when we never looked is the same lie in a new place.
- An install that read nothing says so. Setup used to run to the end, announce that the identity had been distilled, and hand over an empty document. It now stops, names every source it looked at and where it looked, and offers the three ways forward — the most useful being that an identity already distilled on another machine is one file, and copying it here is the whole migration.
- coredence source shows what is actually behind each source: whether the path exists, how many transcripts are in it. The tick meant "enabled", and everyone including its author read it as "found".
1.1.7 (13)
September 2026- The Windows install no longer opens a terminal. Until now the installer finished by opening a black console window that asked you questions — a reasonable thing to show a developer and the wrong thing to show anybody else. On the Mac nobody sees a terminal, and there was no reason for Windows to be different. Setup now runs inside the installer's own progress pane, and asks one question — your name — because that is the only thing it cannot work out for itself: the language comes from the installer, the model is found on the machine, and every assistant it finds gets connected.
- And when it is done, something is there. A shortcut on the desktop and in the Start menu opens your identity — the document itself, the thing the product actually produces on Windows. An install that changes nothing you can see feels exactly like an install that did not happen.
- The finish page reads the engine's exit code rather than assuming success. If no model could be found, it says the identity was not distilled and what to do about it, instead of congratulating you on an empty file.
- An hourly job left behind by another install is moved to this one. If you unzipped the package first and ran the installer afterwards, the scheduled task still pointed at the folder you unzipped; status said "installed", the installer believed it, and the day you deleted that folder the hourly refresh died without a word. A job we cannot read counts as correct — when in doubt, do not break a working install.
- coredence where tells you which file is where: the identity, the document your assistant reads, the database, the profile, the log. The installer uses it to find the identity for that shortcut, since the file is named after the profile. It answers a question people were being sent to the documentation for.
1.1.6 (12)
September 2026- Windows gets an installer. Double-click it and it is done: it installs into your own user directory, so Windows never asks for administrator rights and no UAC prompt appears; it adds itself to your PATH, so coredence works in any terminal; and when it finishes it opens the identity setup itself. The zip is still published for anyone who would rather not install anything.
- There is a second reason it exists. Somebody asked whether we should buy a code signing certificate, and the honest answer was that there was nothing to sign: Authenticode signs PE files, and neither a .bat nor a .zip can carry a signature. Making something signable is the precondition for signing it. The installer is still unsigned — Windows will say the publisher is unknown — and its SHA-256 is in the release notes, next to the file.
- coredence uninstall, on both platforms. Setup leaves two things behind that deleting files cannot reach: the hourly scheduled job, and the MCP server entry in each connected assistant's configuration. Left in place, the second makes your client try to start a server that is no longer there on every launch. The command removes both. It does not remove your identity — that is your own data, and a program that takes it away on the way out has no business calling it yours. --everything deletes it, and says what it is about to do first.
- The installer does not touch your PATH; the engine does. NSIS strings are 1024 characters in the standard build, and a development machine's PATH is comfortably longer: read it in and it is silently truncated, write it back and half of somebody's PATH is gone. The install looks successful while everything else on the machine breaks. The engine reads and writes the registry value with no such limit, and preserves its type, so the %USERPROFILE%-style variables inside it keep expanding.
1.1.5 (11)
September 2026- The engine runs on Windows. There is no window there yet, and that is an order rather than an omission: what the product promises is that your assistant knows who you are, and that needs the engine and the MCP server. The package carries its own Python — unzip it, double-click coredence.bat, and setup walks itself from the profile through the hourly refresh, connecting whichever assistants are on the machine. Running it again is harmless; it repeats no step it has already done. The identity lives in %USERPROFILE%\.coredence, the same single directory the Mac uses, in the same format.
- The hourly refresh writes a log. launchd was given no output path, so when a round failed nothing was written anywhere and there was no way to see why an identity had stopped growing. Both the app's job and the engine's now write to ~/.coredence/refresh.log. An update does not touch a job that is already installed, so the app repairs its own on the next launch.
- Every hint that names a command names the command that exists on that machine. Seventeen lines said "coredence …"; on Windows the executable is coredence.bat, and somebody typing what they were told got an error and reasonably assumed it was their fault. Two of the seventeen were inside the identity document the assistant reads.
- A fresh profile is private from its first write. It was made owner-only when an API key was added to it, which left a window in which a person's name, language and source paths were readable by anyone else on the machine.
1.1.4 (10)
September 2026- The connection tab now finds JetBrains IDEs and the Gemini CLI as well. The JetBrains entry is a single row because the file is a single file: every JetBrains IDE reads the same AI Assistant configuration, so connecting once covers IntelliJ, WebStorm, PyCharm, Rider, GoLand and Android Studio together. The Gemini CLI keeps other settings in the same file, and connecting leaves them exactly as they were.
- The icon reads at small sizes. Downscaling a line drawing averages thin strokes into the background: measured, the contrast fell from 9.3:1 at 512 pixels to 2.7:1 at 32 — below the 3:1 floor for an interface element, which is the arithmetic behind "it looks like a grey square in the Dock." The strokes are now thickened in proportion to the reduction and, at 128 pixels and below, drawn toward white. The 512 and 256 pixel files are byte for byte what they were, so the artwork itself is untouched. The one orange node keeps its colour: the brightening is masked by saturation, so grey lines take the full lift and the accent takes none.
1.1.3 (9)
September 2026- It tells you when there is a new version. The app cannot update itself, and until now the only way to learn that a release existed was to come back to the site. The check lives in the engine rather than in the window, because the engine already reaches the network while it distils and the window still opens no socket at all — the claim on the privacy page holds exactly as written. Once a day the engine asks github.com which release is the latest; the request carries nothing that identifies you, and the answer is a small file on disk that the window reads.
- Settings → Engine shows it, and turns it off. From a terminal that is coredence updates off.
- The documentation used to say the engine "calls the model you chose while it is distilling, and nothing else." That stopped being true the moment this feature existed, so it now names both things it does and how to stop the second one. The value of a claim on that page is that you can check it; one sentence left standing wrong would cost the others.
1.1.2 (8)
September 2026- The engine dropped its old code name. Before it was called anything, the engine was brain, and the name had stayed in the places nobody looks: the Python package, the database file at ~/.coredence/brain.db, the Xcode project. None of it was visible in the app, and all of it was wrong.
- The rename is the easy half. The hard half is that a copy of 1.1.1 already running on somebody's machine calls the old name by hand — its scheduled job runs "-m brain.cli", and a connected client's config names "-m brain.mcp". Those files were written once and do not change on their own. So the old name stays as a shim that forwards to the new one, nothing breaks on update, and the hourly pass quietly rewrites those two files to the current name as it goes. Nothing to do; the identity carries across on its own, database and all.
- The window finds the database under either name. It opens the file directly rather than through the engine, so a person who updates and opens the app before the first scheduled pass would otherwise have met an empty identity while their history sat on disk under the previous filename.
1.1.1 (7)
September 2026- Turning the hourly update on signed you out of macOS. The switch in Settings → Engine and the last step of the setup screen both install the scheduled job by tearing down the old one first, and the teardown named the login session instead of the job inside it. launchd did exactly what it was asked and took the whole session down: the screen went black and the login window came back. Nothing was lost, but from the outside it looked like the machine had restarted itself, and anyone who finished the setup screen on 1.1.0 met it on their first run.
- Apple Notes was reading nothing at all. The collector looked for the note text in the wrong place inside Apple's format, found nothing, and said nothing, so the source appeared to be on while producing not a single note. It reads them now: 115 notes here, every one of them decoded.
- Notes that hold secrets stay out of the identity. Reading Notes for the first time turned up wallet recovery phrases and live API keys sitting in ordinary notes, and that text would have been distilled and written into the rendered profile. A note that names a secret, or that carries something shaped like a key, is not collected at all.
- Masking learned Turkish. The rules recognised only English names — API_KEY=, PASSWORD: — so a secret written the way people actually write it went through untouched, and "API Key: …" with a space instead of an underscore escaped as well.
1.1.0 (6)
September 2026- The identity keeps itself up to date. Reading your sources and distilling them only ever happened on the first-run screen, so an identity stayed at the day it was set up. There is now an hourly pass, ⇧⌘R to run one when you want it, and a switch in Settings → Engine if you would rather it held still.
- The connection tab lists every client it finds on the machine — Claude, Claude Code, Cursor, Windsurf, VS Code — and connects any of them with one button, leaving the servers you already had alone. From a terminal the same thing is coredence connect.
- When the model cannot be reached, the app says why. A spent usage window, a Claude Code that was never logged in and a dropped connection all looked identical and were all reported as a usage limit, which sent people off to wait for something that was never going to change.
- A pass that cannot reach the model says so at once instead of retrying for ten minutes, and never rewrites the identity files from a distillation that failed.
- Two labels in the scene stayed Turkish in the English app.
1.0.1 (5)
September 2026- The app speaks English. It was Turkish everywhere while this site was not, so anyone who downloaded it could read the page and then not the product. It follows the system language, and Settings → Scene has a picker if you would rather choose.
- Scrolling the settings window no longer zooms the scene behind it. The scene watched the scroll wheel across every window of the app, so a scroll meant for settings never arrived there.
- The first-run screen says that macOS may ask for permission to read a folder, and what declining costs — the scan used to go quiet with no explanation.
1.0 (4)
September 2026- The engine ships inside the app. No Python to install, no repository to clone, no terminal — one download, and the first screen sets the identity up rather than telling you which commands to run.
- An MCP server, so the assistants you already use can read the identity instead of being handed a file: what you think about a subject, and what any single rule was drawn from. It runs on your machine over stdio, and it is read-only.
- A connection tab that adds Coredence to Claude with one button, and a bundle for clients that install extensions themselves.
- Distillation can run on your own API key — Anthropic, OpenAI, or any OpenAI-compatible server including a model running on your own machine. Claude Code is still used when it is installed.
- Everything the engine keeps now lives in ~/.coredence. An existing install moves itself there on first run.
- Apple silicon only for this build. The app was compiled for Intel as well, but the engine inside it was not, which would have meant a window that opens and an identity that never appears.
1.0 (3)
September 2026not released- Settings window rebuilt: the layout and colour choices say what they change, and three thresholds that decide which rules are drawn at all are reachable for the first time.
- A confidence floor, and switches for the current-state layer and for draft rules. Hidden rules leave the scene entirely — colour ranges, clustering and node sizes are recomputed from what survives, and the count that is hidden shows in the top bar.
- Menu bar and keyboard shortcuts for search, zoom, pinning and relayout.
- A first-run screen that tells you which of the three things is missing and gives you the command for it, instead of an unreadable-database error.
- The window is dark whatever the system is set to. The scene's palette was built against a dark ground; the welcome screen used to draw black text on it for anyone running a light Mac.
1.0 (1)
September 2026not released- The identity is one scene filling the window, replacing the three-pane split that turned the picture into a table of contents.
- Four arrangements — free, constellation, grid and ring — and four ways to colour: by subject, by layer, by confidence, by reach.
- Rules sized in three steps by how many subjects they turn up in; the ones that cut across everything wear a ring.
- Search that marks matches in place, drag to pin a node, click empty space to dismiss.
- Signed with a Developer ID, hardened runtime, notarised by Apple.
The engine
The engine has its own history, and it is longer than this one — it has been reading and distilling for months. Its commits are in the repository, where the reasoning for each change is in the message rather than summarised here.