Repository navigation
Releases
Releases · jbgh/lossless
lossless v0.1.47
0.1.47 — 2026-11-02
- Remembered decisions keep their place in the context again. 0.1.46 let the step that makes room for a standing rule push out any record that does not warn, and decisions stopped warning in that release. On a replay of real asks that changed about a third of the answers, usually swapping a decision recorded about the exact task for a looser rule. Decisions are protected again: on the same asks the context now matches 0.1.45 exactly, with the smaller set of warnings from 0.1.46 (about 1.7 per ask instead of 2.75).
- Fewer real failures mistaken for tests that fail on purpose. "The checkout test failed first with a timeout" and "red on CI and green locally" are failures, not test-first steps; wording like that now counts as a test-first report only beside a new test or a pass after it.
- Docs no longer describe a decision warning.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.46
0.1.46 — 2026-11-02
- Claude Code's copies of each request are no longer read as turns. Recent Claude Code versions write every message they send to the model a second time, in an
api-request-blobline. Every turn in it is also on its own line, so lossless was reading each one twice. The copy carries harness text in the user's slot, so compact resume instructions and pieces of skill files were stored as the user's rules, and harness lines such as "Permission granted for: …" were stored as the user's own words. Every claim in a copy was also written a second time, a couple of seconds later. Those lines are now skipped. Records they already produced stay in a store until they are retired by hand withlossless supersede. - A message queued while the agent works is read as its session's. Claude Code writes a message you type mid-turn on a line with no note of how the session was started, so in a session a program started, a queued prompt was kept as something a person typed. It now takes the session's from the lines around it.
- A test that fails on purpose is not stored as a failure. Test-first reports ("every new test failed first and then passed", "RED: 12 failed against the old code") were stored as failed attempts and came back as "do not repeat" warnings on unrelated work. They are now dropped when a turn is read, and
lossless inspect --pruneretires stored ones. A report that also gives a cause ("failed first because …", "failed before the fix: the cache ignored the tenant") is kept, and records an agent wrote withrememberare never retired. - Fewer warnings, and the ones left say something the context does not. "Existing implementation may already cover part of this goal" came back on nearly every ask and only restated a decision already in the context, so decisions no longer warn; they still come back first in the context. A failed attempt warns only when an agent recorded it with
rememberor it shares a file or a code identifier with the ask (or matches it closely by meaning when an embedder is configured); one picked up from a conversation that only shares words with the goal still comes back in the context, without a warning. Standing rules warn as before.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.45
0.1.45 — 2026-10-24
- Warnings of the same kind come back as one line. An ask often carried five or six warnings that were the same sentence with a different record id, and agents rarely opened any of them. Now each kind is one line that lists every id:
Prior attempts at this goal failed (see A, B). Do not repeat them without new evidence.No warning and no id is dropped; a kind with a single record keeps its old sentence. On a replay of real asks this cut the lines per ask by about a third, with the same records packed. - A recurring-failure warning now says what the rule is. It used to name a record id and ask the agent to open it; agents mostly did not, and then broke the rule the record described. When an agent wrote that rule with
rememberand it has no markup, the warning quotes its sentence, with its id and date. A rule picked up from a conversation, or one with markup in it, is still cited by id only: this warning fires on every ask and is treated as blocking, so it never carries text nobody chose to record. It still fires whatever the ask is about, so a trap is flagged even when the goal shares no words with it. askandrememberwith only a session id book to the right place. A call that carried just the harness's session id now takes the project and the workspace from the session lossless already indexed, so it no longer fails for a missing project and the workspace-dependent steps ([verify]marks) still run. A project or workspace the caller sent always wins, the two are never mixed from different repositories, and a session id indexed under more than one project fills nothing rather than guessing.remembernow ignores placeholder session ids such asdefault, the wayaskalready did.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.44
0.1.44 — 2026-10-23
- An idle watcher tick costs about an eighth of what it did. 0.1.43 stopped re-reading transcripts every tick, but a tick still statted every known transcript, lstatted every harness directory, read the whole session table and opened the Codex state database, about 30 ms of CPU every 2 s on a store with a few thousand sessions. Now a file or directory unchanged for 10 minutes is looked at about every 30 s (15 ticks at the default interval, fewer with a longer
--watch-interval) on a slot spread by its path, the session list is kept between ticks (re-read when any process adds, changes or removes a session, which a trigger-kept version number on the session table shows, or on the 5-minute full pass), the Codex state database is re-read only when it or its WAL changes, and the tick's working buffers are reused. The same tick now costs about 4 ms. Hooks still report each turn as it happens; the watcher, which catches what a hook missed, picks up a turn in a session idle for 10 minutes or more within about 30 s instead of 2 s. - Catch-ups redact about ten times faster. Every new transcript line runs through the secret patterns before it reaches the tape, and that was most of a catch-up's CPU. Each pattern now first checks for a literal it cannot match without (
AKIA,ghp_, a database URL scheme, apassword=-style key), so most lines skip most regexes. What gets redacted is unchanged: a differential test and a fuzz test compare every line against the regex-only path. - Asks and hook catch-ups stop running git on every call. Resolving a workspace to its project ran
gitonce or twice per ask and per hook catch-up. The answer is now kept per workspace: anowner/repokey for 10 minutes, a key for a workspace with no remote yet for 30 seconds, so records move toowner/reposoon after you add one. - Session lookups use an index. Looking a session up by id (every remember, every ask that carries one) and listing a project's sessions (an ask without one) read the whole session table; both now go through an index created on startup.
- A catch-up that changes nothing writes nothing. Re-recording an unchanged session row was a database write on every hook catch-up.
- A slow ask leaves a line in serve.log. An ask over a second logs where the time went: the ask-time catch-up and how many sessions it copied from, the project lookup, the rest, and the daemon's CPU over the same window. The line names no goal, path, project or session.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.43
0.1.43 — 2026-10-22
- The watcher no longer costs half a core while nothing happens. Every 1 s tick walked every harness root and opened and parsed the head of every transcript to find its cwd — 2,400 opens and JSON parses a second on a machine with 9.8 GB of Claude projects — then ran a cursor query and the idle-seal stats for every one of 5,700 targets.
serve --watchhad used about 104 CPU-hours in 8 days. The watch loop now keeps what it learned between ticks: a transcript's cwd is peeked once (an empty one again when the file changes or on the 5-minute full pass), a directory is re-read only when its mtime moves, the OpenCode session list is re-read only whenopencode.dbor its WAL changes, and a target found caught up and seal-checked is skipped while its file's size and mtime (or its harness update time) hold. An idle tick on that machine went from about 720 ms of CPU to about 30 ms. Anything modified within the last 2 s is not trusted to the cache, and every 5 minutes a tick runs everything in full, so an idle seal comes at most 5 minutes past its threshold. - A catch-up that fails is not retried every tick. A Pi subagent transcript (
subagent-artifacts/*_transcript.jsonl) has no cwd, so its catch-up fails, and 80 of them were retried every second. A failed file is tried again when it changes or on the 5-minute full pass. - An OpenCode session is listed once per key. Once ingested it is listed both under its virtual spool path and from
opencode.db; the two listings used to overwrite each other's state, so every one of 2,290 sessions was checked on every tick. - The watcher polls every 2 s, and the interval is a flag.
lossless serve --watch-interval 5s,lossless watch --interval 5s.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.42
0.1.42 — 2026-10-12
- A store that is not there is no longer backed up as an empty one. A run that found nothing while the bucket held files used to publish an empty generation as the newest one, so the next restore had nothing to restore — an unmounted volume or a home that moved looked exactly like a store whose files were all deleted. A root the backup reads (
raw/,export/,index/) that is gone while the bucket still holds files from under it now fails the run, and the previous generation stays the newest;lossless backup --allow-missingpublishes what is left on purpose. A root that is merely empty is a real change and still publishes. - A store root that is a symlink is backed up, and a root that cannot be read fails the run.
raw/(orexport/,index/) moved to another volume and left as a symlink was silently skipped — the walk never followed the root itself — so the next generation dropped those files while the run reported success. The walk follows a symlinked root now, and a root that is there but unreadable fails the run instead of being quietly left out. restorerefuses only the daemon holding the home it is restoring into. The check used to block on any lossless daemon on the configured sidecar URL, so the restore drill into a scratch home failed while the real daemon was up./healthnow names the home it serves to a caller on the same machine, by a tag (a hash of the path, not the path; symlinks are resolved first, so two spellings of one home agree), and a daemon for another home no longer blocks the restore. A daemon too old to send the tag is still taken to hold the home.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.41
0.1.41 — 2026-10-12
- omp (oh-my-pi) is a supported harness.
lossless setupnow writes omp's pieces too:~/.omp/agent/extensions/lossless.ts(catch-up onturn_end,session_before_compact,session_compact,session_shutdown), MCP in omp's native~/.omp/agent/mcp.json, the skill in~/.omp/agent/skills/lossless/SKILL.md, and the always-on rule in~/.omp/agent/RULES.md.RULES.mdis omp's always-apply rule file; itsAGENTS.mdis deliberately left alone because that is the single user context file omp keeps, so a lossless block there would shadow the user's other global instructions (~/.claude/CLAUDE.mdincluded).lossless doctorchecks all four, and~/.omprelocations are honored (OMP_HOME,PI_CONFIG_DIR,PI_CODING_AGENT_DIR). Newlossless hook-omp. - omp sessions read like Pi's tape, with omp's own shapes. The file is
~/.omp/agent/sessions/<bucket>/<timestamp>_<uuid>.jsonl; the bucket encodes the canonicalized cwd (-<home-relative>under home,-tmp-<temp-relative>under the temp root, else--<absolute>--) and is not reversible, so a session id handed over alone is looked for under every bucket. Written files open with a fixed-width 256-bytetype:"title"slot before thesessionheader, which is where the cwd peek reads. Subagent transcripts (<ts>_<id>/<AgentName>.jsonl, beside the tape) are skipped, like Claude'sagent-*.jsonldumps. - omp's bookkeeping lines are not memory, and neither is an inlined
@filemention. The new entry types (title,title_change,model_usage,service_tier_change,reset_boundary,ttsr_injection,credential_pin,session_init,mode_change) are skipped andcompactionstill marks a compact.bashExecutionandpythonExecutioncount as tool output, and afileMention— the inlined contents of an@filemention, which used to be read as something the user typed — is dropped; that role exists in Pi's tape too, so Pi sessions get the same fix. - omp has no session-id environment variable, so the extension stamps the id. omp mounts MCP servers as
xd://device paths, soask/remember/get_recordarrive as awritetoxd://mcp__lossless_askwith a JSONcontentstring; the extension rewrites that JSON with the harness's own session id (the id fromctx.sessionManager.getSessionId()wins over anything the model sent), and a directmcp__lossless_*tool name is stamped as well. Thesession_iddescription on all three tools and the installed skill now name omp. - A
rememberfrom any harness kept its session id again.lossless mcpreaches the daemon over HTTP, and the remember request droppedsession_id(andharness) on the way, so every remember that a harness had stamped was booked to the session "manual" instead of the one it came from. Ask and get_record were unaffected. Found by running the omp adapter end to end. - A catch-up hook is no longer in its harness's process group. The Pi and omp extensions run
hook-pi/hook-ompin the background so a turn never waits on it, which also meant a harness that exits right afterturn_endorsession_shutdowncould take the child with it before it had read its payload. The child is now detached, so the copy finishes either way;session_before_compactstill waits synchronously. (Five print-mode omp runs landed the tape before and after the change, so this is hardening against a timing window rather than a reproduced loss.)
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.40
0.1.40 — 2026-10-12
- The rule for what counts as your typing is stricter and is applied when records are read, too. A turn is stored as
saidonly if it carries no block markup: any closing tag, any tag shaped like the ones tools write (a hyphen, underscore, or colon in the name), and any comment or declaration turn the whole turn away. The two wrappers that are still accepted (an editor's open-file or selection block at the front, and the wrapper around a message delivered mid-turn) must be in their exact form with no markup inside.askruns the same check on stored records, so one written by 0.1.36 to 0.1.39 under a looser rule stops appearing.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.39
0.1.39 — 2026-10-12
- A turn with a paste or tool output in it is not stored as something you said. 0.1.37 and 0.1.38 tried to cut pasted and tool-written blocks out of a turn and keep the rest. Text inside a block can contain the block's own closing tag, so no cut is reliable. The rule is now the other way round: after an editor's open-file and selection blocks at the front, and the wrapper around a message delivered mid-turn, any block markup left anywhere in the turn means the turn is not stored as
saidat all. Typing about markup ("<div>wrappers should be flex", "set it to<your_key>") is still kept. Sentence-level extraction is unchanged.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update
lossless v0.1.38
0.1.38 — 2026-10-12
- Pasted text cannot escape its block. 0.1.37 removed
<pasted_content>blocks by matching opening and closing tags in pairs, but pasted text can contain those tags itself, close its own block, and leave the rest of the paste looking like something you typed. Everything from the first opening tag to the last closing tag is now removed, a closing tag with no opening tag takes everything before it, and the check runs on the whole turn rather than on the shortened copy of a long one. - Only editor context is stripped from the front of a turn. The open-file and selection blocks an IDE adds are removed and your words after them kept. A turn that opens with any other closed tag block (a notification, a reminder, a hook's output) is not stored as something you said.
- How a session was started is read from the transcript line's own field, so the same text inside a message cannot make a program-started session look like one a person typed in.
Install
curl -fsSL https://github.com/jbgh/lossless/releases/latest/download/install.sh | sh
lossless setup
Already installed: lossless update