Continuity — Every AI session starts knowing your architecture

Decision memory in .continuity/ — session handoff at start, auto-capture in the editor, MCP across AI clients. Two install paths; pick the one that matches how you work.

AI coding tools forget your architecture every session. Continuity captures decisions locally and injects curated context at session start — so you stop re-explaining the codebase and your AI stops contradicting what you already decided.

---

Choose your install path

Continuity is one memory layer (.continuity/ in your repo) with two ways in. They are not interchangeable for habit — pick deliberately.

Path	Best for	What “works as advertised” means
Gallery (recommended)	Solo devs in VS Code or Cursor who reload sessions often	Install extension → run setup wizard → MCP connects → handoff strip on day 1 and day 2 (~half of installers return within a week in prod telemetry)
npm / Homebrew CLI	Terminal-first setup, CI, or headless repos	continuity init → log decisions day 0 → must mount MCP or install the extension for cross-session handoff; npm-only without extension has very low week-2 return unless you follow the post-init NEXT STEP screen

Honest default: If you want “every AI session starts knowing your architecture” without thinking about it, start with the VS Code Marketplace extension. Use npm when you already live in the terminal — then add the extension or MCP before day 2.

See FAQ — Gallery vs npm for the full comparison.

Who This Is For

• Developers using Cursor, GitHub Copilot, Claude Code, or Gemini
• Teams tired of re-explaining the same context every session
• Anyone building real systems with AI — not just prompts

---

Without Continuity vs With Continuity

Without Continuity	With Continuity
Re-explain decisions every session	Decisions automatically recalled
AI forgets architecture	Architecture stays consistent
Conflicting implementations	Conflicts detected and flagged
Context resets constantly	Context persists across sessions (gallery + MCP path; see install paths above)

AI goes from a forgetful intern to a staff engineer with memory.

---

See It In Action

Prefer full quality? Watch on YouTube.

Side-by-side: same codebase, same question, identical AI tool. The only difference is whether Continuity is active.

---

What It Does

Continuity adds a state layer to your AI tools:

• Remembers why decisions were made
• Recalls the right context at the right time
• Prevents conflicting or unsafe actions
• Carries context across sessions and tools

---

How It Works

1. Log decisions as you work — manually, via the continuity CLI, or auto-detected from git commits.
2. Stored locally in your repo — .continuity/decisions.json, committed alongside your code.
3. AI tools recover context automatically via instruction files (CLAUDE.md, .cursorrules, AGENTS.md, GEMINI.md) or optional MCP integration.
4. Only relevant context is injected — no prompt bloat, no wasted tokens.

Local-first. No cloud memory. You own everything.

---

Do I Need to Tell My AI to Use It?

Installing Continuity is the opt-in — you don't prompt your assistant to "use Continuity" every session. How hands-off it feels depends on your install path:

Gallery extension + MCP (recommended — fully hands-off)

• Recovering memory: Session handoff and instruction files (CLAUDE.md, .cursorrules, AGENTS.md, …) load at session start when the extension and MCP are active. Your assistant resumes with architecture and recent decisions without you asking.
• Recording decisions: Auto-capture (Pro), git hooks, and MCP-capable clients log as you work. Capable tools (Claude, Cursor, Copilot, Gemini, Codex) follow the instruction files unprompted.

npm / CLI only (day 0 yes — week 2 needs a deliberate next step)

• Day 0: continuity init and continuity log work immediately; the journal lives in .continuity/.
• Day 2+ handoff: Requires MCP mounted in your AI client or the VS Code extension in the same repo. After init, follow the bordered NEXT STEP screen (continuity recall verify --watch confirms recall). Without that, npm-only use is logging — not automatic session handoff.

If an assistant forgets to record something, continuity log or "log that decision" is enough. Memory keeps itself on the gallery + MCP path; on npm-only, you finish setup once (extension or MCP), then it keeps itself.

---

Core Features

Decision Memory

Log once — your AI remembers forever.

Session Handoff

Resume work without losing context. Curated architecture, recent decisions, and session notes inject before the first prompt — this is how context actually gets delivered across VS Code, Cursor, Copilot, Gemini, and MCP clients.

Auto-Capture (Pro)

Five layers watch git commits, file saves, hooks, AI sessions, and MCP activity so decisions land without stopping your flow.

Code Intelligence

Link decisions to files and symbols via MCP tools, path-based backfill, and optional QuickPick suggestions when file paths appear in decision text. Not benchmarked as "90% accurate auto-linking" — symbol/project indices are built on demand and may be absent until ProjectMappingService has run in your workspace.

Works Across Tools

Continuity works with any instruction-based AI assistant, but Claude Code is the recommended client for the best MCP compatibility — it connects over stdio with workspace roots, so per-project memory resolves reliably. Others work too and are fully supported.

• Claude Code (CLAUDE.md) — ⭐ recommended, best MCP compatibility
• Claude Desktop
• Cursor (.cursorrules)
• GitHub Copilot (.github/copilot-instructions.md)
• Google Gemini (GEMINI.md)
• OpenAI Codex, Google Antigravity
• Any instruction-based AI assistant

Optional AI providers (Pro features)

Auto-log, quality scoring, and semantic search call your configured provider — Anthropic (Claude), OpenAI, Google Gemini, or local Ollama. Choose one in Settings → AI Provider; Continuity does not host models.

Works without a provider: Decision logging, search, MCP tools, and instruction files run fully offline. When auto-log or quality scoring needs a model and none is configured or reachable, Continuity uses template-based drafts (no outbound API call). Privacy domain profiles can block cloud providers and prefer local Ollama when available.

Also included in Pro (not the headline)

Semantic search, knowledge graph visualization, source ingestion, reports, and wiki health checks — useful when you need them; handoff and auto-capture are what Pro sells.

MCP Integration (Optional)

Unlock advanced capabilities for MCP-compatible tools:

• Tool interception
• Policy enforcement
• Context injection
• Automation workflows

A full MCP tool suite covers decision logging, search, code intelligence, governance, freshness, reports, and sources.

---

Getting Started

Recommended: VS Code Marketplace (gallery path)

