Omniscio

Archive a session

Archiving takes a session out of the sidebar's main list and parks it in the Archived sub-section without deleting anything — how to archive from the keyboard, the menus, middle-click or mobile, how undo works, how it differs from Delete, and what happens under the hood.

On this page

What it is

Archiving a session takes it out of the sidebar's main list and parks it in a collapsible Archived sub-section near the bottom of the project. The CLI process is killed, any running turn is force-stopped, and the row's status flips to archived. The conversation history, attachments, and metadata are all preserved — archive is non-destructive. You can unarchive any time, and sending a new message to an archived session silently un-archives it so triage stays friction-free.

Archive is the right action when you're done with a session and want it out of your way. It's NOT the same as Pause — pause is "freeze, I'll come back to this"; archive is "I'm done, hide it." It's also not Delete. An archived session keeps everything and stays visible under the Archived sub-section indefinitely, and you can bring it back. Delete is the separate, permanent action: right-click a session (archived or not) and choose Delete, or use the session's ⋯ menu → Delete…. A dialog names the session and asks you to type the word "Delete" first, and then the session and its whole history are removed for good, with no undo. The one exception is an AI Coaching chat, which goes to Recently deleted and can be restored for 30 days. See delete-a-chat.md.

Every archive is undoable. The always-on path is Ctrl+Z with focus outside a text box (a session row, the sidebar): it reverses your last session action, and you can press it repeatedly to walk back through recent actions. The session's own message composer also undoes the action via Ctrl+Z when its box is empty (it falls back to the app undo) — but inside any OTHER text box (search, team chat) Ctrl+Z is that box's own text-undo, like a normal editor, never the action. An optional Undo toast (a 5-second clickable "Undo" button) can also be turned on under Settings → Notifications ("Session archived" toasts, off by default); when on, clicking it calls unarchiveSession() and brings the row back. The default keyboard shortcut to archive the active session is Ctrl+W (or just E, both bound to the closePanel action in keybindings.ts — the action is internally named closePanel but its label is "Archive session"). When a file, markdown, or image preview is open on the right (the File Viewer, or the Google Drive preview), Ctrl+W closes that panel first — it archives the active session only on a second press, or when no preview is open. This mirrors Escape, which already closes the preview.

Where to find it

