Most surfaces, one walkthrough.

Download for Windows, run the installer, point at your first repo. A one-time, free sign-in, then works fully offline.

How the in-app auto-update works, the manual override, and recovering from a blocked update.

The person-owned brain that follows you across every AI tool, your repos, and your life. Ask it locally, connect it to Claude Desktop / Cursor / ChatGPT via MCP, read it from any app with a scoped token, open it in Obsidian, share a slice.

Invited to a team? Accept, install the desktop app, bind it, and turn on streaming, in one walkthrough for the invited member.

Know what to do next. Spend, ship-readiness, vulnerabilities, brain pulse: the one tab to open each morning.

Triage-first alerts ranked by blast radius. Capped, quiet, and suppressed when a lesson already covers it.

Universal cross-repo file index. Substring search across paths and titles.

The queued and running actions across your repos, with status and one-click open.

Every multi-step workflow run, its slices, and where each one landed.

The /team landing: connected devices, invites, budget alerts, server-owned policy.

The hosted /dashboard view: what stays in the cloud, what stays on each laptop.

Your standing situation report. One signal hub for spend, ship-readiness, the queue, and what your next session will load.

Everything your AI built, following you across repos, sessions, and machines.

The left end of every loop: what a loop is declared to do, before it runs, joined straight to its outcomes.

Live agent sessions in flight, updated as they run.

Your app tells you why it is slow, before you have to ask. Own-runtime health, opt-in terminal capture, and a hosted fleet view of which installs are flapping.

Drill into one Claude Code run: a cost-weighted span waterfall from session to turn to tool.

The chain from prompt to edit to result, reconstructed for any change.

The filterable PR index across every tracked repo. The conversation record, indexed.

End-of-session journal entries: what got built, what is next, what slowed us down.

On-demand plain-language summaries of any repo you track.

The RepoOps Signal Layer: the raw detections that feed every higher surface.

Non-destructive rewind: snapshot the working tree on demand, restore any prior state without a commit or moving HEAD.

Your organization GitHub repositories, inventoried from the RepoOps GitHub App.

The live health of your team always-on RepoOps capture daemon across every bound device.

Know it will not ship broken. Trust boundaries, BYOK, threat model, plus a live footgun scan.

What each agent and tool is allowed to touch, and where the boundaries sit.

The reach of a change before you ship it: what it touches, what it could break.

The declared read and write scope for each surface, enforced at the boundary.

Runs the same checks CI would, in about 90 seconds, before the PR opens.

Review a diff line by line: brain decision rules, security checks, and blast radius on the changed hunks.

Env-var registry: which file reads what, plus the Doctor's plain-language footgun checks.

Production alerts auto-correlated to the change and the AI session that likely caused them.

The hosted Guard and Manage controls for the team.

A guided go-live preflight plus deploy and domain runbooks.

A read-only advisory-control posture across every inventoried repo.

Arm or disarm the advisory controls RepoOps can apply, per repository.

The tenant-scoped service-connector vault.

The proof-of-work record: what shipped, tied back to the intent that asked for it.

Five cheaper-loop plays read back to you, each with the findings that tripped it and the dollars it bleeds. See the waste before the invoice does.

A ranked, plain-English story per loop: a session shipped a PR, it introduced a defect, and a lesson now guards it.

Close the loop on your coding agents so the loops you run improve instead of just running.

One supervisor dashboard for the architect overseeing an autonomous agent fleet.

The public verification page: paste an attestation, get an independent yes or no.

Know what it cost. Combined-mode Claude Code telemetry across every tracked repo.

Per-session token spend with heuristic and LLM-driven recommendations on where to save.

Per-developer session timing, prompt cadence, tools, files. The contractor-governance surface.

The full archive of captured user prompts. Declared intent, read back: search what your team actually asked their AI.

Per-client invoice export with proof-of-work line items.

Full session transcripts, searchable turn by turn.

Edit each repo's tier mappings and open a PR with the change.

Production LLM telemetry: by-tier, by-surface, hot prompts, real Anthropic billing.

The full model: revenue, cost of goods, margin floors, and the levers that move them.

A composite Spend-Efficiency grade over six levers: defaults, routing, caching, context, visibility, ROI.

Vendor spend plus pricing model. The aggregated economic view.

Cross-developer activity ledger with integrity proofs. Per-binding drill-down.

Team vendor spend and budget alerts.

The hosted Today, Watch, and Spend rollups in one place.

A CFO and CEO rollup: spend, prevented incidents, ROI, and a 30-day trend.

A PM rollup: ship-rate, deploy frequency, and median time-to-merge.

Last night's lesson proposals: review, accept, reject. The reason your second project goes faster.

Ask your brain a question in plain language and get an answer grounded in your own notes.

One read surface over what the team knows, what it learned this week, what it prevented, and who is working on what.

The active lesson store. Every accepted lesson regenerates into CLAUDE.md and AGENTS.md on next run.

The ADR log: every architectural call with the reasoning. The receipts behind the code.

The error-learning loop: what broke, what fixed it, what rule prevents it next time.

Unresolved architectural questions, each with the event that triggered it.

