Sessions.

Work is saved as you go

A session is one conversation with the agent: your prompts, its replies, the tools it ran, and what it all cost. Every session is recorded as it happens, on your machine and outside your checkout, so nothing squeezy stores shows up in your repository.

You can list past sessions, search them, see the summary of one, or resume it and keep working. Search looks inside the conversation, not only at the date and the branch, so "auth bug" finds the session where you were fixing one. squeezy sessions fork branches a saved session into a child, so you can try a second approach without spending the first.

Nothing expires on a timer. squeezy sessions clean is a sweep you run yourself, and it archives rather than deletes, so squeezy sessions unarchive brings a session back. squeezy sessions delete is the one command that removes history for good. Neither will run without either --dry-run or --yes, so you always see the list before it is acted on.

Long conversations are compacted while they run: older turns fold into a short summary of goal, progress, and decisions, while recent work stays word for word. Resuming picks up that compacted conversation, so turn 30 does not re-send turns 1 through 29.

Records live at $SQUEEZY_HOME/projects/<project-dir>/state/sessions/. The search index beside them, cache/indexes/sessions.db, is rebuildable and covers a redacted projection: your prompts, the agent's replies, tool names, and session metadata. Reasoning and tool output bodies are never indexed.

squeezy sessions list
squeezy sessions list "auth bug"
squeezy sessions show <id>
squeezy sessions resume <id>

Undo what the agent changed

Checkpoints are an undo button for the agent's edits, independent of git. Turn them on and each edit is snapshotted first, into a private copy under $SQUEEZY_HOME that is separate from your own history, so undo works even before anything is committed.

/undo rolls back the most recent change. /revert-turn <turn_id> takes back everything one turn did, a turn being your message plus all the work the agent did to answer it. /checkpoints lists what can be restored. Every restore is verified against content hashes: if you edited a file yourself since the snapshot, the restore stops and reports the conflict instead of writing over your work.

What is covered: files the agent writes, patches it applies, notebook cells it edits, downloads it saves, and shell commands it runs. What is not: tools from MCP servers, including servers running on your own machine, and shell commands you run yourself. So /undo cannot reverse a file an MCP server wrote, and will reach past it to an earlier checkpointed edit.

This is off by default, and the reason is cost: each snapshot enumerates the whole workspace, so its price tracks how many files your checkout has, not how big the edit was. Files over 2 MiB are skipped, and snapshots are kept for 7 days. One consequence to decide with your eyes open: while checkpointing is off, /undo, /revert-turn, and /checkpoints are hidden from the slash menu and the command palette, so choose before the risky work starts, not after.

Enable it with [tools].checkpoints_enabled = true in your settings file, from /config checkpoints, or with SQUEEZY_CHECKPOINTS_ENABLED=true; each applies on restart. Note that the private copy is a real copy: your workspace content lives under $SQUEEZY_HOME until retention prunes it. Anything your .gitignore covers is never captured, and neither is anything in your repository's local excludes. On small and medium repositories the per-edit undo is worth these costs; on very large trees, your own git commits are the better safety net.

/undo                    # roll back the latest file change
/revert-turn <turn_id>   # undo everything one turn changed
/checkpoints             # list what can be restored

Memory that carries across sessions

Resuming replays one conversation; memory carries durable facts between them. squeezy keeps a small, plain-Markdown memory so a new session already knows how you like to work and what a project is about, without re-learning it each time. It is on by default and lives in files you can read and edit.

Recall is automatic: at session start the memory index is loaded into the model's context, capped at 16 KB per scope. So is capture. After a turn settles, a cheap background pass distils durable facts into memory, and a quiet ✎ memory: line appears in the transcript when it saves one. You can also be explicit and say "remember that ..." or "forget ...". Run /memory to see everything saved, grouped by scope, or /memory <query> to search it.

Where a memory lives follows what kind it is, and squeezy decides that rather than asking. Facts about how you work (user, feedback) are global under $SQUEEZY_HOME/user/memory/ and follow you everywhere; facts about a repository (project, reference) stay under $SQUEEZY_HOME/projects/<project-dir>/state/memory/. Each memory is one file, and a MEMORY.md beside that directory indexes them.

Memory is for durable preferences and context, not code indexing. It deliberately skips secrets, credentials, and personal data, and skips anything re-derivable from your code or your git history. Set context.user_memory_max_bytes = 0 to turn it off entirely, or context.memory_auto_extract = false to keep file memory but stop the automatic capture pass.

Cost and context, in view

During a session, /context shows how much of the model's window is in use right now, and /cost shows where the money went: split by model and by role into input, output, reasoning, cache reads, and cache writes, in dollars where the provider publishes rates. /cost saving summarizes what was saved, and /cost discover breaks the session down by savings, waste, and trend, so a large bill becomes a specific answer rather than a guess.

Exports and workspace state

For a handoff, /export writes one directory holding session.json with the full data and session.html as a readable page. Exporting the session you are in adds three more: bundle.md, which pairs terminal diagnostics with a secret-redacted transcript and a checksum; conversation.txt, the raw screen transcript, redacted; and a subagents/ directory with one redacted transcript per helper agent that ran. By default it lands under the owning project's artifacts/exports/ directory in $SQUEEZY_HOME, not inside your checkout, and exporting the same session twice writes a v2/ beside the first snapshot rather than over it.

Some state stays with the machine rather than the checkout. A generated repo profile at $SQUEEZY_HOME/projects/<project-dir>/cache/repo-profile.toml records compact facts squeezy detected -- languages, package managers, likely commands, CI providers -- so later sessions skip re-exploring the shape of the project. Read it with squeezy repo show and recompute it with squeezy repo refresh. Four per-workspace display preferences persist the same way: transcript density, transcript detail, the minimap pane, and the active theme, keyed by the resolved repository root and restored the next time squeezy launches there, so they never dirty your working tree.

Reporting

Use /report for the guided local archive flow, or squeezy report <id> to create a diagnostic ZIP outside the Session. --startup works without a resumable Session; --dry-run inspects the manifest without publishing an archive. Share the ZIP privately with the developer support team through the appropriate channel. See help & troubleshooting.