1. Install from the VS Code Marketplace
2. Open your project in VS Code or Cursor
3. Run Setup Wizard — Command Palette → Continuity: Run Setup Wizard → configure MCP → reload
4. Open the Continuity sidebar — handoff strip shows session state above the fold
5. Log your first decision — your AI will remember it next session

That's it — no cloud setup, no account required.

Alternative: npm / Homebrew (CLI path)

npm install -g @continuity/cli@^3.8.3
cd your-project && continuity init

Follow the NEXT STEP screen after init (extension install, MCP setup, or reload). For full handoff habit, install the extension in the same repo. Details: continuity-cli/README.md.

---

Pricing

Free proves it works. Pro makes it automatic. Team makes it shared and provable.

14-Day Free Trial

• Full Pro access — auto-capture, full handoff, MCP, export, every feature
• Unlimited decisions
• No credit card required

After the trial: Your decisions stay in .continuity/ — search, view, and export keep working. Decision logging is always free. Auto-capture and full session handoff pause until you upgrade; Pro brings them back.

What Pro sells

Pro keeps two things automatic: capturing why your codebase is the way it is, and serving that context when any AI session starts. Decisions land from git, file watch, hooks, and MCP — you rarely type them in. Full session handoff injects curated architecture before the first prompt, so you stop re-explaining the same choices every week. After trial, logging stays free; auto-capture and full handoff pause until you upgrade. Search and the knowledge graph are included — not the headline.

Plan	Price
Monthly	$9 / month
Annual	$89 / year (save 18%)
Lifetime	$199 one-time

Upgrade to Pro · Team — $15/seat (3-seat minimum): git-shared decisions, audit export, Dream governance reports.

---

What This Actually Is

Continuity is not:

• A note-taking tool
• A prompt helper
• Just another extension

Continuity is:

The state management layer for AI coding tools.

---

Why It's Different

• Local-first — your memory lives in .continuity/ in your repo, not on a vendor-hosted decision cloud
• Repo-owned — versioned with your code, reviewed in PRs
• Cross-tool — same memory serves every AI assistant you use
• Built for real work — production-grade, not demos

---

If This Helps You

If Continuity saves you time, please leave a review on the Marketplace — it helps others find it.

---

What's New

v3.0.157 — September 2026

• Cleaner MCP setup toast. After configuring MCP in the Setup Wizard, the success notification now shows at most two actions — no duplicate dismiss buttons or crowded four-button stacks.

v3.0.156 — August 2026

• First-run toast storm fixed. Opening a repo no longer fires three simultaneous notifications (context synced, import prompt, decision logged). A 90-second startup quiet window defers non-critical toasts; AI instruction import waits until Setup Wizard completes; quietOnboarding defaults to on.
• Draft decision popups shortened. AI auto-capture review toasts show one line + filename — full text opens on Review, not in the notification body.

v3.0.154 — August 2026

• Trial panel no longer shows "-1 days remaining". Pre-trial (before your first logged decision) now displays honest copy — 14-day trial starts after your first decision — instead of a broken negative countdown and "Unknown" expiry.
• Trial abuse closed. Logging decisions via CLI/MCP only no longer bypasses the 14-day countdown; extension activation reconciles the decision store and starts the trial. Pre-trial also caps at 7 days before the countdown auto-starts.
• Setup Wizard auto-opens when you open a repo that already has .continuity/ (e.g. after continuity init), so gallery onboarding is one less manual step.

v3.0.153 — August 2026

• Public copy aligned with product reality (GRADE-8). Marketplace readme, FAQ, and extension docs now describe the two-path truth — VS Code/Cursor handoff loop vs npm CLI habit path — without overpromising multi-agent orchestration.
• Same PRC stack as 3.0.152. Trial nudges on Day 11/14/15, handoff-first onboarding, MCP auto-repair at activation, and interview CTAs — repacked so gallery-facing copy matches what ships.

v3.0.152 — August 2026

• Trial nudges fire on Day 11 and Day 14 — not only at expiry. Sequential milestone toasts and sidebar copy now lead with handoff + auto-capture value before trial ends, so upgrade prompts arrive while you still have time to evaluate Pro.
• Handoff-first onboarding. Setup wizard welcome and completion screens point at the handoff strip and first-handoff panel; new users with ≤50 decisions see a quieter sidebar until memory grows.
• CLI day-3 habit commands. @continuity/cli@3.8.3 adds continuity doctor and continuity handoff, extension-aware init next-step, and bridge gating when the VS Code extension is missing.
• PostHog-only telemetry on npm MCP 3.0.122. Standalone @continuity/mcp no longer burns 5s on deprecated DigitalOcean ingest (CO-675).

v3.0.150 — August 2026

• User-research CTAs at the decision moment. Trial toasts, expired sidebar, and CLI post-log now offer a quick interview link (Buildpad) — separate flows for "why didn't you upgrade" vs "what made you pay" — so we can learn from real cohorts without blocking upgrade paths.
• Handoff status at a glance. The Decisions tab shows MCP health, decision count, and handoff readiness above the fold — populated on sidebar ready so you always see session state without scrolling.
• Smarter decision linking. AutoLinker parity in the extension: new decisions link to prior context via the same core engine as MCP, not a regex heuristic.
• CLI engagement + interview line. @continuity/cli@3.8.1 ships post-log bridge/nudge plus a one-time research prompt when trial is ending; Homebrew tap mirrors npm.

v3.0.134 — August 2026

• Cleaner first run in a fresh git repo. When you run continuity init before your first commit, setup completes without confusing git error output — so npm and headless installs feel polished from the very first command.

v3.0.132 — August 2026

• New decisions connect themselves. Every decision you log now links automatically to the prior decisions that led to it — capped, confidence-gated, and marked as auto-created — so your knowledge graph builds itself instead of collecting disconnected dots. Decisions with no relevant context are labeled as intentionally standalone rather than left unexplained.
• The Synaptic Graph explains what you're looking at. Clicking a decision opens a context panel that reads like a story — what was decided, what it replaces, what led to it, what followed — with clickable connections. Selection now keeps a decision's neighborhood highlighted while everything else fades back, auto-created links render dashed with their confidence, and a new toolbar pill isolates unlinked decisions in one click.
• First run on npm gets you to recall faster. continuity init now seeds an empty journal from your git history, mounts the MCP server for detected AI clients automatically, and generates instruction files (CLAUDE.md, AGENTS.md, and friends) — one command instead of four.

