Galileo already tells you which page in your documentation is lying — and points at the exact block as proof. Connect GitHub and Notion, and within minutes you get Findings: a stale page, two Sources that contradict each other, a doc that names a function the code deleted two quarters ago. Each one carries an Evidence trail back to the exact Source and location it came from.

That is the wedge. The next chapter is about what happens after the Finding: turning "this doc lies" into "this doc is fixed, and the fix stuck." Here is where Galileo is headed, and the one rule that orders all of it.

Where Galileo is today

Two Connectors ship today — GitHub (App install) and Notion (OAuth workspace). Authorize a Connection, create a scoped Source, and Galileo Syncs it into a provenance-tracked knowledge graph. Pull Sources never hold your provider tokens.

Over that graph, two cross-source detectors run. Stale documentation is judged deterministically over Evidence — timestamps, materiality, and now doc↔code drift. Conflicting claims uses an LLM to propose grounded contradictions between two Sources, and deterministic rules to pass judgment. An LLM never opens, sustains, or resolves a Finding on its own — because a product whose promise is "your docs lie, here's the proof" cannot afford a verdict that hallucinates.

The most recent thing to land is the code-aware graph: Galileo now extracts public code symbols from your Elixir and TypeScript/JS, links docs to the symbols they name, and opens a stale-documentation Finding when a doc still references a function that no longer exists. "This doc names a symbol the code deleted" is now a Finding with proof, not a feeling.

The rule that orders everything: sharpen the wedge before widening the surface

Every step must sharpen the wedge — Findings over cross-source knowledge — before it widens the surface. More detectors before more connectors; depth of judgment over breadth of Sources.

Galileo roadmap, sequencing principle

It would be easy to chase a logo wall of connectors. We're not going to. A connector only earns its slot by feeding the detectors more Evidence per Concept. Depth compounds; breadth doesn't. That's why the committed work below deepens the two Sources we already have — and makes Findings actionable — before any new Source type lands.

Next: committed, in order

No dates — the ordering is the commitment. This is what we build next, and why each item earns its place.

1. Close the resolution loop

A Finding should be a task someone finishes, not a dashboard row someone admires. So the Findings page graduates from a read-only report into a work surface: human triage — acknowledge, snooze, dismiss-with-reason — layered as annotations over the deterministic lifecycle, never overrides. Open, resolve, and reopen stay judged by Evidence.

One click creates an issue (GitHub first; Linear when its Connector lands) with the Evidence trail embedded — and it's a two-way link: when the Finding resolves or reopens, its issue gets commented and closed or reopened to match. Finding alerts ride the existing notification system (in-app and email first; Slack and Google Chat as they land), so a new Finding reaches the team where it already talks. This is the item that most directly moves Finding resolution rate, which is exactly why it leads.

2–4. Deeper Sources, before new ones

• Incremental GitHub markdown Sync — drive re-Sync from commit diffs so large docs/ trees stay cheap to keep fresh, multiplying eligible detector subjects without blowing Sync cost.
• Notion sync scoping — databases as first-class roots and richer exclude rules, so Findings come from the team's real knowledge base, not from meeting notes and archives.
• Source labels in the graph explorer — browse the graph the same way you already filter Sources, Findings, and the dashboard, so a multi-product Org can slice by label everywhere.

5. Tribal-knowledge detector (coming soon)

The knowledge that exists only in conversations and people — never in the docs — is where bus-factor risk hides. A third Finding kind will make it visible and fixable before the one person who knows it leaves. It compounds on the same graph and the same open/resolve lifecycle as the detectors that ship today: a new detector, not a new pipeline.

6. Linear Connector (coming soon)

The one new Source in the committed list — and it's pulled forward by demand, not a connector count. Tickets bring richer Evidence into the graph (what was decided, when, and by whom), and Linear gives the resolution loop a second tracker to file into. It earns its slot by making judgment sharper, not by growing a logo wall.

Later: directional, sequenced after the wedge

• Grounded remediation — the Finding drafts its own fix. An LLM reads what the deterministic layer already proved (the Finding, its Evidence, and the live content on both sides, code included) and drafts the corrected doc section. Strictly a proposal a human applies — the Finding still resolves only when the deterministic re-check passes.
• Answers with accountability. An org-scoped MCP server first — so the agents your team already uses (Claude Code, Cursor) get context that knows its own freshness — then in-product ask and chat surfaces. Every answer carries its Evidence and freshness; a question we can't answer honestly feeds the Finding loop instead of ending in a confident synthesis. It is not a chatbot over your wiki.
• Delivery briefings. A scheduled, label-scoped digest of how the window went — code changes, tickets moved, Findings opened and resolved — each fact with Evidence. The deterministic layer selects the facts; the LLM only narrates, and any sentence it can't ground is dropped.
• A wider Source surface. Confluence, Jira, Azure DevOps, Google Workspace, Slack, meeting transcripts, and Datadog — each earns its slot by the Evidence it feeds the detectors, ordered by demand.
• Source-scoped access control, public signed webhooks, and enterprise readiness (SSO, compliance posture) — the groundwork that lets sensitive Sources and 200+-engineer orgs come aboard without leaking anything.

What you can do today

Connect GitHub and Notion, and watch the first confirmed-real Finding show up in minutes — with the Evidence to back it. Everything above is what makes that Finding something you finish and something that stays fixed.

The full roadmap lives in the repo — no dates, ordering as the commitment, and every item written as the outcome it has to produce. If your team pulls the order differently, that's the point: the Later horizon is re-orderable, but the rule underneath it doesn't move — depth of judgment before breadth of Sources.