2026-07-18moat
See any codebase as a map — from one prompt, no account
New on-ramp at /scan/try: copy a prompt into your own coding agent (Claude Code, Cursor, anything that can read your repo), paste back the JSON it returns, and your codebase renders as an interactive map right in the browser. Your source never leaves your machine — the agent reads it locally and sends only the structure. Like what you see? Create a shareable link and send it around. It's clearly labelled an AI-generated preview, distinct from the deterministic scan your synced projects get. And `npx @secondos/scan` now runs the same scan from anywhere.
2026-07-18moat
A clearer, more honest map — plus a plain-language read of what powers it
The codebase map got a big upgrade. A line up top now says what a project runs on in plain words — "takes payments through Stripe, keeps data in Postgres, stores files in S3, and caches with Redis" — and every part reads as what it does, with recognizable services shown by purpose instead of a wall of package names. Click an entry point to trace a real flow through the map, arrow by arrow. We also simplified the board (calm connections, name-first cards) and stopped drawing edges the graph wasn't sure of, so a trace never claims a connection that isn't really there. Optionally, `secondos scan --narrate` renames each part in plain feature language.
2026-07-18feature
Your AI sessions can become memory, scoped to the right project
SecondOS can now passively read your local AI coding sessions (Claude Code, Codex, Cursor) and distil the durable decisions from them into reviewable memory, scoped to the exact project each one belongs to. Opt-in: nothing runs until you enable it, and it uploads only a bounded, decision-dense slice of the right repo's turns, never the whole transcript and never your reasoning or tool output. Install a session-end hook and it captures automatically as you finish working, or run it by hand for one session at a time. Every captured note carries where it came from, so recall shows 'from Cursor' or 'from Claude Code' right next to it.
2026-07-18feature
Capture a whole session, and let the decisions that changed win
Long conversations move: a choice made early gets reversed later, or quietly reaffirmed. Full-session capture reads the entire conversation, not just the last few minutes, and folds it so the final decision wins instead of leaving you a pile of contradictions. What you actually settled on is what gets remembered.
2026-07-18feature
Your memory can now record itself, with a one-click undo
Turn on auto-accept and a decision that survives SecondOS's quality checks becomes an active memory directly, instead of waiting in a review queue. It stays honest the same way everything else does: a memory goes stale when the code it describes changes, contradictions supersede each other, and there is always a one-click undo. A new Recently recorded view shows what SecondOS wrote for you while you worked, so you can glance and correct anything. Opt-in and off by default.
2026-07-13moat
Publish a read-only link to your project's living knowledge
You can now share a project's living knowledge, the map-derived docs and the decisions behind them, as a public read-only link anyone can read without an account. It never includes your source code, it is opt-in and off by default, and a disabled link simply returns not-found so nothing leaks. Your codebase's memory, readable by your team or the world, entirely on your terms.
2026-07-12moat
The upkeep that keeps your memory living is on us, not your credits
The background work that keeps your memory current, distilling decisions, refreshing living docs, and the embeddings behind them, no longer counts against your monthly credits. Your allowance is for your own queries. The automation that makes SecondOS a living system rather than a static file is ours to run, so your credits stretch a lot further than the raw activity suggests.
2026-07-12feature
Your issues and PRs become memory, bound to the code they touched
SecondOS can now read a linked repo's recent issue and pull-request discussions and distil the durable decisions argued out in them into reviewable memory proposals. Opt-in and manual: it is never wired into a sync, it reads discussion text only (never your source, never a diff), and it writes nothing back to GitHub. A PR-sourced memory binds to the file the PR touched and carries its origin, so recall shows `from #128` next to the note with a link straight back to the thread. The same drift that ages any memory applies here: move the code the decision was about and the issue-sourced note goes stale instead of quietly misleading your next agent. Pro, real-model only, human-accepted in the Memories inbox.
2026-07-10moat
The client is source-available: read the code, check our claims
Everything that runs on your machine (the CLI, the MCP server, the ingest, graph, embed and memory packages) is published as a source-available mirror at github.com/Preatan/secondos-client. Our data-handling promises are only as good as your ability to check them, so this is the check: the line that drops a code body before upload, the value-level redaction pass, the secret skip-list, the fully local mode, all readable for yourself. The companion docs/DATA-HANDLING.md walks the exact source lines and says the uncomfortable part out loud too: your prose docs and manifests upload as full text, not as a map. Trust you can verify beats trust you are asked for.
2026-07-10feature
Living docs are now readable by any AI tool
The self-maintaining knowledge base already lived in the web app; now every AI tool can pull it over MCP. A new read_living_doc tool serves the map-derived architecture, overview, onboarding, module and API docs straight into the agent, so it reads the structure someone already wrote down instead of re-deriving it from scratch. Read-only and free. It serves only the already-generated, map-derived prose, so the K‑S23 boundary holds: your source is never the input.
2026-07-10feature
Start from a repo in the browser, connect a tool in one click
Onboarding lost its CLI wall. The empty state now creates a project straight from a GitHub repo in the browser, with install and config that adapt to your OS (macOS, Windows, Linux). Connecting an editor got a one-click path too: deep-link buttons wire the local MCP server into Cursor and VS Code with no hand-edited JSON and no restart. The other editors keep the copy-paste config, and the remote-MCP token deliberately has no one-click link, because a deep link would carry the token through browser history where it leaks.
2026-07-09feature
Your credit standing, visible in the app
The credit model now has a face. A usage widget shows context credits remaining and storage used at a glance, and settings carries a full credit-status banner with your balance, the rolling five-hour ceiling, and a top-up or upgrade path when you get close. The plan is unchanged and stated plainly: Free includes 50,000 context credits, Pro is $10 a workspace for 500,000, and a $5 top-up adds 250,000 that never expire. Credits are metered and recorded on every operation today; the hard block is one flag away (SECONDOS_CREDIT_MODE=enforce), so the surface is ready before the meter becomes the gate.
2026-07-09feature
The Living Knowledge Base — a second brain for your codebase
Living docs grew from one ARCHITECTURE.md into a self-maintaining family of eleven documents: overview, architecture, modules (per-module, with dependencies, routes and tables), a module dependency map, an API reference, the data model, the team's knowledge (decisions, conventions, gotchas), a learnings log, onboarding, recent changes, and a glossary. Bring a project in and the applicable docs write themselves; every push refreshes them incrementally (only the sections whose map or memory changed). They're written from the structural map — the call/import graph, routes and DB schema included, things no other tool can auto-document — never your source (K‑S23). Big modules break into sensible sub-modules. Your docs stop rotting, and you maintain nothing.
2026-07-08moat
Living docs: a human ARCHITECTURE.md that maintains itself
secondos docs writes a readable ARCHITECTURE.md for your repo from its structural map plus your accepted memories — grounded in structure, never your source (K‑S23). The part that matters: on a refresh it re-writes only the sections whose underlying map changed and leaves every untouched section byte-identical, so the doc stays current instead of rotting — at almost no cost. Written by the CLI (or your CI) where the code lives; the App still can't read or commit to your repo.
2026-07-08engine
Our own benchmark, in the open
A dedicated benchmark for structure-aware codebase memory, measured on five real repos: ~5–9× fewer tokens per question, a map that stays bounded regardless of repo size, code-search precision@1 100% and memory-recall MRR 0.96 — with the scripts to reproduce it on your own repo. We define the benchmark for the thing we actually do, rather than borrowing a conversational-memory one built for a different job.
2026-07-07feature
The relationship graph now spans seven languages
PHP and Ruby graduate from symbols-only to the full call graph. who_uses (callers) and impact_of (blast radius) now resolve cross-module in seven languages — TypeScript, JavaScript, Go, Python, Rust, Java and PHP, plus Ruby — each with a bespoke extractor and per-language resolution, not a symbol grep. Ask who calls a function or what a change will break and the answer holds across files and packages in all seven. Kotlin, C, C++, C# and Swift stay detected and searchable.
2026-07-07feature
Sign in with GitHub
Log in to the web app with your GitHub account in one click, no inbox round-trip. It signs you in only; connecting a repo is still a separate, explicit step with its own zero-code-read permissions.
2026-07-07feature
Remote MCP: connect a hosted agent
Hosted agents that can't spawn a local process — a claude.ai custom connector, ChatGPT, any MCP-over-HTTP client — can now reach your project over a hosted /mcp endpoint. Mint a project-scoped Bearer token from Integrations, paste it into the agent's connector, and it reads the same map and memory as your editor. The token is shown once, is bound to a single project, carries only the read and memory tools, and revokes instantly.
2026-07-06moat
Local memory mode: fully offline, on your machine
Keep memory entirely on-machine. remember and recall now read and write a plain .secondos/memories.json in your repo — no account, no network, versioned in git if you want it. The cloud is optional: start local, and push the same notes up later when you want them shared or read over remote MCP. Your notes, in a file you own, the same way your source already is.
2026-07-06engine
secondos init and watch: one-command setup, auto-resync
secondos init walks you from an empty repo to a synced map and a wired-up editor in a single command — detect the project, build the first map, print the MCP config. secondos watch then keeps it current: it re-extracts changed files as you save, so the map stays fresh in the background without a manual push. Onboarding is now one line; freshness is now nothing.
2026-07-06moat
who_uses and impact_of now resolve across five languages
The relationship graph grew beyond JavaScript. who_uses (callers) and impact_of (blast radius) now resolve cross-module in TypeScript, JavaScript, Go, Python, Rust and Java — bespoke extractors with per-language call resolution, not a symbol grep. Ask who calls a function or what a change will break and the answer holds across files and packages. PHP and Ruby get a symbol map and search today; Kotlin, C, C++, C# and Swift are detected and searchable.
2026-07-06feature
Drift detection, now on three axes
Drift widened from schema to three read-only checks: your code against the Drizzle schema, the environment variables your code reads against .env.example, and the packages you import against package.json. Each flags the undeclared and the likely-unused, with both locations, so the mismatch surfaces before it ships. Still read-only — it alerts, it never changes anything.
2026-07-06feature
Connect GitHub in one click
Connect a repo from the web app with one click. The GitHub App requests no code-read permission — it lists your repos and triggers your own CI to rebuild the map on every push. Your source stays inside your CI boundary; the App literally cannot read it, and the map stays fresh without a manual re-sync.
2026-07-06moat
One command prints your MCP config
secondos mcp-config prints the ready-to-paste MCP configuration for Cursor, Claude Code, Claude Desktop, Windsurf and VS Code. Copy it into your editor's settings and the SecondOS server is wired up — no hand-writing JSON, no guessing the command.
2026-07-05feature
The CLI ships on npm
Run bunx @secondos/cli push . at the root of any repo — no clone, no build step — and you have a structure-aware map on your machine. Every command runs from the same package: push, ask, drift, mcp-config and init-github-action.
2026-07-05feature
Every memory carries a trust score
One 0..1 number per note, folded from signals we already track: anchored to real code lifts it, stale or aging sinks it, and notes your agents actually reuse earn trust. Recall, list and MCP all surface it, so a caller knows what to lean on and what to double-check.
2026-07-05engine
Validity windows: a memory can expire with a version
A note can now carry an explicit validFrom / validTo, so “this was true in v1.2” stays queryable and out-of-window memory is down-weighted in recall instead of deleted. Hard windows complement the soft temporal decay already in place.
2026-07-05feature
Conflict detection: divergent notes flagged, not stacked
Within the same scope, notes that are about the same thing but disagree are surfaced as review candidates — by embedding distance alone, no model required. Connect a completer and it upgrades to a real contradiction check that proposes which note supersedes which.
2026-07-03moat
Assisted distillation: SecondOS proposes durable memories
After a sync, SecondOS reads the map diff and recent decisions and proposes memories you accept or reject — assisted, never auto-written, and map-only so it never touches your source. Proposals need a connected model; without one it degrades quietly to no proposals.
2026-07-02engine
Memory graph: browse memory ↔ code, colored by trust
A navigable view of how notes attach to real symbols, tinted by trust and validity so stale, low-confidence memory is visible at a glance. The memory finally has a map of its own.
2026-07-02feature
Org memory: conventions that span every repo
A workspace-scoped memory that isn't bound to one project — shared conventions that fold into recall across every repo in the workspace. One home for the rules your whole team keeps re-explaining, project after project.
2026-07-01moat
Team sharing: invite teammates to the map and memory
Invite people into a project with roles; they read the same structure-aware map and memory you do. Sharing covers the map and the notes — never your source, which still never leaves the machine that synced it.
2026-07-01engine
@-mention grounding with numbered citations
Pull an exact symbol into a question with @, and answers cite the precise source lines they leaned on, numbered. Grounded in the map, and traceable straight back to where it came from.
2026-07-01engine
Expanded MCP toolset: memory hygiene tools
The MCP surface grew memory-hygiene tools — history, restore, reconcile — alongside remember and recall, so an agent can curate its own notes without leaving the tool it works in.