v3.0.130 — August 2026

• Trial reminders land at the right time. Day 11 and day 14 nudges fire on schedule, grace-period toasts dedupe to once per day, and a sidebar banner appears when your trial has a week or less — so upgrade prompts feel helpful, not noisy.
• CLI recall path is clearer from first run. continuity init and continuity mcp setup now point you at live recall verification with --watch, and recall verify offers to start watch in the same session after preview — closing the gap where most npm installs never reached the aha moment.

v3.0.128 — August 2026

• Decision edits and archives stick. Updating or archiving a decision no longer silently reverts on the next sync — your journal changes persist the way you expect.
• MCP setup repairs itself on Windows. After an extension update, Continuity finds the correct server path even when your project config still points at an old install location.
• License stays current between sessions. Online revalidation keeps Pro status accurate without asking you to re-enter your key after routine restarts.

v3.0.124 — August 2026

• Trial upgrade path stays connected end-to-end. When you tap Upgrade from a trial reminder or the in-app menu, Continuity opens pricing with a consistent checkout flow — so moving from trial to Pro is one clear path, not a dead click.

v3.0.122 — August 2026

• Synaptic Graph works reliably again. The decision graph view fills the panel, settings and edit panels stay hidden until you open them, and the performance overlay closes normally — so exploring your memory map is usable on every reload.
• Sidebar tab icons render correctly. Decision, graph, and settings tabs show their intended glyphs instead of broken escape codes in the webview shell.

v3.0.119 — August 2026

• MCP-only install from npm. Run Continuity memory in Claude Code, Cursor, or Cline without the VS Code extension — install @continuity/mcp globally, point your MCP client at your repo, and decision logging plus search work on the free tier.
• Pro on npm uses the same license you already have. Activate with the existing continuity CLI; the MCP server picks up your Pro status from the shared license cache — no separate npm subscription.
• Governance warns before it blocks. When optional governance is enabled, conflicting decisions surface as warnings in the log response so you see the tension without a silent overwrite.

v3.0.114 — August 2026

• Search that scales with your memory. Decision search now uses industry-standard BM25 relevance ranking: rare, specific terms (a library name, a service, an acronym) count for more than common words, and long entries no longer crowd out short precise ones. In our 1,000-decision benchmark, the right decision appeared in the top results for 19 of 20 questions — up from 13 — so the answers your AI needs surface even in large, mature project histories.

v3.0.112 — August 2026

• Trial reminders that show your progress. On day 11, 14, and 15 of your trial, Continuity surfaces how many decisions you have logged and how much context your AI has already recalled — so you see the value before the trial ends, not after.
• Clearer upgrade paths during trial. Trial notifications link to pricing with context about what Pro unlocks; optional email signup on day 11 helps you stay in touch if you want a nudge before trial ends.
• Clearer Pro positioning in the marketplace listing. Pro is described as what it actually delivers: auto-capture plus full session handoff — every AI session starts with your architecture, not a blank slate. Trial copy now matches the product: your decisions stay yours, logging is never blocked, and auto-capture pauses after trial until you upgrade.
• Team tier linked from pricing. Git-shared memory, audit export, and governance reports at getcontinuity.io/pricing.

v3.0.110 — August 2026

• Export decisions from the sidebar. One-click export from the Decisions tab, header icon, or Command Palette — with optional redaction for sharing outside your team.
• Analytics consent after your first handoff. Continuity asks once whether to send optional usage telemetry; you can change your choice anytime under Settings → Privacy & Analytics.
• Trial funnel telemetry. Optional analytics now records trial phase transitions so activation dashboards reflect real trial-to-paid journeys.
• Governance export signal. Successful decision exports emit audit_export metadata (format, counts, redaction flag) — no decision content transmitted.

v3.0.108 — July 2026

• MCP status clears when your AI client connects. Opening Cursor, Claude Code, or Copilot with Continuity MCP enabled now updates the sidebar promptly — you no longer need to run a memory tool first just to dismiss the idle banner after reload.

v3.0.107 — July 2026

• Governance telemetry for teams. Dream consolidation runs and decision exports now emit optional analytics signals (dream_cycle_completed, audit_export) so Team-tier governance usage can be measured in PostHog — decision counts, contradictions surfaced, export format, no decision content transmitted.
• DEV savings indicator reliability. Marketplace and DEV builds bundle tiktoken WASM so the savings counter works on fresh installs without a broken dependency path.

v3.0.105 — July 2026

• Clearer MCP status with Claude Code and other external clients. When your AI tool connects over MCP but hasn't called a tool recently, the sidebar now explains that state honestly — including when memory was last used — instead of leaving a confusing "unconfirmed" banner up forever.
• Verify MCP in one click. A new Verify action copies a short prompt you can paste into Claude Code, Cursor, or Copilot to confirm the connection is working.
• Gentle reminder after updates. After a gallery upgrade, Continuity may nudge you once to run an MCP tool so the sidebar reflects your live connection.

v3.0.104 — July 2026

• Accurate MCP status in the sidebar. When your AI client uses Continuity's MCP tools, the sidebar now reflects that connection promptly — no more "MCP unconfirmed" banner stuck on after tools are working.

v3.0.103 — July 2026

• Optional analytics events arrive reliably. Sidebar and activation events now reach your analytics dashboard even when other network paths are slow or unavailable — so install and engagement funnels reflect real usage on fresh machines.

v3.0.102 — July 2026

• Optional analytics work out of the box. New installs include analytics configuration by default, so activation and sidebar activity show up in Live dashboards without manual setup.
• Stronger install verification. Marketplace builds are checked before release so a missing analytics or savings indicator configuration cannot ship again.

v3.0.99 — July 2026

• Reliable extension updates. After a gallery upgrade, Continuity now removes stale version folders across VS Code, Cursor, and remote install paths, repoints the MCP stable symlink automatically, and logs cleanup issues to the Output channel — so MCP keeps working on the version you actually installed.
• Edition-safe cleanup. Marketplace updates no longer risk deleting a side-by-side DEV install when both editions are present.

v3.0.98 — July 2026