How to use it

  1. To archive the active session via keyboard. Press Ctrl+W or E with no input focused (or with a session focused). The row vanishes from the sidebar and joins the Archived sub-section. Ctrl+Z undoes it when focus is outside a text box, and also from the session's message composer while that box is empty; inside any OTHER text box (search, team chat) Ctrl+Z is that box's own text-undo, like a normal editor. Press it again from outside a text box to walk back through earlier actions. If you've enabled the optional "Session archived" toast (Settings → Notifications, off by default), its Undo button is a focus-independent alternative. Undo restores the session to its previous status if it was in an attention state (e.g. "Needs You" — ATTENTION_STATUSES); otherwise it returns to ended.

  2. To archive via the right-click context menu. Right-click any session row in the sidebar (or right-click + drag for a multi-select). The context menu opens with just Archive at the top — the command only, not the session name (you already know which row you right-clicked). Selecting more than one row first changes the label to Archive N sessions — bulk archive runs through bulkArchiveSessions and shows a single toast with the total. Archiving a selection that holds a running agent asks once first, naming how many live agents will be stopped ("Archive 3 running agents?"). That question is not about how many rows you ticked: archiving a running session stops it on the way in, and the Undo brings back the ROW, not the run — so it asks for even one running agent, wherever you archive from. A selection of idle or finished rows asks nothing, however large it is. Every archive entry point in this page — the menu, the E key, the mobile swipe, the mobile header button — runs that same one question, so none of them is the cheap way in.

  3. To archive on mobile via the X button. On mobile (md:hidden viewport), each session row in the sidebar shows a small X / close icon at the right edge. Tapping it archives that single session, undoable the same way (Ctrl+Z, or the optional toast). An Overseer's row has no X — the app's own always-on agents are reached through their inbox alert cards and their hub, and archived deliberately from there, so the row never offers an archive door. Desktop never shows an X — the X is mobile-only by design. On desktop, archive via middle-click, right-click menu, the overflow menu, or the keyboard shortcut. Inside an open session on mobile there's a second path: the Archive button in the header's top-right corner — it sits in the session header's action row, right after the ⋯ menu, centered on that row and hugging the right edge, so it stays lined up with the ⋯ and the mic no matter how tall the header gets (it renders inline for exactly that reason — when a taller control like the voice mic was added, an older fixed-position version drifted above the row; inline it can't). The inbox detail views (Texts, Email, digests, alerts, drips, …) use one shared pinned button at that same corner. Rule locked by mobile-archive-placement-contract.md. When the session is already archived, that same slot shows Unarchive. On the desktop header the way back from an archived session is a labeled "Unarchive" button (icon + word) beside the ⋯ menu, and the session's ⋯ menu always offers Unarchive too — even though Archive is pinned to the bar by default — so typing "unarchive" into the menu's filter always finds it. An archived session is never a dead end.

  4. To archive via desktop middle-click. Middle-click any session row in the sidebar (mouse button 1 — the scroll-wheel button) and the row archives immediately, undoable the same way (Ctrl+Z, or the optional toast). Middle-click is the desktop equivalent of the mobile X. Next-session behaviour: middle-clicking the session you're currently viewing advances the cursor to the row rendered immediately below it (or the row above when it was the last) — uniformly for every status, so you can triage a pile of gray/paused sessions row-by-row and the list stays where you are instead of jumping. Per-section advance: for Interrupted (gray/ended) and Paused rows specifically, the next pick stays within that same section — bouncing back to the previous row when you archive (or snooze) the last one — so clearing an Interrupted session never jumps you into the Paused section. Cursor-stable scroll: middle-clicking the highlighted row slides the next row into the exact on-screen slot the dismissed row occupied — under your stationary mouse — so you can middle-click the same spot repeatedly to clear a stack without ever moving the pointer. A stray middle-click on some other row never yanks an unrelated item to your mouse. Near the top edge — where a row physically can't reach the slot — it lands as close as the list allows, and at the bottom of a full list a tiny invisible spacer grows by exactly the shortfall so the next row still lands under your mouse (the same trick the phone uses; it trims away as you scroll clear, so no empty space lingers). Keyboard E keeps its calm behavior (it only scrolls when the next row would otherwise land off-screen), because the mouse is on the row for a middle-click but nowhere for E. Mobile × keeps its place: on a phone, tapping an inbox row's × holds the list steady as the row leaves, so the next row's × lands where your finger already is, letting you clear a stack top-to-bottom without re-aiming your thumb. See cursor-stable-dismiss-contract.md.

  5. To archive via the overflow menu. Open a session, click the three-dot menu (MoreHorizontal) in the session header, and pick Archive (archive icon) from the quick-actions group at the top of the menu — Snooze / Pause / Send Later / Archive, with a divider beneath it. The shortcut hint shows Ctrl+W next to it. Archive is now offered for any non-archived session, including a running one — clicking it on a live session auto-terminates the CLI, then archives (the same two-step backend the keyboard shortcut and middle-click already use), so you no longer have to reach for those just to archive a running session. The entry is replaced with Unarchive when the session is already archived. You can also right-click Archive — or any other quick-action row — and pick "Pin to session bar" to promote it to a one-tap button on the session header (desktop only); right-click a pinned header button to unpin it. Pinning rules: session-bar-commands-contract.md.

  6. What happens to a running session on archive. Omniscio first calls processManager.terminate(sessionId) to kill the CLI, force-flips the status to ended, then runs the archive write. So archiving an active session is a two-step backend operation that you don't see in the UI — from your perspective the row just vanishes. Worktree merges are triggered as part of the archive flow if the session was running on an isolated git worktree — but only while the in-app auto-lander is armed (its Auto-lander master switch in Settings → PR Merge Queue). It ships disarmed, so on a default install nothing is merged: the session's branch (session/<session-id>-<slug>) is kept exactly as it is; merge it yourself with your usual git tooling, or arm the auto-lander so Omniscio lands isolated branches for you. Nothing is thrown away either way. A merge-back you ask for by hand — Retry Merge (POST /session/:id/retry-merge) — is never blocked by the auto-lander switch.

  7. Auto-unarchive on Send. Open the Archived sub-section, click an archived session to view its history, type a new message, and Send. Omniscio calls queries.unarchiveSession() from sendResponse() and re-spawns the CLI for the new turn — the session is back in the live list and the conversation continues. You don't need to explicitly unarchive first.

  8. Manual unarchive without sending. Open the archived session, click the three-dot menu, and pick Unarchive (archive-restore icon). The status is restored to ended (or whatever you pass as restoreStatus) and the row reappears in the live sidebar list. Toasts and selection state are not preserved across the unarchive — it's a clean state restoration.

  9. P / H "deposit" an archived session into the live list. Pressing P (pause) on an archived session you currently have open un-archives it INTO the paused bucket — atomic, optimistic-slice-migrating, sidebar-visible immediately. Pressing H (snooze) does the same but routes through ended first so the existing snooze flow can take it from there. Bulk P with a mixed selection (some archived, some active) runs both arms in parallel and clears selection on settle. The single-session paths require the row to be the active surface (so a stale archived row in archivedSessions[] can't be silently dragged out when you're looking at something else). Codified as invariant keybindings-deposit-across-the-archive-boundary in archive-session-contract.md. Before this fix (2026-05-23), P/H on an archived session were silent no-ops because the keyboard handler only looked in sessions[].

  10. Browse the Archived sub-section. Scroll to the bottom of any project's session list and click the Archived (N) chevron to expand. See browse-archived-sessions.md for navigation through archived sessions (mobile swipe, J/K keys, prev/next chevrons).

  11. Phantom sessions. Omniscio sometimes creates a "blank" session and then soft-deletes it (softDeleteOtherBlankSessions) — for example when launching a new session that has no draft and no messages, an existing blank session is reused instead. If you somehow archive a soft-deleted phantom (rare race), the IPC returns "Session not found" and the renderer drops the row from sessions instead of rolling it back to visible. From your perspective the row stays gone — no error toast.

  12. Archiving an already-archived session is idempotent (self-heal). If a session was archived from another client (web/mobile), or its archive status push was missed (listener not yet mounted, a stale startup fetch), the row can be stranded in your LIVE SESSIONS list showing a gray (ended) dot even though it is already archived in the database. Clicking Archive on it again does NOT fail: Omniscio detects the session is already archived, reports success, and re-broadcasts the archive status event so every connected client (including the one with the stale row) moves it out of the live list and into Archived. From your perspective the stuck gray row finally disappears. (Before 2026-05-19 this returned a misleading "may still be running" error and the row snapped back, staying stuck forever — see the session-archived-stuck-gray-in-live-list postmortem.)

  13. Every archive is attributed — the "Archived by" chip. Open any archived session in the dedicated Archive view (the Archive sidebar / search). The header shows a small chip beside the project name with an archive icon and a human label — for example "Keyboard shortcut", "AI Router", "Recipe step", "Mobile swipe", "Voice command", "Close button", "Auto-cleanup", "CLI direct", "Plugin (its own session)", or "Agent (self-archived)". The plugin label marks a session a plugin started and then filed away itself through ctx.sessions.archive — a plugin can archive only its own sessions (plugin-bridge-capabilities-part-3.md). Every archive path records who triggered it (the closed ARCHIVE_TRIGGERS set, see src/shared/types.ts) into sessions.archived_by at write time. Pre-v226 rows that were archived before the column existed show "Unknown" as a graceful fallback rather than a blank chip. Unarchiving clears the stamp so a subsequent re-archive starts fresh. The chip exists so when a session "disappears" you can see exactly which surface put it there — keyboard shortcut, recipe step, AI router decision, etc. — instead of guessing. When another SESSION asked for the archive over the CLI, the session's own activity names it. The passive note at the end of the conversation reads "Automatically archived — External CLI (approved request) · archived by Whoever Asked", and that name is a link: clicking it opens the session that asked (an Overseer retiring its own helper, a maintenance session cleaning up). The name comes from the requester recorded on the CLI action, so it is the real asking session and never a guess; if no requester was recorded, or its row has since gone, the note stays exactly as it was without the attribution. A session is never named in its own note — a session that archives itself keeps the plain "Self-archived" wording above.

  14. Search the full archive — the search box loads everything. The dedicated Archive view lists the first 50 archived sessions on open (a performance cap — a 4,000-row archive would otherwise freeze the renderer at startup). As soon as you type into the search box, Omniscio auto-loads the rest of the archive in the background — a status line under the search input says "Loading all N archived sessions so search covers every one..." while the IPC is in flight. The filter then matches over the full archive, not just the first 50. You don't need to hit a "Show all" button first; the moment you start searching, the whole archive becomes searchable. This guarantee — "search always sees every archived session, no matter how many there are" — is what makes the archive a safe discoverability fallback when a session seems to have vanished.

  15. Stop an entire spawned run — and closes that stick. When an automation spawns a controller session that in turn spawns many worker sessions (an audit, a recipe, an agent orchestration), closing the controller now stops the WHOLE run — every worker it spawned is stopped with it, in one action, instead of you killing them one at a time while it spawns more. You don't even have to find the controller: right-click any worker row and pick "Stop entire run" — it resolves up to the controller and stops the whole tree. Because that one click can end a whole fleet, it asks first: a confirmation names how many sessions of the run the app can see ("Stop 4 running agents?") — the controller plus the workers it knows about, so treat a small number as a floor rather than a total — and declining it stops nothing and sends nothing. And anything you close stays closed: a session you close yourself is marked so NO automatic process — crash-recovery on a restart, the retry sweeper, an automation messaging it — can silently reopen it; only you re-opening it — or an agent you have directly told to — brings it back. A controller you've closed also can't spawn any more workers.

  16. A session can archive itself (agent self-archive). A running session — really the AI agent inside it — can archive its OWN session when its work is done, two equivalent ways: the simplest is to emit the marker [[OMNISCIO_SELF_ARCHIVE]] on its own line in its final message — Omniscio spots it when the turn ends and archives the session automatically, no command to run (agents reliably forget a curl call, so the marker is the dependable path); or it can call the CLI control server route POST /session/self-archive directly. Both trigger the SAME archive through one shared dispatch, so everything below applies identically. The marker matches only on its own line (a mid-sentence or code-fenced mention never fires, so an agent discussing the feature can't archive itself) and is stripped from the shown message. There's no id involved — the target is always the caller, resolved from its $AMC_SESSION_ID (the X-AMC-Source-Session-Id header), so a session can only ever archive itself, never another. It behaves like any other archive (the running turn is finalized then the process stops, the row moves into Archived, reversible via Unarchive) and is stamped with the "Agent (self-archived)" attribution chip so you can tell at a glance that the session ended itself rather than you or a recipe ending it. It honours your "require approval for CLI session actions" setting — applies immediately by default, or queues an inbox approval when that setting is on — unless you turn on the dedicated "Let finished sessions archive themselves without approval" toggle (Settings → CLI Control, off by default), which lets a session's OWN self-archive apply immediately with nothing landing in your inbox even while approval stays on for every other lifecycle action (only self-archive is exempt — archiving another session over the CLI still asks). Turning that toggle on is itself an approval-gated settings change, so an agent can never grant it to itself. It also has its own on/off kill-switch, Session self-archive (default on); when off, both triggers refuse (the route returns 403, the marker is a no-op). Full reference: agent-self-archive.md (the focused how-it-works page), session-self-archive-contract.md, and the omniscio-control sessions spoke. No automatic archive takes an unread report off your board unless you have handed archiving over. While a session holds a needs-you card whose final message you have not seen (no reply from you after it, and its badge not marked read), every automatic archive is refused: the session's own self-archive, a CLI request, a crew or Overseer retire, an audit run card. The session stays on the board until you have seen it. That includes the old session after a crew lead or foreman starts fresh: the post moves to the new session straight away, and the old one waits on your board until you have read its last report, then you archive it like any other (a lead's routine quiet turn has nothing waiting for you, and its cards follow the new session, so that session is filed away at once). An archive that is only blocked by the unread guard becomes an Archive card for you. When the app or the install-wide owner key asks for an archive and your unread report is the only thing in the way, it arrives in your Approvals as an Archive session "…" card naming the session, so your one click is the answer the app was waiting for; Approve all clears a pile of them at once. An agent's own token is narrower: it may archive only what it is responsible for — a crew member it commands, a builder assigned to the Overseer slot it holds, or a session linked below it in a group — and anything else is refused outright, with no card. One thing stands that card down, because it is you answering it in advance: an Always, everywhere standing allow you granted on an Archive session card — the caret beside Approve, or Settings → CLI Control → Always-allowed actions, where it is also revoked. An Archive card offers only that scope, because archiving is not a per-project action. With it in place an archive of another session asked for over the CLI just happens: no card, and no stopping at an unread report either, since your click would have carried it through the same way. Two things are deliberately NOT that answer: the Session pause / snooze / archive toggle (it ships off, so on a stock install it would mean "bury every unread report" without you ever choosing it), and a session closing itself — that keeps its own "Let finished sessions archive themselves without approval" toggle, so a grant can never empty the board of every finished session whose report nobody has read yet. Otherwise nothing is archived until you click, so an agent can never bury a report you have not read. Only cleanup triggers for sessions with nothing to read skip the check (idle empty sessions, orphans, project deletes, recipe and silent-recipe lifecycle, coaching, an untouched Super Prompt relaunch, and an Overseer lead being replaced: a fresh start files the outgoing lead away, while the Overseer keeper's own sweep still waits until you have read that lead's card), an Overseer filing a builder whose report the app already delivered to that same Overseer (the report has a reader who has it, so it is not waiting on you), and your own archive never waits. The check fails open if it cannot read the messages, and AMC_DISABLE_UNREAD_ARCHIVE_GUARD=1 turns it off. A card is never raised for something your approval could not clear — a session that is shared with someone right now, or one holding unshipped worktree work, still refuses with its own reason rather than asking you a question whose only answer is no.

  17. Archive warns you before it cancels work still due back (the archive safety net). Archiving cancels anything still due to come back to the session: a wake-up it scheduled, a land or gate watch, or an approval card it raised. Undo brings the row back but not those. A session it spawned is NOT one of them — a child runs in its own process with its own credentials, archiving the parent neither stops it nor takes its report away (that arrives in your inbox on its own), so a running child never holds the archive: spawn a worker, close the parent, let the worker finish. So when you archive a session and one of them is still live, the archive does not happen; a toast names what would be cancelled instead, for example "Not archived — this session is still waiting on something: a wake schedule is still armed. Archiving now would cancel it." The toast carries Archive anyway, which archives at once, and that warning waits for you: newer toasts never push it off the screen, and it does not time out on its own, so the button is still there whenever you get to it (dismiss it with its X if you would rather not act). A session with nothing due back archives instantly, exactly as before. It covers every place you archive from: Ctrl+W / E, middle-click, the mobile X and swipe, the header button, the right-click menu, inbox Dismiss and Simple Mode. A bulk archive archives the rest and lists the held-back sessions, and its Archive anyway archives exactly those. If a session also has unpublished git work, that warning comes first; its Archive anyway then shows this one, and this one's Archive anyway clears both, so neither warning repeats. The session's own scratch folder is never part of this check — it is temporary by design, every agent is told to write its read-back files there, and archiving deletes it on purpose, so counting it would hold nearly every finished session. That means a file you want to keep must not live only in a session's scratch folder. Automatic archives are never held: an agent's own self-archive, cleanup sweeps, recipes, automations, CLI archives and a crew lead being filed away. Voice archives show the reason but no Archive anyway button. It ships off: turn it on with Settings → Sessions → Behavior → "Warn before archiving loses work" (off by default, and an install that already had it on is switched off once by a one-time settings migration) — setting reference.

  18. Archive pauses before throwing away a running audit. A Nighty Tidy audit is expensive and takes hours, so archiving a session that is still working an audit run is held: a toast names the audit and offers Archive anyway, which archives at once. Only the session actually doing the work is held — a session that has already ended, a crashed audit, or an older session whose work moved on to a successor archives exactly as it does today, so the warning never claims an archive would cancel something it would not. Every place you archive from is covered, and a bulk archive lists the held-back sessions. Automatic archives are never held. It ships on; turn it off with Settings → Sessions → Behavior → "Pause before archiving a running audit" — setting reference.

  19. A row can tell you, before you click, that archiving it would strand work — once you switch it on. The shield is off by default: turn on Show “not safe to archive” warnings on sessions in Settings → Sessions → Behavior (archiveSafetyIndicatorEnabled). While it is off Omniscio runs no background check for it at all, and switching it off clears every shield already drawn. With it on, sessions that still have something coming back to them carry a small amber shield in the row's indicator slot, and its tooltip names the reason in words — "Not safe to archive: a crew seat is still live", "…: background work is still running", "…: a message is queued for delivery", "…: the agent is waiting on a background process", "…: a wake schedule is still armed", "…: a gate watch is registered", "…: an approval card is waiting". Hovering the row itself explains it too, alongside its other icons. A row with nothing in flight draws no shield at all, so the mark only ever appears where it means something. The shield and the warning in item 17 ask the same question of the same code, so a row can never warn you about something an archive would not actually hold — the shield simply says it earlier, at a glance, without interrupting anything. It is advisory: it never blocks an archive, never slows or hides a row, and carries no button of its own. While switched on, it refreshes in the background every ten seconds for the rows you are looking at, so it can lag real state by up to that long; the warning at archive time is always fresh. It is desktop-only — the phone's session list does not draw it, and a phone archive is still held by item 17's check. Full rules: archive-safety-indicator-contract.md.

  20. Archiving a session that is still running an audit asks first. A session running a Nighty Tidy audit keeps the entire audit in its own work, so archiving it ends the audit and the findings are lost — two paid runs were lost that way, one at $182 and one at $311.52, both to a routine middle-click. So when a session that is still running an audit is archived by you, Omniscio asks once before anything happens: "Archive a session that is running an audit?" with Archive and end the audit (Cancel is the button in focus). It covers every place you archive from — middle-click, Ctrl+W / E, the header X, the overflow menu, the phone swipe, a spoken command, and a bulk archive (one question for the whole gesture, never two). Every other session archives exactly as before, with no question and nothing slower, and a session that has already ENDED never asks even if it still remembers its audit. It ships on; turn it off with Settings → Sessions → Behavior → "Ask before archiving ends a running audit" — setting reference.

How it behaves

Archiving is non-destructive and reversible. The CLI process is killed and any running turn is force-stopped, the row's status flips to archived, and the conversation history, attachments and metadata are all preserved — the session parks in the collapsible Archived sub-section near the bottom of its project and remains visible there indefinitely. Every archive can be undone: Ctrl+Z with focus outside a text box reverses your last session action and can be pressed repeatedly to walk back through earlier ones, and sending a new message to an archived session silently un-archives it. The one limit worth knowing before relying on it: inside any other text box (search, team chat) Ctrl+Z is that box's own text-undo, not the action undo. The other limit: undo does not bring back the session's scratch folder or anything that was still due back to it, which is why your own archive of such a session asks first (item 17 above). The scratch folder is not covered by that warning, so agents carry it instead: before an agent's summary card recommends Archive, it moves anything it still needs out of its scratch folder to somewhere lasting (a memory note, or a git-ignored folder in the project) and the card says where it went. Every session is also told this at the start: the built-in scratch-files instruction in its system prompt tells the agent to delete the throwaway scratch files it wrote before the final report and to move anything of its own that must survive out of the folder first, because archiving deletes it. It also tells the agent to leave the app's own session credential in that folder alone — neither copied out nor deleted — because archiving the folder is what destroys it.

An archive that cancels a booked check-in says so in the session. The warning above is for a session YOU archive; a session archived by anything else — a cleanup sweep, a recipe, its crew, an agent ending itself — writes a plain note into its own transcript instead, naming each wake schedule that was still armed and when it would have fired, and pointing at the switch that turns it back on. A session with nothing armed gets no such note. So a check-in a colleague booked for you does not disappear without a word: open the session and the note is there.

  • agent-self-archive.md — how a session archives ITSELF when its work is done (the [[OMNISCIO_SELF_ARCHIVE]] marker / POST /session/self-archive, the "Agent (self-archived)" chip, the two CLI-Control settings)
  • pause-or-stop-a-session.md — Pause vs Archive: pause keeps the row visible but frozen; archive hides it
  • snooze-a-session.md — Snooze vs Archive: snooze hides until a time, the session keeps running in the background
  • browse-archived-sessions.md — open and navigate between archived sessions (J/K, swipe, prev/next chevrons)
  • send-a-message.md — auto-unarchive on Send and the rest of the Send pipeline
  • bulk-select-sidebar.md — multi-select and bulk-archive via right-click menu
  • bulk-stop-restart-sessions.md — stop or restart a hand-picked set of sessions (vs. "Stop entire run", which stops one spawned tree)
  • delete-a-chat.md — Delete vs Archive: delete removes one session and its whole history for good, after a type-to-confirm dialog; archive keeps everything and is reversible
  • delete-a-project.md — when you want to delete a whole project (and all its sessions) instead of just archiving one session

Last verified 2026-11-02