Named, reusable recipes: moves your team makes on purpose, plus the anti-patterns you avoid.

The domain vocabulary specific to this project, plus the terms you deliberately do not use.

The freshness and coverage of your brain: what is decaying, what is missing.

The cross-reference web between brain entries, and the links worth adding.

Brain references that point at moved, renamed, or deleted targets, flagged for repair.

The memory that captures itself as you work, no manual note-taking required.

Force-directed graph of brain cross-references. Node size scales with influence.

Draft end-of-session entries generated from the work, ready to review and keep.

A PR description drafted from the diff and the session, ready to edit.

Your skill trajectory: what you are getting better at, and the next thing to learn.

When and where the work happens, as a calendar heatmap.

What your loops produced, measured and read back to you.

Post a number that actually means something. Generated locally, downloaded on click.

Surfaces the workflows you actually repeat and turns the top one into a skill file.

Cross-repo pattern library: what is shared across 2 or more repos, what is worth promoting.

The brain pulse rolled up across every connected developer.

The hosted brain read surfaces and what each one exposes.

The team quality score and how it is computed.

Coaching signals rolled up across the team.

Brain freshness and coverage across the team.

Your brain is already a valid Obsidian vault. Point Obsidian at it, install Dataview, get a graph view plus live dashboards. Edits flow back through the write-trust guard.

Mint a scoped, revocable read token and read a slice of your brain from any external property. Copy-paste REST and JS snippets plus a Google Sheets Apps Script template.

A context-health score from 0 to 100 over the rule engine health surface.

An auto-generated descriptive wiki over your repo source.

A voice interface: record a question and get a transcript.

Add or remove tracked repos at runtime. Manage clients, accounts, BYOK keys, telemetry privacy.

Every privileged action, who did it, and when. The tamper-evident record.

The local-first cryptographic governance surface: ledger verification, redaction posture, policy, file integrity.

The curated, reusable prompt library for the team. Distinct from the captured-prompts archive under Spend.

The portable brain plus skills plus docs prompt. Port this setup to any repo in one paste.

The full gold-standard repo setup prompt: every convention this project has earned.

The four-step install for the brain dashboard in any repo.

The hosted admin surface: members, roles, org policy.

The hosted, tamper-evident audit log for the team.

Team governance: policy, controls, and enforcement.

Team share links and their scopes.

How team licenses work, how billing rolls up, what happens if a license lapses.

Account settings: invites, role management, the linking-code flow for bound devices.

A one-shot launch-readiness audit prompt you can run against any repo.

The admin console: seats, subscription, members, policy, governance, and budget.

Configure single sign-on with your SAML 2.0 identity provider.

Create revocable read-only links to the team rollup.

Privacy-respecting, team-scoped aggregate counts of which hosted tabs your team visits.

The map of routes, modules, flows, and entry points, for when you or your AI need to find the right file.

Every file and folder with a single line of purpose. The fastest way to onboard a codebase.

Every route, page, and endpoint with shipped-or-planned status.

The feature index: what shipped, what is planned, what is deferred.

The canonical HTTP API contract: every endpoint, method, auth, request, response.

Every database model, column, index, and foreign key, paired with the migration that created it.

Suite reference: runners, fixtures, CI jobs, coverage.

Every external vendor: env vars, install steps, failure modes, monthly cost.

Build and pipeline deps: what each is, risk profile, compromise scenario, patch path.

One searchable index over every brain and docs reference for this repo.

Crons, hooks, background jobs: what runs without you, when, and what proves it ran.

The design system: tokens, type, motion, light and dark.

The running log of design decisions and their rationale.

The component registry: every reusable variant, what uses it, and the boundaries.

The canonical verb spine and what each verb owns across the product.

Phases, progress bars, the track filter. The single source of truth for what is shipped vs. queued.

The pillars, moats, and positioning: what RepoOps is for, what it is not, what is the moat.

Concrete users behind each label: Vince (solo vibe coder), Eli (eng manager), Andy (agency owner).

What we watch, what counts as a bad signal, and the thresholds that trigger action.

Parked ideas: what has been considered and consciously deferred.

The registry of every shipped docs page plus walkthrough video.

The brain index: the map every session reads first.

The four principles that keep AI-written code disciplined.

Think before coding, simplicity first, surgical changes, goal-driven execution.

Bring your own embedding key: how vector indexing uses it and the fallback when it is missing.

How outbound email meets compliance: unsubscribe, sender identity, and rate rules.

A flat index of every dashboard tab and the doc that covers it.

The hosted reference index for the team scope.

A read-only catalog of the Claude Code dev-time toolkit across your tracked repos.

Many brains working the same problem at once, with shared context.

A shareable, public, read-only slice of a brain.

A society of brains that teach each other across repos and people.

The brain and skill marketplace: what you can publish, what you can install.

Who can read and write each brain slice, and the write-trust guard behind it.

What lives in hosted Labs and what stays desktop-only.

A live feed of pattern detections across repos, tenants, and query gaps.

An append-only signed log of every cross-* event.

One control panel for every cross-* axis: session, repo, tenant, and realtime.

A 30-day leaderboard of cross-* activity per axis.