• Complete activation funnel (optional analytics). When PostHog is configured, Continuity now tracks the full install journey — first-run completion, MCP mount attempts, upgrade page views, and clicks — so you can measure where new users succeed or drop off.
• Smarter mount telemetry. MCP connection attempts are aggregated hourly per client, preserving retry counts without flooding your analytics budget.
• First-run milestone. Continuity records when onboarding finishes, closing the gap between install and first handoff in activation dashboards.

v3.0.96 — July 2026

• Smarter savings reporting. Continuity now measures token savings with explicit coverage — so ROI-style claims stay honest and defensible.
• Stronger MCP health monitoring. Hourly process summaries help catch runaway server restarts before they drain your machine.
• Richer optional analytics. Improved handoff and context events for users who opt in to anonymous usage analytics.

v3.0.95 — July 2026

• Paid licenses work in Claude Code, Cursor, and other external MCP clients. If Continuity shows LICENSED in VS Code, the same license is honored when those tools launch the MCP server directly — no false "trial expired" wall.

v3.0.94 — July 2026

• MCP works with your paid license across all AI clients. Claude Code, Cursor, Copilot, and other tools that launch Continuity's MCP server directly now honor Active Pro and lifetime licenses — not just when VS Code spawns the server.
• Activation analytics (optional). Anonymous funnel events help measure time-to-first-handoff for new installs when PostHog is configured.
• Handoff tracking. Continuity records when session context reaches your AI assistant — the moment memory actually delivers value.

v3.0.91 — July 2026

• Activation funnel telemetry (v2). Optional PostHog forwarding when configured — extension_activated (with is_first_run) and handoff_served events for measuring time-to-first-handoff and 7-day activation rate.
• Richer anonymous analytics properties. Events include schema version, install ID, IDE, and build mode so production dashboards can exclude dev/bypass installs.
• Handoff served tracking. Continuity records when session context is injected at startup or via MCP — the primary “value moment” for new installs.

v3.0.90 — July 2026

• Clearer privacy and data handling. Documentation now accurately describes local-first storage, optional anonymous usage analytics, and integrations you configure — replacing outdated absolute no-telemetry wording.
• Safer exports when sharing decision history. Export tools can redact email addresses and similar personal details before you hand a log to a teammate or auditor.
• Fewer duplicate auto-captured decisions. Continuity now deduplicates repeated hook and auto-log entries so your journal stays easier to search.
• Smaller, faster semantic search index. Decision embeddings use a compact on-disk format with automatic migration from older caches.
• Journal maintenance tools. Compact a growing decision log from the CLI when revisions pile up.
• Works with your choice of AI provider. Docs and defaults reflect Anthropic, OpenAI, Gemini, or local Ollama — plus optional cloud fallback when a local model is unreachable.
• Cross-tool memory, honestly marketed. Public copy leads with MCP shared memory; experimental in-editor agent features stay off by default.
• Stronger pre-ship checks. Automated gates verify privacy copy, provider messaging, journal health, and CI reliability before each release.

v3.0.83 — July 2026

• Clearer signal when MCP is unavailable. The status bar and sidebar now show when Continuity is on file-based fallback instead of live MCP tools — degraded mode is visible, not silent.
• Safer context when MCP is down. Fallback guidance prioritizes session notes and summaries and avoids dumping entire decision caches into your assistant's context.
• More reliable auto-capture from git commits. Commit subjects with colons, punctuation, and quotes no longer break automatic post-commit notes.
• More accurate savings estimates. Savings tracking uses refreshed model pricing so counterfactual estimates stay realistic.
• Steadier MCP health checks. Background health probes no longer spawn extra server processes on each check.

v3.0.81 — July 2026

• Release-quality work behind the scenes. A broader automated check now runs against every build before it ships. Nothing changes in how Continuity behaves day to day.

v3.0.80 — July 2026

• More accurate savings tracking. Broader project coverage and refreshed model pricing.

v3.0.79 — July 2026

• Your full decision history shows in the sidebar again. Refreshes now read the same durable log as search and MCP, so counts and lists stay in sync on large projects and after git pull on another machine.
• MCP health on WSL and mixed setups. Quick Setup and health checks fall back when editor config still points at another computer’s paths, and status is less likely to stay red while the server is starting.
• Project memory travels with the repo. Session handoff files (working memory, unfinished tasks, dream reports, and related artifacts) can live in git so you pick up on Windows, Mac, or WSL where you left off.
• Easier cache rebuild after clone. Regenerate the local decision index from the journal with one npm script when the CLI install is still being set up.

v3.0.78 — July 2026

• Claude Code connects reliably again. Quick Setup now writes the project MCP config Claude Code actually reads, with the format current Claude Code versions require — so continuity shows up in /mcp after you approve it.
• Clearer MCP health on slow setups. The editor health check is lighter and more patient on Windows and WSL, so red “disconnected” status is less likely when the server is still starting.

v3.0.77 — July 2026

• See your AI remember something on day one. A guided First Recall flow walks you from setup through a real recall moment — so you know memory is working before you lean on it in a long session.
• Memory progress at a glance. The status bar shows how far setup has come and opens a quick path to finish wiring your editor or agent.
• Starter decisions when the repo is empty. Sample entries give you something to search and recall immediately; remove them anytime when your own history is enough.
• When memory helps, you notice. Clear notifications when Continuity surfaces a past decision for your AI — including after commits that auto-capture a decision.
• End-of-session recap (optional). After a productive stretch, a short digest summarizes how often memory was surfaced or captured — at most once per day.
• Share a memory snippet. Copy a formatted “memory card” to the clipboard for docs, standups, or teammates.

v3.0.75 — July 2026

• Your decision history is harder to corrupt or lose. Every writer — the extension, MCP server, CLI, and background jobs — now routes through the same durable journal. Deletes stay deleted, slow saves no longer lose the file lock, and archive operations no longer bypass the source of truth.
• The Synaptic Graph remembers your filters. Saved graph settings (status filter, connection threshold, layout) apply on first open instead of racing the restore message — so what you hid stays hidden.
• Security you can trust under pressure. Credential scans reject symlink escapes, the pre-commit hook inspects what you actually staged, and marketplace builds fail closed when licensing checks are unavailable.
• CLI packaging that works on a clean machine. The bundled continuity command ships with its full dependency tree materialized at pack time, and stale MCP builds are caught before they reach a VSIX.
• Repair inverted cause-and-effect links. New command: continuity repair-causal-edges re-orients causal relationships using timestamps (dry run by default; --apply to write).

