Turbocharge Claude Code, Cursor, Codex, Gemini & every coding agent: faster, cheaper, with contextual understanding specific to your codebase.
TypeScript ai-agentsanthropicclaude-codeclicode-graphcodexcontext-engineeringcursordeveloper-toolsgeminiknowledge-graphllmmcpmcp-serveropen-sourceopenaitree-sitter
Add business case and product design notes
anirudhkumar-nanonetsa4a99ecfac25
diff --git a/BUSINESS-CASE.md b/BUSINESS-CASE.mdnew file mode 100644index 00000000..d944aada--- /dev/null+++ b/BUSINESS-CASE.md@@ -0,0 +1,148 @@+# Business Case: Context Graph — the self-hosted team brain++**Decision:** Of the five candidate products in PRODUCT-DESIGNS.md, we are launching+**Idea 2 — a self-hosted "team brain":** point it at a folder of team documents and get a+searchable knowledge graph that answers questions with citations, shows its confidence,+and gets smarter every time someone uses it. Open source, local-first, one process,+one SQLite file.++This document records why — the market logic, the evidence, and the risks — so the+reasoning survives past the launch week.++---++## 1. The problem is real, universal, and unsolved at our price point++Every team past ~10 people develops the same disease: the answers exist, but they live+in a retired engineer's head, a two-year-old Slack thread, page 41 of a runbook PDF,+and a Notion workspace nobody can search. The symptom is the **repeated question** —+"how do we deploy staging?", "who owns billing escalations?" — asked again every time+someone joins or forgets.++The category answer is enterprise search ("Glean for your company"), and it is sold as+**enterprise SaaS**: per-seat pricing, sales calls, and — the part small teams actually+refuse — *shipping every internal document to a third party's cloud*. A 15-person+agency, clinic, lab, or startup has exactly the same disease and none of the budget,+procurement patience, or willingness to exfiltrate its documents.++That gap — **teams of 10–100 who want their knowledge searchable without giving it to+anyone** — is the market. It is precisely the audience that self-hosts Nextcloud+instead of Dropbox and Chatwoot instead of Zendesk, and it congregates in reachable,+free channels (r/selfhosted, Hacker News, awesome-selfhosted lists).++## 2. Why this idea beat the other candidates++We deep-researched the three viable candidates (the two dev-oriented ideas were+excluded by constraint). The finding that decided it: **no candidate wins on empty+whitespace — every category is occupied — so the deciding axis is speed to real+users**, and the candidates differ by an order of magnitude:++| | A: Team brain | B: Slack onboarding bot | C: Support graph |+|---|---|---|---|+| Incumbent | Onyx (30.7k★) — heavyweight | Various SaaS Q&A bots | Chatwoot (34.1k★) + paywalled "Captain AI" |+| Gatekeeper between us and users | **None** | Slack Marketplace | Helpdesk marketplaces |+| Structural friction | Show HN / r/selfhosted post | **5 active workspaces required *before submission*, up to 10 weeks of manual review**, mandatory public HTTPS hosting, scrutiny on message-reading scopes | Zendesk/Intercom connector + 1–3 weeks marketplace review |+| Realistic time to first 10–100 users | **Days** | Months | Weeks |++For a project whose explicit goal is *the first 10–100 users, fast, with a demo today*,+B is disqualified by Slack's own rules and C by connector-plus-review lead time. A is+the only candidate where the entire acquisition loop — build, post, install — is+**permissionless**. Post-launch data for comparable OSS AI tools shows a competent+Show HN averaging ~121 GitHub stars in the first 24 hours; that is the top of exactly+the funnel we need, available on day one, at zero cost.++B and C are not discarded ideas — they are **future surfaces on the same engine**. A+Slack bot and a support-desk integration are distribution channels for a knowledge+graph that already exists. Building A first means B and C later inherit a graph, a+user base, and public proof.++## 3. Why we can win the shelf we're stepping onto++The obvious objection: Onyx already owns "open-source enterprise search" with 30.7k+stars. Why will anyone install ours?++Because Onyx's dominance is also its verified weakness. It is an **enterprise-shaped+deployment**: multiple containers, Postgres, a Vespa search cluster — infrastructure+that assumes a platform team. The r/selfhosted user with a NAS and the 20-person+company with no DevOps function bounce off it. The market leader structurally cannot+serve the low end without abandoning its architecture. That is a classic+low-end-disruption opening:++- **Their install:** a container fleet and a search cluster.+- **Ours:** one process, one SQLite file, embeddings computed in-process, no accounts,+ no API keys required. Your team's entire brain is a file you can copy.++The second differentiator is the product's actual thesis, and it is one the incumbents+don't have: **the graph is alive and it shows receipts.** Every fact carries how many+times it has been observed, a confidence score, and the exact source passages behind+it. Answers cite their evidence. When a teammate contributes a correction, you *watch*+the graph reinforce. Enterprise search treats knowledge as a static index to be+re-crawled; we treat it as a living ledger that compounds with use. For a small team,+that maps to the real fear — "can I trust this answer?" — and answers it visibly.++## 4. Why we built the demo as a local web app with the graph on screen++This was a deliberate GTM decision, and the research forced it:++1. **The differentiation must be visible or it doesn't exist.** The strongest caution+ from the research is that graph-based retrieval is *not* an automatic quality win —+ published benchmarks (arXiv 2502.11371) show GraphRAG failing to beat plain RAG on+ simple single-hop questions. If we demoed a chat box that answers questions, we+ would be indistinguishable from every RAG wrapper of the last three years and would+ read as "Onyx but smaller" — the single biggest identified risk of this launch. So+ the demo's design puts the mechanism on screen: the living graph is permanently+ visible, asking a question lights up the exact facts consulted, every fact wears a+ monospace provenance receipt (`68% · ×2 · 2 sources`), and teaching it something+ makes the reinforced nodes pulse. The moat is the epistemics; the UI exists to make+ the epistemics undeniable in a 30-second screen recording.++2. **A web UI is the product for this buyer, not a veneer.** The constraint was a+ non-developer-oriented standalone product. Our audience's operations manager will+ never run a CLI; "open localhost:4680 and ask" is the whole onboarding. The same+ interface doubles as every marketing asset the launch needs — the Show HN GIF, the+ README screenshot, the hosted demo.++3. **Distribution research dictated the shape of the install.** The channel analysis+ was unambiguous for self-hosted tools in 2026: Docker-first (a single `docker run`+ as the headline), hosted read-only demo as the week-two amplifier, and *not*+ npm-first — native-module installs (SQLite bindings, ONNX runtime) fail behind+ corporate proxies and node-gyp toolchains often enough to burn first-run trust;+ Anthropic itself abandoned npm distribution for Claude Code over exactly this+ failure mode. A self-contained local web server is the artifact that Dockerizes+ into that one-liner without change.++4. **Local-first is the positioning, so the demo must run with zero cloud.** The+ pitch — "your documents never leave your machine" — is falsified by a demo that+ requires an API key. Retrieval, the graph, and provenance all work fully offline;+ a cloud key only upgrades the experience (written answers, richer extraction).+ That graceful degradation is the trust story, demonstrated rather than claimed.++## 5. What winning looks like++The goal is deliberately not a million users; it is **10–100 real installs, fast**,+because for an OSS product that is the flywheel's first turn: installs → GitHub stars+→ list inclusion (awesome-selfhosted) → organic search → more installs.++- **Week 1:** Show HN + r/selfhosted launch. Success: ~100 stars, 10+ confirmed+ installs, 3 users who ask for something (a connector, a feature) — proof of pull.+- **Week 2–4:** hosted read-only demo, Docker image on a registry, README GIF.+ Success: first users we didn't personally cause; first inbound issue from a+ non-developer team.+- **After proof:** B (Slack surface) and C (support surface) become roadmap items+ built on a graph users already trust — entering those markets with evidence instead+ of cold.++## 6. Risks, stated honestly++- **"Onyx but smaller."** The kill risk. Mitigation is the entire demo design+ (visible graph, receipts, reinforcement) plus positioning discipline: we are not+ "enterprise search, lighter" — we are a *living knowledge ledger* for teams that+ will never deploy enterprise search.+- **Graph quality skepticism.** GraphRAG's benchmark record means we must not+ over-claim answer quality. We claim *provenance, confidence, and compounding* —+ properties plain RAG genuinely lacks — and let answer quality be table stakes.+- **Category churn.** The AI-tool graveyard is large; distribution moats are+ temporary. Our durable asset is the graph data users accumulate — the longer a team+ runs it, the more expensive leaving becomes. That is also why the write path+ (contribute/teach) shipped in v1 rather than later: retention is the moat, and+ retention starts at the first contributed fact.diff --git a/PRODUCT-DESIGNS.md b/PRODUCT-DESIGNS.mdnew file mode 100644index 00000000..e82b438b--- /dev/null+++ b/PRODUCT-DESIGNS.md@@ -0,0 +1,348 @@+# Context Graph Engine — Design Sketches for the Top 5 Product Ideas++> **Purpose:** design sketches for the five candidate products, written to a+> common template so they can be reviewed and scored side by side. Grounded in+> the current codebase (`src/engine.ts`, `src/graph/*`, `src/ai/*`, `src/mcp.ts`).+>+> **Frame (decided):** standalone, open-source, local-first, download-and-run,+> aimed at **small teams / companies**, **pure OSS / grow-first**.+>+> **Reviewer:** each idea uses the same 11 headings. Section 0 describes the+> shared primitives (team sync, scoping, embedding consistency) that most ideas+> depend on — read it first, it's referenced throughout.++---++## What already exists (the substrate)++The engine is real and most of a product already:++- **Core API** (`ContextGraphEngine`): `ingest` / `ingestFile` / `ingestDir` / `read` / `contribute` / `exportGraph` / `stats`.+- **Data model** (`graph/types.ts`): `GraphNode` and `GraphEdge` each carry `confidence`, `observations`, `provenance[]`, timestamps; `Chunk`s ground them in source text.+- **Merge/reinforce** (`graph/merge.ts`): incoming entities are matched to existing nodes by exact normalized name/alias **and** embedding cosine ≥ `mergeThreshold`; matches reinforce (`observations += 1`, confidence → 1, provenance union), non-matches are created. Edges dedupe on `(source, target, relation)`.+- **Storage** (`graph/store.ts` → `SqliteStore`): the engine talks to a **`GraphStore` interface**, so the backend is swappable (this is the single most important fact for the team ideas).+- **Providers** (`ai/*`): local-first — in-process embeddings (transformers.js `all-MiniLM-L6-v2`, 384-dim) + Ollama extraction; auto-upgrades to OpenRouter/OpenAI when keys are present.+- **Access modes**: library, `context-graph` CLI, `context-graph-mcp` MCP server (7 tools).+- **Retrieval** (`retrieval/retriever.ts`): semantic match on nodes → one-hop expansion → supporting chunks → rendered prompt.+- **Export** (`graph/export.ts`): interactive HTML / JSON / Mermaid.++### Known gaps every idea must reckon with++1. **Single graph per DB.** No namespaces/collections — one `.db` file = one graph. Multi-project scoping = separate DB files today, or a new `scope` column.+2. **No team sync.** The graph is local to one machine. → **Section 0.1**.+3. **Embedding provider must be consistent across a shared graph.** Vectors from different models aren't comparable; dedup/retrieval break if two members use different embedders. → **Section 0.3**.+4. **In-memory vector search.** `allEmbeddedNodes()` loads all nodes to score. Fine for small-team scale (thousands of nodes); a ceiling to note, not fix now.+5. **No delete / decay / temporal.** Facts don't expire or track "when true." Deferred features; matters for some ideas more than others.+6. **No auth / access control.** Acceptable for local single-user; needs a story the moment a graph is shared over a network.++---++## Section 0 — Shared primitives (referenced by ideas 1–4)++### 0.1 Team sync — the one real new engineering task++Most ideas reduce to "the same engine, but the graph is shared across a small+team." Two modes, both leaning on the existing `GraphStore` interface and the+fact that **merge is near-idempotent** (re-applying a contribution reinforces+rather than corrupts).++**Mode A — Git-native (zero infra, best for coding teams).**+- Serialize the graph to a committed, human-diffable file: `.context-graph/graph.jsonl` (one node/edge/chunk per line) or a small directory of shards to reduce merge churn.+- `pull` → import + **re-merge** remote records into the local graph using the *existing* `mergeExtraction`-style union (dedup by name/embedding, reinforce, union provenance). Because merge is commutative-ish, two people's additions combine without a central server.+- `push` → re-serialize and commit. Conflicts resolve by union, not overwrite (take max `observations`, reinforced `confidence`, union `provenance`, newer `updatedAt` for `summary`).+- Pros: zero infra, versioned, offline-friendly, code never leaves the repo. Cons: not real-time; embeddings bloat the file (store quantized or recompute on import).++**Mode B — Shared store (near-real-time, best for non-code teams).**+- Implement `GraphStore` against a shared backend. Recommended: **libSQL / Turso embedded replica** — a local SQLite file that syncs to a shared remote. This preserves *local-first* (reads/writes hit local) while giving *team-shared* state. Alternative: `PostgresStore` (+ pgvector) for a self-hosted server.+- Pros: real-time, scales past git-file limits. Cons: someone runs the sync target (a Turso DB or a Postgres container).++**Recommendation:** ship **Mode A first** (it's the differentiator and needs no infra), offer **Mode B** as an opt-in for larger/non-code teams. Both are additive — the engine core is untouched.++### 0.2 Scoping / namespaces++Teams have multiple projects. Minimal design: add an optional `scope` (a.k.a.+`collection`) string to documents/nodes/edges, default `"default"`, filterable+at read time. Cheaper interim: one DB file per project (already supported via+`--db` / `CONTEXT_GRAPH_DB`). Recommend interim for v1, `scope` column when a+single shared store hosts many projects (Mode B).++### 0.3 Embedding consistency (a hard constraint, not a nice-to-have)++A shared graph **must** pin one embedding model for all members, recorded in+graph metadata; the engine should refuse (or warn + re-embed) on mismatch. For+local-first teams, standardize on the in-process `all-MiniLM-L6-v2` so there are+no keys and no drift. Cloud embeddings become a per-graph, all-or-nothing choice.++### 0.4 Provenance & trust (already have the bones)++`provenance[]` + `observations` + `confidence` already exist per node/edge. Every+idea should surface these in its UX (who/what contributed a fact, how many times+confirmed) — it's the built-in trust and "gets smarter" story.++---++## Idea 1 — Shared memory for a team's coding agents ⭐ recommended beachhead++**1. Positioning.** One self-hosted graph every developer's Claude Code / Cursor+reads before working and writes learnings back to — so the team's agents stop+re-learning the codebase, conventions, and the reasons behind past decisions.++**2. Target user & JTBD.** Small eng teams (2–20). *"My AI agent doesn't know how+**we** do things, so I re-explain our patterns every session and it repeats+mistakes we already solved."*++**3. Primary flows.**+- *Bootstrap:* `context-graph ingest-dir ./` over the repo + docs → initial graph committed to `.context-graph/`.+- *Before work (automatic):* agent calls `context_read` via MCP → gets conventions, gotchas, ownership, past decisions relevant to the task, with source lines.+- *After work (automatic):* agent calls `context_contribute` with what it learned ("the retry helper lives in `net/backoff.ts`, not `util`"); merged + reinforced.+- *Sync:* `git pull` merges teammates' contributions (Mode A); the graph rides the repo.++**4. Architecture.** Reuses the engine wholesale. New: **Team Sync Mode A**+(§0.1), a `context-graph sync` command + a git hook / CI step, and MCP tool+polish. Optional: a "session recap" that batches an agent's session into one+contribution.++**5. Data model changes.** Add a `kind`/`type` vocabulary for code entities+(`module`, `function`, `convention`, `decision`, `pitfall`, `owner`). Add+`scope` = repo path if multi-repo (§0.2). Serialization format for git sync.++**6. Hero feature.** **Write-back that survives `git pull`** — the graph is+shared, versioned, and compounds across the whole team, and it visibly improves+(confidence/observation counts) as everyone's agents use it.++**7. MVP scope.**+- *In:* repo ingest, MCP read/contribute (exists), Mode A git sync, code-aware entity types, a `sync`/merge command, README quickstart, the HTML graph view.+- *Out:* web UI, real-time sync, access control, decay.++**8. Effort.** **Low–Med.** The engine + MCP exist; the real work is sync + serialization + code-entity tuning. ~2–3 weeks to a launchable v1.++**9. Distribution / GTM.** MCP directory listing, Show HN, `curl | sh`, a README+demo GIF of the graph. Coding-agent devs are the most OSS-viral audience in 2026.+Dogfood on this very repo (it's already an MCP server).++**10. Success metrics.** GitHub stars, MCP installs, weekly-active graphs,+**contributions-back per active graph per week** (the "is it compounding?" metric),+% of teams with >1 contributor to a graph.++**11. Risks / open questions for the reviewer.**+- Does git-file sync stay clean once embeddings are in the file? (Quantize? Recompute on import? Separate embedding cache out of git?)+- Contribution quality/noise: do we need a confidence floor or a review gate before a learning becomes readable?+- Is "one graph per repo" the right unit, or per-monorepo-package?+- Overlap with ByteRover — is "team-shared + reinforcing" a strong enough wedge vs their individual file-tree?++---++## Idea 2 — Self-hosted "team brain" (the small-team Glean, but OSS)++**1. Positioning.** Point it at a team's docs (Notion/Drive export, PDFs,+markdown) → a self-improving knowledge graph both people and agents query, via a+web UI to explore/ask and an MCP server so any agent taps in.++**2. Target user & JTBD.** Small companies (10–100) where knowledge is scattered+and Glean/Guru are too pricey/enterprise. *"Nobody can find the current answer,+and the wiki is stale."*++**3. Primary flows.**+- *Ingest:* connect a source or drop a folder → graph builds (progress UI).+- *Ask (human):* web search box → structured answer + source passages + a graph view of related entities.+- *Ask (agent):* MCP `context_read`.+- *Curate:* the graph self-reinforces; humans can confirm/flag a fact (bumps/curbs confidence).++**4. Architecture.** Engine + **a new web app** (the big lift) + **Mode B shared+store** (§0.1) so multiple users hit one graph + **connectors** (start with+folder + Notion/Drive export). Auth needed once networked (§0 gap 6).++**5. Data model changes.** `scope`/workspace column (§0.2); user identity for+contributions; a `verified`/`flagged` state on nodes/edges layered over+confidence; source-connector metadata on documents.++**6. Hero feature.** **A living knowledge base that doesn't rot** — write-back ++reinforcement keep it current, and humans + agents share exactly one source of+truth, with the graph as a navigable map.++**7. MVP scope.**+- *In:* folder + one connector, Mode B store, web UI (search + answer + graph view + admin), basic auth, MCP read.+- *Out:* fine-grained permissions, SSO, real-time collab, mobile.++**8. Effort.** **Med–High.** The web UI + connectors + auth are net-new and are+the bulk of the work. ~6–10 weeks to a credible v1.++**9. Distribution / GTM.** Self-host via Docker; OSS repo; "the open, local Glean"+narrative. Slower-burning than Idea 1 (not developer-viral by default).++**10. Success metrics.** Deployed instances, weekly-active askers, queries/week,+answer thumbs-up rate, fraction of answers with a cited source.++**11. Risks / open questions.**+- Scope creep: this competes with mature tools; UI quality bar is high.+- Retrieval quality on heterogeneous docs — is one-hop + chunks enough, or do we need multi-hop / reranking?+- In-memory vector search ceiling (§0 gap 4) arrives sooner here.+- This is the **natural expansion of Idea 1**, not a cold start — is it premature to build before Idea 1 shows pull?++---++## Idea 3 — Onboarding & tribal-knowledge brain (+ Slack bot)++**1. Positioning.** Capture how your systems work, who owns what, and the answers+that clog Slack — into a graph a bot answers from and learns from every thread.++**2. Target user & JTBD.** Small teams with painful new-hire ramp and+repeated questions. *"We answer the same onboarding questions every week."*++**3. Primary flows.**+- *Seed:* ingest onboarding docs, runbooks, an org/ownership sheet.+- *Ask:* `@brain how do we deploy staging?` in Slack → answer + sources.+- *Learn:* the bot ingests resolved threads (opt-in) via `contribute`, so answered questions strengthen the graph.+- *Escalate:* if confidence is low, route to the owner entity in the graph.++**4. Architecture.** Engine + **a Slack app** (events API, slash command, thread+reader) + Mode B store (bot is a shared service). Reuses read/contribute directly.++**5. Data model changes.** `owner`/`team` entity types + `owns`/`escalates_to`+relations; thread/message provenance; confidence threshold config for+"answer vs escalate."++**6. Hero feature.** **The contribute/reinforce loop is a perfect fit** — every+answered question makes the next answer better; low-confidence gaps auto-route to+a human owner.++**7. MVP scope.**+- *In:* Slack bot (Q&A + thread ingest), doc ingest, owner/escalation entities, confidence-gated escalation.+- *Out:* other chat platforms, analytics dashboard, auto-summarized weekly digests.++**8. Effort.** **Med.** Self-contained; the Slack integration is the main new+surface. ~4–6 weeks.++**9. Distribution / GTM.** Slack App Directory + OSS self-host. Narrow, concrete,+easy to explain; less developer-viral than Idea 1.++**10. Success metrics.** Questions answered/week, % answered without escalation,+median time-to-answer, new-hire "time to first useful answer," contributions from+resolved threads.++**11. Risks / open questions.**+- Answer quality/hallucination on thin graphs — need a hard confidence floor + "I don't know, ask @owner."+- Privacy: ingesting Slack threads needs clear opt-in and redaction.+- Is a Slack bot the right first surface, or a thinner CLI/MCP bot to validate value faster?++---++## Idea 4 — Support graph that learns from resolved tickets++**1. Positioning.** A graph over help docs + resolved tickets; an agent drafts+answers and every resolution reinforces what's actually true — support that+compounds.++**2. Target user & JTBD.** Small support/CS teams. *"We keep re-solving the same+issues; our macros and docs drift from reality."*++**3. Primary flows.**+- *Seed:* ingest help center + historical resolved tickets.+- *Draft:* on a new ticket, `read` → agent drafts a grounded reply with sources.+- *Learn:* on resolution, `contribute` the accepted answer → reinforces the graph.+- *Surface gaps:* low-confidence/frequent-miss topics flagged for a doc update.++**4. Architecture.** Engine + **helpdesk connectors** (Zendesk/Intercom/email) ++an answer-draft flow + Mode B store. Reuses read/contribute.++**5. Data model changes.** `issue`/`product`/`resolution` entity types;+ticket provenance; a "gap report" query over low-confidence high-frequency nodes.++**6. Hero feature.** **Reinforcement is the native mechanic of support** — answers+measurably improve as tickets close, and the system tells you which docs to write.++**7. MVP scope.**+- *In:* one helpdesk connector, doc ingest, draft-answer flow, resolution → contribute, gap report.+- *Out:* full agent autopilot, multi-brand, SLA analytics.++**8. Effort.** **Med.** Connectors + draft flow are the new work; furthest from+current dogfooding, so slower to a credible internal demo.++**9. Distribution / GTM.** Helpdesk marketplaces + OSS self-host. Clear ROI story;+**most naturally monetizable later** (per-seat / per-resolution), but that's a+later, post-grow question given the OSS-first frame.++**10. Success metrics.** Draft-acceptance rate, deflection rate, handle-time+reduction, docs created from gap reports, reinforcement events/week.++**11. Risks / open questions.**+- Wrong answers are costly in support — needs strong grounding + human-in-the-loop before send.+- Connector maintenance burden (helpdesk APIs).+- Weakest fit with "small **team**" if it drifts toward enterprise CS — keep it small-team scoped.++---++## Idea 5 — The local-first memory layer (horizontal primitive)++**1. Positioning.** "mem0, but local-first & TypeScript/MCP-native" — a drop-in+memory any builder adds to any agent in one install, no keys, no database to+stand up.++**2. Target user & JTBD.** Developers building agents who want memory without+cloud lock-in or a Python dependency. *"I want durable agent memory I can `npm i`+and run offline."*++**3. Primary flows.**+- `npm i` / `curl | sh` → `read` / `contribute` in library, CLI, or MCP form.+- Bring-your-own store via the `GraphStore` interface; local by default.++**4. Architecture.** **Almost exactly what exists today.** The work is packaging:+crisp API surface, docs, examples, a **published benchmark**, and framework+adapters (LangChain.js, Vercel AI SDK, Mastra).++**5. Data model changes.** Minimal. Maybe stabilize the public types and add+memory "scopes" (user/session/agent) to match how the category is framed.++**6. Hero feature.** **Zero-infra, TS/MCP-native, self-reinforcing memory** — the+combination none of the Python/cloud incumbents offer by default.++**7. MVP scope.**+- *In:* API/docs hardening, adapters for 2–3 JS agent frameworks, a benchmark writeup, examples.+- *Out:* everything vertical (no UI, no connectors, no team features).++**8. Effort.** **Low.** Mostly docs, examples, benchmark, adapters. ~1–2 weeks to+a stronger OSS release.++**9. Distribution / GTM.** Pure GitHub-star play: benchmark blog post, framework+adapter announcements, MCP directory, Show HN. Highest ceiling for stars, hardest+to differentiate on story alone.++**10. Success metrics.** Stars, npm weekly downloads, adapter installs, benchmark+ranking, inbound "who's using it."++**11. Risks / open questions.**+- **Most crowded shelf** — "generic memory" without a sharp use case rarely wins attention; this is why it's framed as the *engine underneath Idea 1*, not the headline.+- Benchmarking honestly against mem0/Zep (LongMemEval) may expose gaps (no temporal graph).+- Positioning risk: "yet another memory lib" fatigue.++---++## Cross-idea summary (for scoring)++| # | Idea | Effort | Risk | New surface to build | OSS virality | Fit w/ current code |+|---|------|--------|------|----------------------|--------------|---------------------|+| 1 | Coding-agent team memory ⭐ | Low–Med | Med | Git sync + code entities | High | Highest (dogfooded) |+| 2 | Team brain (OSS Glean) | Med–High | Med | Web UI + connectors + auth | Med | Med |+| 3 | Onboarding + Slack bot | Med | Low–Med | Slack app | Med | Med |+| 4 | Support graph | Med | Med | Helpdesk connectors + draft flow | Low | Med |+| 5 | Memory primitive | Low | High | Docs/adapters/benchmark | High | Highest (as-is) |++**Recommended path (unchanged):** ship **Idea 5's engine, packaged as Idea 1**,+grow it OSS through developers, and let real-world usage pull toward **Idea 2**.+Ideas 3 and 4 are strong standalone verticals if a specific design partner /+pain shows up first.++### The single sentence to defend+> **Local-first + team-shared + TypeScript/MCP-native + self-reinforcing** —+> the square of the memory market that no current player occupies.++---++## Questions the reviewing model should pressure-test++1. Is **team sync via git (Mode A)** genuinely robust given embeddings live in the graph, or does it force Mode B (a server) sooner than claimed?+2. Is "coding-agent team memory" (Idea 1) a **strong enough wedge vs ByteRover**, or is the differentiation too thin?+3. Does the **near-idempotent merge** actually hold under concurrent multi-writer merges, or are there conflict cases (e.g., two different summaries, contradictory facts) that need explicit resolution / a temporal layer?+4. For pure-OSS grow-first, is Idea 1 or Idea 5 the better **top-of-funnel**, given 1 has a sharper story but 5 is closer to shippable today?+5. Which idea best withstands the **"generic memory is commoditizing"** risk over a 12-month horizon?+6. What's the **smallest possible v1** that proves the "gets smarter with team use" claim to real users?