v3.0.74 — July 2026

• Your decisions connect to each other again. Continuity suggests how a new decision relates to what you already recorded — supersedes, causes, relates to. On large histories those suggestions had stopped surfacing; they now work across the whole store, so your memory reads as a connected graph instead of a list of isolated entries.
• Relevance scoring you can actually tune. The confidence behind each suggested link is now scored consistently whether or not a pair shares files or tags, so the strictness setting behaves the way it reads — raise it for only the strongest links, lower it for broader coverage.
• Search understands more of what you write. Certain everyday words could cut a search short; queries now expand reliably, so results stay complete.
• The knowledge graph is easier to read. It frames itself to your decisions instead of a handful of outliers, nodes stay visible when zoomed out, and every layout — hierarchical, radial and force-directed — works even when your decisions reference each other in loops. When the view is showing a subset, it tells you.
• Command-line tools match the app. The bundled continuity commands now unlock the same features your installed edition has, so the terminal and the editor no longer disagree about what you can do.

v3.0.72 — July 2026

• Verified end-to-end before it ships. This is the upload-ready build over v3.0.71 — same improvements, re-checked on a clean machine so what you install is what we tested.

v3.0.71 — July 2026

• Your decision history is harder to lose. Deletes stay deleted, archiving marks old decisions without silently undoing itself, and every writer now routes through the same durable journal — closing the last cache-only paths that could drop or resurrect decisions under normal use.
• Extension and MCP agree on your tier from the first session. Fresh installs, trial transitions, and license cache loads no longer leave the assistant thinking you are expired while the UI shows Pro unlocked — or the reverse.
• Memory surfaces when your assistant reads files, not only when it writes. Pre-session hooks and retrieval paths prefer the journal that travels with your repo, so a fresh clone or a read-only command can still inject the decisions tied to the file you are editing.
• Safer commits by default. The secret scan now inspects what you actually staged, not whatever happens to be on disk afterward — closing the path where a staged credential could slip through.
• Synaptic Graph scales better on large histories. Batch link rendering, level-of-detail glow, offscreen culling, and honest node-cap controls make the graph usable on thousand-decision stores without freezing the editor.

v3.0.60 — July 2026

• Your memory is there the moment you clone. Project history now travels with the repository and is found immediately by every Continuity command — including on a teammate's fresh clone, a new machine, or a CI checkout. Terminal-based assistants in particular now see your full history from their first command instead of starting empty.
• Search understands how you actually phrase things. Searching with a natural sentence now finds the decisions that match your words, ranked by relevance, instead of requiring the exact phrase. When nothing matches, Continuity tells you how many decisions it searched, so an empty result is never mistaken for an empty history.
• Everything your commands record, stays recorded. Consolidation, archiving, entity extraction, coverage drafts, scans and team sync all write into your permanent history, so their results persist for good. The extra detail Continuity attaches to each decision as you log it — the technologies and concepts it recognises — is now kept permanently too, making that history richer over time.

v3.0.59 — July 2026

• The Synaptic Graph controls now do what they say. Every filter actually filters: status, minimum connections, tags and node limit all reshape the graph instead of quietly leaving it unchanged. Settings you change stick — no more sliders snapping back on their own — and the panel opens showing your real values rather than placeholders. Connections are traced in both directions, so a decision no longer looks isolated just because its links point inward. When a very large history is trimmed to keep the view readable, the graph now tells you how much it left out instead of silently showing you part of the picture.
• See your memory being used, not just trust it. Your AI assistant is now asked to name the prior decision behind its answer — "per decision-abc123, we chose X because Y" — so when it draws on your history you can see it happen. Previously it announced every decision it saved and said nothing about the ones it read.
• Project memory is findable on a fresh clone. Assistants that work through the terminal are now pointed at the decision record that travels with your repository. On a freshly cloned project they find your full history immediately instead of coming up empty.
• Your assistant stays connected through updates. Editor connections now survive an extension update instead of breaking until reconfigured — a fix that matters most in Cursor, where an update could leave the assistant reporting no connection.

v3.0.56 — July 2026

• Recall got a lot lighter. Search results now stay compact instead of unfolding long lists of loosely-linked decisions — on a large history that is the difference between a few lines and several pages per result. You get the same answer, and your AI assistant keeps far more of its attention for your actual work. Related decisions are still shown, ranked by what matters most, with a count of any extras.
• Cause and effect are recorded the right way round. When Continuity links two decisions as one leading to another, the direction now always follows the timeline — the earlier decision is the cause. Newly created links are correct from here on.
• Suggestions while you work are more relevant. The prompts that surface prior decisions as you edit or run commands now trigger on genuine file matches and prefer your most recent thinking, so they stay useful instead of repeating the same old entries.
• Your history stays put, wherever it is logged. Continued hardening of the durable decision store, so decisions recorded from any tool land in the permanent record and survive pulls, merges, and branch switches.

v3.0.55 — July 2026

• Your decision history stays put. Decisions logged from the command line now persist to the same durable history as the ones logged through your AI assistant, and they survive a pull, a merge, or a branch switch. Automatic commit notes are held to that same standard, so the count you see is the history you keep.
• A rescue command for older histories. If a project logged decisions before this release and some never made it into the durable history, continuity reconcile-decisions finds them and restores them. Run it with --dry-run first to see exactly what it would restore. It only ever adds — anything you deliberately deleted stays deleted.

v3.0.54 — July 2026

• A cleaner git experience. Committing no longer leaves your decision log showing as "changed" after every commit. Auto-captured commit notes are now held aside as gentle reminders and only added to your logged history when you choose — so your working tree stays clean and your decision log stays focused on the decisions you actually keep. A new command lets you accept all the held-aside notes at once whenever you want them.

v3.0.53 — July 2026

• Analytics accuracy refinement. A follow-up to v3.0.52 that further sharpens how Continuity classifies its own usage across tools. No change to your workflow.

v3.0.52 — July 2026

• Under-the-hood reliability & analytics accuracy. Behind-the-scenes refinements to how Continuity measures its own usage, so product metrics stay accurate across every AI tool. No change to your workflow.

v3.0.51 — July 2026

• See your memory working. When your AI assistant pulls past decisions into a session, Continuity now shows a brief notification — plus a running count in the status bar — so the value of your accumulated context is visible instead of happening invisibly in the background.
• Useful from your very first session. Continuity is smarter about turning your project's history into decisions: it surfaces the meaningful architectural changes with real context and skips the noise, so your memory helps on day one — not just after weeks of logging. A new "Re-seed from git history" command refreshes it anytime.
• Consistent across more AI assistants. Your project memory now shows up the same way across a wider range of AI tools — including terminal-based assistants — so switching tools doesn't mean losing context.
• More from the command line. New commands let you inspect your project's memory and tidy up AI-tool connections without opening the editor.
• Continued reliability & security hardening. Ongoing improvements to setup stability and credential screening across every path.

v3.0.39 — July 2026

• Your decisions now travel with your code. Decision history is committed alongside your project, so cloning the repo on a new machine — or handing it to a teammate — brings the full record of why with it. No separate sync, no extra setup.
• Clean merges across branches and machines. When two people (or two machines) record decisions in parallel, the histories now combine automatically — without merge conflicts and without dropping anyone's entries.
• Deletes stay deleted, everywhere. Removing a decision now consistently removes it across every view and every synced copy.
• Works out of the box in existing projects. Continuity now sets your decision history up to be version-controlled automatically on first use, and repairs project settings that would otherwise keep decisions from being tracked.
• Continued security hardening. Credential screening now also runs when decisions are read back, so sensitive values are caught on every path — not just when first written.

v3.0.34 — July 2026

• Decision logging is always free — forever. Capturing your architectural decisions never gets locked. Keep logging across sessions even after your trial ends; the record of why is always yours. Advanced features remain part of Pro.
• Smoother trial & upgrade experience. Clearer, less intrusive messaging around trial status and Pro features.

v3.0.31 — June 2026

• Smoother reconnection after the background service restarts. When Continuity's behind-the-scenes service restarts, connected AI assistants now re-establish their connection automatically instead of getting stuck on a stale session.
• Stable setup across multiple machines. Continuity's AI-tool configuration now settles into a consistent, machine-independent form, so switching between computers no longer causes the setup to flip back and forth.

v3.0.29 — June 2026

• Connection status that always reflects reality. The session context Continuity provides to AI assistants now verifies live tool availability at the moment it is served, so assistants always see an up-to-date picture of what's available and avoid unnecessary fallback behavior.

v3.0.28 — June 2026

• Sharper security screening. Credential detection now scopes AWS-secret matching to genuine AWS contexts, so exporting decisions and ingesting sources work smoothly with any file path on any machine — while real leaked keys are still caught and blocked.

v3.0.27 — June 2026

• Every release is now verified end-to-end before it ships. A new automated release-qualification pass installs Continuity the way a user would and exercises the complete AI-assistant tool surface, the command-line interface, decision storage, and licensing on a clean machine — across macOS, Linux, and Windows. Each update arrives pre-validated against real-world conditions, not just unit tests.

v3.0.25 — June 2026

• Deeper, more capable AI analysis. Continuity's AI-assisted features now use the latest, most capable reasoning models for complex work, with model and cost information kept current.
• Long analyses finish cleanly. Lengthy AI responses now run to completion instead of occasionally cutting off partway through.
• More reliable AI-tool connection by default. New installs connect over a more dependable default, reducing first-run setup friction across editors.
• Continued security hardening. An additional security-review pass with documented follow-ups.

v3.0.23 — June 2026

• Reliable multi-project memory, even with several windows open. When Continuity serves more than one project at once — including setups where it runs as a shared background service — each session now consistently reads and writes the correct project's decision history, closing the last path where a busy multi-project setup could route context to the wrong project.
• Quieter, more dependable background updates. Drift-detection state is now saved reliably when multiple editor sessions are open on the same project, removing a class of repeated background write errors.

v3.0.21 — June 2026

• Drift alerts are now accurate. The "Contradictory Answer Drift" notification was firing constantly as a false positive — flagging every decision that appeared in more than one search result. Drift detection now only triggers on genuine inconsistencies in how the AI cites a specific decision. Dismissed alerts also survive VS Code restarts, so the same warning won't reappear every time you reload.

v3.0.20 — June 2026

• Continuity works correctly across all your projects. When you work in more than one project with a single Continuity installation, decisions and context now always route to the right project — the one you're actually working in. Previously, a long-running session could stay locked to the first project that opened, silently writing to the wrong history.
• Security hardening. AI-generated content displayed in the sidebar and timeline is sanitized before rendering. The MCP server's HTTP transport and shell-command handling have additional protections against injection. Credentials are scrubbed from context and telemetry payloads before they leave your machine.

v3.0.18 — June 2026

Improvements driven directly by field feedback from teams using Continuity in daily AI sessions:

• Honest connection status. Project context responses now reflect the live connection state instead of an older health snapshot — no more "disconnected" warnings inside a clearly working session.
• Session goals always come from the freshest source. When your session notes have just rolled over to a new day, stale goals from an older snapshot no longer appear alongside them.
• Your newest decisions always show up. The project memory file now lists your most recent decisions strictly by date, so the latest work is never pushed out of view.
• Less noise from automatic capture. Auto-captured commit drafts wait in their own review queue instead of crowding your recent decisions, and decisions you've already replaced are marked "ready to archive" rather than nagging for review.
• No more duplicate decisions from imports. Importing decisions from an instructions file now skips anything already in your project memory and reports what was skipped.
• Set several session goals in one step. Updating session notes accepts a list now — no more one-bullet-at-a-time round-trips.
• Decisions logged without tags get smart tags automatically, derived from the technologies and concepts in the decision text, so search and filtering keep working even when tagging is skipped.
• Leaner responses for AI assistants. Context payloads are trimmed (rounded scores, no empty fields, capped lists) so more of the conversation budget goes to your actual work.

v3.0.14 — June 2026

• Decision search finds the right answer for indirectly phrased questions. Asking your assistant something like "is it OK to add quick debug logging here?" now surfaces the relevant past decision instead of returning "no decisions found." In benchmark testing across 141 searches, queries that previously came back empty now return their best matches every time — with the correct decision ranked first.
• Search never strands you on small projects. When a search has no strong match and your project has a modest number of decisions, Continuity returns your full decision history instead of an empty result, so your assistant always has something to work from.
• Setup guides you instead of erroring when no folder is open. Running any Continuity command before opening a folder now shows a friendly prompt with an Open Folder button — previously some commands (including the setup wizard) could show a raw "command not found" error.

v3.0.13 — June 2026

• Smoother session resume. Your recorded decisions and context are now made available to your AI assistant at the start of a session, so you re-explain your project less often.
• File-linked decisions resurface when you work on that file. If a past decision is tied to a file, it's surfaced to your assistant when that file is being changed.
• Optional automatic capture on commit. Commits can be recorded into your project memory automatically.
• Clearer status. Continuity distinguishes "installed" from "active in this session."
• More reliable logging. Decision writes are hardened against duplicates and concurrent edits.

v3.0.11 — June 2026

• Security hardening across the board. A comprehensive security pass strengthened how Continuity handles untrusted content, protects your local decision history and license, and gates automated actions — safer by default.
• Updated dependencies. Refreshed bundled libraries to pick up the latest upstream security and stability fixes.
• Reliability improvements. Quality and test-coverage work behind the scenes for a more dependable experience.

v3.0.10 — May 2026

• Edit the tags on an existing decision. You can now refine how a past decision is categorized without re-creating it — handy for cleaning up or reorganizing your decision history by topic.
• Decisions logged right after a commit reach your task board. When you've connected Jira, Linear, or GitHub Issues, decisions you capture immediately after committing now flow through to the board as expected.
• Leaner project memory file. The project context file your AI assistant loads at the start of each session is now more concise and focused — it loads faster and spends less of the conversation budget on boilerplate.
• More consistent decision tagging. Tags are normalized predictably (case-folded and de-duplicated) so searching and filtering your decisions by topic behaves the same every time.

v3.0.9 — May 2026

• Internal telemetry improvements. No user-facing changes since v3.0.8. This release adds a property to one analytics event so the team can see which AI clients are exercising Continuity in aggregate, helping us prioritize auto-configuration coverage and detection fixes.

v3.0.8 — May 2026

• Your AI assistant connects automatically on install. Continuity detects Claude Code, Cursor, Cline, Roo Code, OpenAI Codex, Gemini CLI, and GitHub Copilot on your machine, then wires up the connection silently — install Continuity, open your AI tool, and the memory layer is already connected. No command palette step, no manual config edit. The AI can call Continuity's memory tools from session one.
• New AI client support: Cline and Roo Code. Both are now auto-detected alongside the existing roster of supported clients.

v3.0.7 — May 2026

• More reliable Setup MCP for HTTP-mode users. If you've opted into the optional HTTP daemon transport, the Setup MCP wizard now writes correctly-discriminated configuration entries for Claude Code, Claude Desktop, Cursor, Gemini CLI, and Antigravity. Stdio mode (the default for almost every install) was never affected.
• Clearer guidance for AI assistants on where project decisions go. The auto-generated project instructions now explicitly tell AI assistants to route project-scoped decisions (architecture, tradeoffs, "we chose X because Y") through continuity log rather than the assistant's private session memory. Cross-project context like user preferences and environment quirks still belongs in private memory, but project decisions belong in Continuity where teammates and other AI tools can see them.

v3.0.6 — May 2026

• Marketplace listing cleanup. README streamlined for clarity — plain text headers, simpler bullets, no decorative glyphs. No functional changes from v3.0.5; the credential-safety improvements and Pro launch shipped in earlier 3.0.x releases.

v3.0.5 — May 2026

Credential safety across the AI workflow. Credential-shaped values that show up in your assistant's context, in conversation memory, in persisted decisions, or in scanned file content are redacted before they leave the boundary or hit disk. Coverage includes Atlassian, GitHub, GitLab, OpenAI, Anthropic, Slack, AWS, Google, Stripe, Twilio, SendGrid, Mailgun, NVIDIA, Perplexity, JSON Web Tokens, private-key blocks, and NAME=VALUE environment-style assignments.

• OS keychain for tracker credentials. continuity tracker connect <provider> now stores Jira / Linear / GitHub Issues tokens in your OS keychain (macOS Keychain, Windows Credential Manager, Linux libsecret) instead of a plaintext file. Existing setups keep working; new connects show [keychain] or [file] so you can see which backend handled it.
• New: continuity credentials migrate. Scans .env, .env.local, and the existing tracker credentials file for credential-shaped values, reports what would move to the keychain, and — with --apply — actually migrates them. Originals are saved as .backup files first. Companion commands: continuity credentials list and continuity credentials clear.
• Redaction across input, output, and persistence. Credentials that appear in tool arguments, model output, persisted decisions / notes / memory, or tool result content are replaced with structured <REDACTED:…> markers. Sub-5 ms on typical payloads, idempotent, and resistant to false positives on UUIDs and hashes.
• One-click audit of existing memory. A new audit surfaces credential hits in your existing decision history and session notes, so anything written before this release can be reviewed and cleaned up.

v3.0.4 — May 2026

• "Test MCP server" reports a meaningful result in both transport modes. The diagnostic button in the Continuity sidebar detects which transport mode you're using and reports the appropriate health check: a list of configured AI clients in stdio mode, or the daemon health probe in HTTP mode.

v3.0.3 — May 2026

• Claude Code CLI is set up on fresh installs. Setup MCP creates the Claude Code CLI config when needed, so brand-new Claude Code users on Windows and elsewhere have Continuity wired up immediately after first install.

v3.0.2 — May 2026

• Setup MCP shows per-tool results. After running Setup MCP from the Continuity Setup Wizard, the notification lists each AI tool individually (Claude Desktop, Cursor, Claude CLI, GitHub Copilot, Gemini CLI, Antigravity, Codex) with its configuration status, so you can see exactly what was configured.

v3.0.1 — May 2026

• Windows install reliability. Fixed an issue where Setup MCP could fail on Windows with a permission error when trying to install the bundled CLI launcher. The launcher now installs to a user-writable location and never tries to write into protected system directories.

v3.0.0 — May 2026

Continuity 3.0 — the paid-Pro launch.

After a long beta, we're moving Continuity into a sustainable paid model. A 14-day Pro trial still ships with every install — full access, every feature, no credit card. When the trial ends, your workspace stays usable in read-only mode (search, view, export everything you've already logged), and a Pro license unlocks writing again.

• All Pro features included in trial. The 14-day trial gives you the same experience as a Pro user: unlimited decisions, semantic search, knowledge graph, code intelligence, native Jira / Linear / GitHub Issues integrations, MCP server, and the full CLI.
• Read-only mode after trial. Your data doesn't disappear when the trial ends. Search, list, and export keep working. New decisions, edits, and integrations require a Pro license.
• Pro pricing. $9/month, $89/year, or $199 lifetime. Activate at app.hackerware.com/pricing.
• Existing trial users: if your trial has already ended on a previous version, this update will move you into read-only mode. Your decisions remain searchable while you decide whether to upgrade.

v2.20.125 — May 2026

• CLI now fires native trackers. continuity log, task, and note push to Jira / Linear / GitHub Issues directly when you've connected credentials — no middleware required. Manage credentials with continuity tracker connect <provider>, tracker list, and tracker disconnect. Tokens live in ~/.continuity/credentials.json with 0600 permissions. CLI-only users now have full parity with the Settings → Integrations panel.
• Comments on existing tickets. continuity note --ticket CO-12 "..." adds a comment to the linked Jira / Linear / GitHub issue. The working ticket is auto-detected from feature/co-12-... branch names or set explicitly via continuity working CO-12.
• Brand font rolled out. Sidebar webview now ships JetBrains Mono via bundled @font-face, ensuring the brand-correct mono rendering everywhere — no system-font dependency.
• Reliability fix for MCP decision logging. Resolved an intermittent issue where logging could fail even with a connected MCP server.

v2.20.122 — May 2026

• Tagline restored. Marketplace subtitle reverted to "Memory that belongs to your code — not your model." No code changes from v2.20.121.

v2.20.121 — May 2026

• Documentation refresh. Release notes streamlined for clarity. No code changes from v2.20.120.

v2.20.120 — May 2026

• Calendar view on the Decisions tab. A month-grid calendar at the top of the panel makes it easier to navigate large decision logs. Days with decisions show a count; click any day to filter the list below.
• Welcome panel telemetry. First-run experience now correctly measures how often users complete setup.

v2.20.117 — May 2026

• Native GitHub Issues integration (Pro). A new Connect GitHub Issues wizard joins Connect Jira and Connect Linear — paste a token, pick a repo, optional default labels, and decisions automatically become issues. No middleware required.
• Disconnect actually disconnects. Native-tracker Disconnect buttons (Jira / Linear / GitHub Issues) now use a proper VS Code modal and clear all state on confirm.
• Google Gemini provider. The Gemini option in the AI Provider dropdown is now fully wired, with a Test connection button to verify your setup end-to-end.
• Settings panel polish. Test connection buttons for AI Provider, MCP daemon, and license server. Section descriptions moved to themed hover tooltips for a cleaner panel.
• Native tracker hardening. Better Jira issue type inference, support for team-managed projects, auto-mapping after Load projects, and decisions auto-transition to Done.

v2.20.98 — May 2026

• continuity webhook CLI command. Configure generic-URL webhook fanout (n8n, Zapier, Make, custom endpoints) from the command line — add / list / remove / test subcommands.

---

Credential Safety

Continuity reduces accidental credential leakage in AI-assisted coding workflows. Credential-shaped values that appear in tool arguments, model output, persisted decisions and notes, or tool result content are redacted before crossing system boundaries.

• 27 provider formats covered — Atlassian, GitHub (full PAT family), GitLab, OpenAI, Anthropic, AWS, Google, Stripe, Slack, Twilio, SendGrid, Mailgun, NVIDIA, Perplexity, JSON Web Tokens, PEM private keys, and env-style NAME=VALUE assignments. Plus a tunable entropy fallback for unknown formats.
• Tracker credentials in the OS keychain — continuity tracker connect <provider> writes Jira / Linear / GitHub Issues tokens to your OS keychain (macOS Keychain, Windows Credential Manager, Linux libsecret) with a file fallback when the keychain is unavailable. Run continuity credentials migrate (dry-run by default) to move any existing plaintext tokens.
• Audit existing memory — the audit_secrets command surfaces credential-shaped strings in your existing decision history so anything written before this release can be reviewed and cleaned up.
• Scope: accidental, not adversarial — this is a hygiene-and-defense-in-depth layer. It reduces the probability of credentials accidentally ending up in long-lived memory. It is not a guarantee, and deliberately-obfuscated credentials, semantic references (e.g. "the production AWS key"), and prompt-injection payloads stored in memory remain open problems. See SECURITY.md for the full scope and threat model.
• Verification report — March 2026 remediation verification plus periodic re-reviews (latest: July 2026, commit 75107b2b). See docs/security/SECURITY_VERIFICATION_REPORT.md for line-level findings, scope limits, and dependency triage (including protobufjs disposition).

Privacy

• Your decision memory stays in your repo — decisions, sources, and session notes live in .continuity/ in your workspace. Commit that folder to share with your team; Continuity does not host or sync a central decision cloud.
• Optional anonymous usage analytics — enabled by default; sends event names, a hashed device ID, and license tier only (never decision text, file paths, code, email, or names). Disable anytime: VS Code Settings → continuity.analytics.enabled: false.
• Integrations you configure — webhooks, Jira/Linear/GitHub Issues, and optional AI features (semantic search, auto-log, quality scoring) may call endpoints or providers you set up. Cost/savings estimates are computed locally.
• License validation — marketplace Pro builds contact Hackerware to validate licenses; trial state is stored locally.
• Tracker tokens stored in the OS keychain — Jira / Linear / GitHub Issues credentials use the platform keychain by default (file fallback only when keychain is unavailable, with 0600 permissions).

---

Support

• Issues: GitHub
• Email: support@hackerware.com
• Website: hackerware.com