memhouse 0.18.12 → 0.20.1

package/ui/src/pages/Dashboard.jsx

@@ -8,7 +8,7 @@ import ActivityHeatmap from '../components/ActivityHeatmap'
 import DateRangePicker from '../components/DateRangePicker'
 import { editorColor, editorLabel, formatNumber, formatCost, dateRangeToApiParams } from '../lib/constants'
 import EditorIcon from '../components/EditorIcon'
-import { fetchDailyActivity, fetchOverview as fetchOverviewApi, fetchDashboardStats, fetchChats, fetchCosts } from '../lib/api'
+import { fetchLanding } from '../lib/api'
 import ChatSidebar from '../components/ChatSidebar'
 import AnimatedLoader from '../components/AnimatedLoader'
 import ShareModal from '../components/ShareModal'
@@ -26,7 +26,7 @@ const MODE_COLORS = {
   copilot: '#f59e0b', thread: '#ec4899', opencode: '#f43f5e', claude: '#f97316',
 }
 
-export default function Dashboard({ overview }) {
+export default function Dashboard({ overview, refreshKey = 0 }) {
   const navigate = useNavigate()
   const [dailyData, setDailyData] = useState(null)
   const [filteredData, setFilteredData] = useState(null)
@@ -37,6 +37,7 @@ export default function Dashboard({ overview }) {
   const [costs, setCosts] = useState(null)
   const [shareOpen, setShareOpen] = useState(false)
   const [largeContextChats, setLargeContextChats] = useState(null)
+  const [largeContextTotal, setLargeContextTotal] = useState(null)
   const [selectedChatId, setSelectedChatId] = useState(null)
   const txtColor = dark ? '#888' : '#555'
   const txtDim = dark ? '#555' : '#999'
@@ -56,40 +57,25 @@ export default function Dashboard({ overview }) {
   }
   const noLegend = { legend: { display: false }, tooltip: { bodyFont: { family: MONO, size: 10 }, titleFont: { family: MONO, size: 10 } } }
 
+  // ONE request for the whole page (/api/landing). It used to be five — overview, daily
+  // activity, dashboard stats, costs and a 500-session chat list priced only to find the ten
+  // largest — 33–34 SQL statements behind them. `refreshKey` moves when Live sees the house
+  // version change or Refetch completes.
   useEffect(() => {
-    const dateParams = dateRangeToApiParams(dateRange)
-    const chatParams = { limit: 500, named: false, ...dateParams }
-    if (selectedEditor) chatParams.editor = selectedEditor
-
-    fetchChats(chatParams).then(r => {
-      const big = (r.chats || []).filter(c => c.bubbleCount >= 100).sort((a, b) => b.bubbleCount - a.bubbleCount)
-      setLargeContextChats(big)
-    })
-
-    if (!selectedEditor) {
-      // A date range without an editor must still refresh the overview widgets
-      // (KPIs, monthly trend, top projects) — falling back to the all-time
-      // `overview` prop would disagree with the date-scoped heatmap/stats/costs.
-      const hasDates = dateParams.dateFrom || dateParams.dateTo
-      if (hasDates) fetchOverviewApi(dateParams).then(setFilteredData)
-      else setFilteredData(null)
-      fetchDailyActivity(dateParams).then(setDailyData)
-      fetchDashboardStats(dateParams).then(setStats)
-      fetchCosts(dateParams).then(setCosts)
-      return
-    }
-    Promise.all([
-      fetchOverviewApi({ editor: selectedEditor, ...dateParams }),
-      fetchDailyActivity({ editor: selectedEditor, ...dateParams }),
-      fetchDashboardStats({ editor: selectedEditor, ...dateParams }),
-      fetchCosts({ editor: selectedEditor, ...dateParams }),
-    ]).then(([ov, daily, st, c]) => {
-      setFilteredData(ov)
-      setDailyData(daily)
-      setStats(st)
-      setCosts(c)
-    })
-  }, [selectedEditor, dateRange])
+    const params = { ...dateRangeToApiParams(dateRange) }
+    if (selectedEditor) params.editor = selectedEditor
+    let cancelled = false
+    fetchLanding(params).then(r => {
+      if (cancelled) return
+      setFilteredData(r.overview)
+      setDailyData(r.daily)
+      setStats(r.stats)
+      setCosts(r.costs)
+      setLargeContextChats(r.largeContext.chats)
+      setLargeContextTotal(r.largeContext.total)
+    }).catch(() => {})
+    return () => { cancelled = true }
+  }, [selectedEditor, dateRange, refreshKey])
 
   if (!overview) return <AnimatedLoader label="Loading dashboard..." />
 
@@ -500,7 +486,7 @@ export default function Dashboard({ overview }) {
               <span className="inline-flex items-center gap-1">
                 <AlertTriangle size={10} className="text-amber-400" />
                 large context
-                <span style={{ color: 'var(--c-text3)' }}>({largeContextChats.length})</span>
+                <span style={{ color: 'var(--c-text3)' }}>({largeContextTotal ?? largeContextChats.length})</span>
               </span>
             </SectionTitle>
             <div className="space-y-1">

package/ui/third-party-notices.js

@@ -0,0 +1,119 @@
+/* global process */
+// Writes THIRD_PARTY_NOTICES.txt beside the built dashboard (public/), listing every
+// third-party package whose code ends up in the bundle, with its license text.
+//
+// Why: the bundle carries React, chart.js, lucide, react-markdown and others, all under
+// licenses (MIT, ISC, …) whose one condition is that the notice travels with every copy.
+// Vite strips their license comments when it minifies, so the published package shipped
+// those copies with no notice at all. This plugin reads the bundle's own module graph, so
+// the list is exactly what was bundled, never a hand-kept list that drifts.
+//
+// No dependency of its own on purpose: it reads each package's package.json and license
+// file straight off node_modules.
+import fs from 'node:fs'
+import path from 'node:path'
+
+const LICENSE_FILE = /^(licen[sc]e|copying|notice)([.-].*)?$/i
+
+// Bundled packages that genuinely ship no license file, each with its declared license
+// and why it may be listed without a text. Any other package without one fails the build.
+// Empty today: every bundled package ships its license file.
+//   'name': { license: 'MIT', reason: 'one line: why there is no file, and what was checked' },
+export const NO_LICENSE_FILE = {}
+
+// '/abs/ui/node_modules/react-dom/cjs/x.js' -> { name: 'react-dom', dir: '/abs/ui/node_modules/react-dom' }
+// The LAST node_modules segment wins, so a nested copy is attributed to itself.
+export function packageOf(id) {
+  const clean = String(id).replace(/^\0/, '').split('?')[0].split(path.sep).join('/')
+  const i = clean.lastIndexOf('/node_modules/')
+  if (i < 0) return null
+  const parts = clean.slice(i + '/node_modules/'.length).split('/')
+  const name = parts[0].startsWith('@') ? `${parts[0]}/${parts[1]}` : parts[0]
+  if (!name || name.startsWith('.')) return null
+  return { name, dir: clean.slice(0, i + '/node_modules/'.length) + name }
+}
+
+function readPackage(dir) {
+  let pkg = {}
+  try { pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8')) } catch { /* no manifest */ }
+  let files = []
+  try { files = fs.readdirSync(dir).filter((f) => LICENSE_FILE.test(f)).sort() } catch { /* unreadable dir */ }
+  const texts = files.map((f) => {
+    try { return { file: f, text: fs.readFileSync(path.join(dir, f), 'utf-8').trim() } } catch { return null }
+  }).filter(Boolean)
+  const license = typeof pkg.license === 'string' ? pkg.license
+    : (pkg.license && pkg.license.type) || (Array.isArray(pkg.licenses) ? pkg.licenses.map((l) => l.type || l).join(' OR ') : '')
+  const repo = typeof pkg.repository === 'string' ? pkg.repository : (pkg.repository && pkg.repository.url) || pkg.homepage || ''
+  return { version: pkg.version || '', license: license || 'UNKNOWN', repo, texts }
+}
+
+/**
+ * @param {object} [o]
+ * @param {string} [o.fileName]  where the notices land, relative to outDir
+ * @param {string[]} [o.extra]   packages that reach the bundle without showing up as a JS
+ *                               module: tailwindcss (its preflight CSS is in the stylesheet),
+ *                               react-router-dom (it only re-exports react-router, so the
+ *                               graph holds react-router's modules, not its own)
+ * @param {string} [o.root]      where to resolve `extra` from (the ui/ directory)
+ */
+export default function thirdPartyNotices({ fileName = 'THIRD_PARTY_NOTICES.txt', extra = [], root = process.cwd() } = {}) {
+  return {
+    name: 'memhouse-third-party-notices',
+    apply: 'build',
+    generateBundle(_options, bundle) {
+      // Keyed by INSTALL DIRECTORY, not by name: two versions of one package can both be
+      // bundled (a nested copy beside the top-level one), and each carries its own license.
+      const found = new Map() // dir -> name
+      for (const out of Object.values(bundle)) {
+        if (out.type !== 'chunk') continue
+        for (const id of Object.keys(out.modules || {})) {
+          const p = packageOf(id)
+          if (p && !found.has(p.dir)) found.set(p.dir, p.name)
+        }
+      }
+      for (const name of extra) {
+        const dir = path.join(root, 'node_modules', name).split(path.sep).join('/')
+        if (!found.has(dir) && fs.existsSync(dir)) found.set(dir, name)
+      }
+      // One entry per name@version; two install dirs holding the same version are one notice.
+      const entries = new Map()
+      for (const [dir, name] of found) {
+        const info = readPackage(dir)
+        const key = `${name}@${info.version}`
+        if (!entries.has(key)) entries.set(key, { name, ...info })
+      }
+      const list = [...entries.values()].sort((a, b) => (a.name === b.name
+        ? a.version.localeCompare(b.version, undefined, { numeric: true })
+        : (a.name < b.name ? -1 : 1)))
+      // A bundled package whose license text cannot be shipped fails the build. A notice
+      // file that silently omits one is the defect this plugin exists to prevent. The only
+      // exceptions are packages that genuinely ship no license file, named in
+      // NO_LICENSE_FILE with their declared license and the reason.
+      const missing = list.filter((e) => !e.texts.length && !NO_LICENSE_FILE[e.name])
+      if (missing.length) {
+        this.error(`bundled without a license text: ${missing.map((e) => `${e.name}@${e.version} (declares ${e.license})`).join(', ')}. `
+          + 'Add the license text, or list the package in NO_LICENSE_FILE (ui/third-party-notices.js) with its declared license and why.')
+      }
+      const blocks = list.map((e) => {
+        const allowed = NO_LICENSE_FILE[e.name]
+        const head = `${e.name}${e.version ? ` ${e.version}` : ''} — ${e.license}${e.repo ? `\n${e.repo}` : ''}`
+        const body = e.texts.length
+          ? e.texts.map((t) => (e.texts.length > 1 ? `[${t.file}]\n${t.text}` : t.text)).join('\n\n')
+          : `(this package ships no license file; declared license: ${allowed.license}. ${allowed.reason})`
+        return `${'='.repeat(72)}\n${head}\n${'-'.repeat(72)}\n${body}\n`
+      })
+      const source = [
+        'memhouse dashboard — third-party software included in this directory (public/)',
+        '',
+        'The built dashboard bundles the packages below. Each is listed with its version,',
+        'its declared license, and the license text it ships. Generated at build time by',
+        'ui/third-party-notices.js from the bundle\'s module graph.',
+        '',
+        `${list.length} packages.`,
+        '',
+        ...blocks,
+      ].join('\n')
+      this.emitFile({ type: 'asset', fileName, source })
+    },
+  }
+}

package/ui/vite.config.js

@@ -12,10 +12,14 @@ export default defineConfig({
     outDir: '../public',
     emptyOutDir: true,
   },
+  // The dev server proxies /api to the memhouse dashboard (127.0.0.1:MEMHOUSE_PORT, default 4640).
+  // The dashboard needs its token: open the dev server with the URL `memhouse dashboard` prints in
+  // a terminal, on this origin (http://localhost:5173/#token=…); the page sends it as a Bearer
+  // header, which this proxy passes on.
   server: {
     proxy: {
       '/relay': 'http://localhost:4638',
-      '/api': process.env.RELAY ? 'http://localhost:4638' : 'http://localhost:4637',
+      '/api': process.env.RELAY ? 'http://localhost:4638' : `http://127.0.0.1:${process.env.MEMHOUSE_PORT || 4640}`,
     },
   },
 })

package/docs/releases/v0.18.12.md

@@ -1,59 +0,0 @@
-# memhouse 0.18.12 — 2026-10-29
-
-A patch release on the 0.18 line. It does one thing for users:
-
-- **The `/mem` skills pre-approve read-only commands only.** Each skill's `allowed-tools`
-  now lists the memhouse read commands it teaches, instead of `Bash` as a whole.
-
-No drill was run for this patch release. Its one user-facing change is held by
-`misc/skill-allowlist-test.js`, which runs in `npm test`.
-
-## Upgrade
-
-```bash
-memhouse update        # refreshes the /mem skills wherever they are installed
-```
-
-Then reload the skills in Claude Code with `/reload-plugins`, or restart the session.
-
-If you upgraded with `npm install -g memhouse` instead, run `memhouse plugins install claude`
-once, so the installed skills match the package.
-
-Nothing else changes: same house layout, same schema, same daemons.
-
-## Changed
-
-### Skills: allowed tools restricted to read-only commands
-
-Each `/mem` skill's `allowed-tools` names the memhouse read commands it uses:
-
-| skill | runs without a prompt |
-|---|---|
-| `/mem:house` | `memhouse instance`, `whoami`, `status`, `stats`, `doctor`, and `share --list` (with or without `--json`) |
-| `/mem:recall` | `memhouse search`, `resume`, `sessions-query`, `status`, `whoami` |
-| `/mem:sql` | `memhouse sessions-query`, `stats`, `status`, `whoami` |
-| `/mem:access` | `memhouse whoami`, `status`, and `share --list` (with or without `--json`) |
-| `/mem:admin` | `memhouse whoami`, `status`, `instance` |
-
-Any other command goes through Claude Code's normal permission prompt, as does a read
-command with another command chained to it. Expect a prompt where a skill used to run a
-command without one; approve it as you would any other command.
-
-## Repository and tests
-
-These do not change the installed package's behaviour:
-
-- `misc/skill-allowlist-test.js` keeps every skill's `allowed-tools` to read-only memhouse
-  commands. It joins `npm test`.
-- The test tooling's deploy targets (lab address, test machine, engine checkout) are read
-  from an untracked `deploy/targets.env`. `deploy/targets.example.env` shows the shape.
-- Test fixtures, examples, drill records and docs use stand-in names, hosts and paths.
-  `misc/env-guard-test.js` checks tracked files for real environment values, and it joins
-  `npm test`.
-- Security reports go through GitHub's private vulnerability reporting (`SECURITY.md`).
-- The 0.18 line is now cut from the `release/0.18` branch. `AGENTS.md` and
-  `misc/publish-guard.js` say so.
-
-## Deferred
-
-Nothing new. Later work ships on the current line's next release.

package/memhouse/COMPETITION.md

@@ -1,221 +0,0 @@
-# memhouse — the competition
-
-Companion to `DESIGN.md`. That file states **the four bets**; this one grades each
-bet against the field as it actually stands.
-
-**Surveyed 2026-08-07.** Every star/fork/date figure was pulled from the GitHub API
-on that date and is a decaying fact — re-run before citing. Claims that could not be
-verified are marked *unverified* rather than asserted. X/Twitter was not reachable
-(HTTP 402 to the fetch tool), so nothing here reflects it.
-
-The finding, in one line: **three of the four bets are already occupied by shipping
-competitors, most of them free and further along. Bet 3 is the one that holds.**
-
----
-
-## The field splits four ways
-
-The space shares vocabulary but not architecture. Distinguishing the camps is the
-whole analysis, because most "agent memory" products are not competitors at all.
-
-| Camp | What it means | Where memory comes from | Competes with us? |
-|---|---|---|---|
-| **Transcript readers** | Index the JSONL/SQLite stores the agents already wrote | Passive — reads disk | **Yes, directly** |
-| **Hook capturers** | Install lifecycle hooks, compress with an LLM, re-inject | Passive, but must live inside the agent | Yes, on the same users |
-| **Memory SDKs** | Developer calls `add()` / `search()` | Active — the developer writes it | No — different product |
-| **Observability** | OTel/proxy traces of model calls | Passive, at the API layer | Only on analytics |
-
-memhouse is a transcript reader with the observability camp's analytics attached.
-That combination is the most defensible thing about the product's *shape*; the
-individual pieces are not scarce.
-
----
-
-## The four bets, graded
-
-### Bet 1 — Parse on the client. **Occupied. Not differentiated.**
-
-The reasoning in `DESIGN.md` is sound and the conclusion is correct — sqlite-backed
-editors do force client-side parsing. But it is no longer a distinguishing choice.
-At least five projects crack the same on-disk stores today, and one of them cracks
-formats we do not touch (encrypted Protobuf sidecars for Antigravity CLI, Markdown
-for aider).
-
-Editor coverage — the number we lead the README with — is mid-pack:
-
-| Project | Editors | Note |
-|---|---:|---|
-| AgentsView | **50+** | each with documented on-disk paths |
-| lean-ctx | 30+ | claimed |
-| CCHV | 28 | each with documented paths |
-| **memhouse** | **17** | |
-| deja-vu | 17 | different 17 — has Cline, aider, Qwen Code, Kimi Code, Roo Code |
-| coding_agent_session_search | 11+ | |
-| ctx | 8 | |
-| Conare | 7 | |
-| Contextify | 2 | Claude Code + Codex CLI only |
-
-deja-vu's tagline is our pitch verbatim: *"it indexes the sessions your coding agents
-already wrote to disk, months of history from before you installed it, across
-seventeen harnesses."*
-
-### Bet 2 — Typed common schema. **Occupied on outcome, distinct on method.**
-
-Everyone arrives at structured storage; the axis that still separates us is **when
-the extraction happens and what survives it**.
-
-- **SQLite + FTS5 is the category default**, reached independently by AgentsView,
-  Agent Sessions, claude-code-chat-explorer, claude-mem, ccrecall and mnemo.
-- **ClickHouse for editor transcripts is unclaimed.** The only other ClickHouse-based
-  agent memory found is `clickmem` (57 stars) and it is embedded chDB, single-user,
-  so it inherits none of the multi-member properties. Langfuse is ClickHouse-backed,
-  MIT and self-hostable — but ingests API traces, not editor stores.
-- **Verbatim-with-no-LLM-on-the-write-path has one serious co-traveller**:
-  MemPalace (58k stars in four months) sells exactly that — *"verbatim storage,
-  zero API calls."* We are not alone on this axis, but the company is good.
-
-Honest caveat: at single-team scale SQLite demonstrably suffices. ClickHouse is a
-bet on a scale we have not yet had to prove.
-
-### Bet 3 — Kernel-installable agency, own-only by absent grant. **This one holds.**
-
-This is the finding worth acting on. Every competitor's multi-user story is a
-**shared pool** or **metadata scoping**. Not one enforces isolation at the
-datastore's own permission layer.
-
-| Product | Team mechanism | Isolation |
-|---|---|---|
-| AgentsView | `pg push` / `pg serve` to shared PostgreSQL | **None.** Connection string is the whole boundary; `machine_name` is a label, not a fence |
-| memsearch (Zilliz) | Docker + shared Milvus, documented "for team environments" | **None documented** — no RBAC, no per-user namespacing |
-| mem0 | `user_id` + `agent_id` + `run_id` filters | Metadata filtering, not enforcement |
-| Industry pattern | `tenant_id` column + row-level security | Policy layer, revocable by whoever owns the policy |
-| Contextify | Cloud workspace, per-project opt-in | Real, but proprietary, cloud-first, 2 editors |
-| **memhouse** | three `GRANT SELECT` on the member's own rooms | **A member cannot name another member's rooms.** `WITH GRANT OPTION` on `SELECT` and not on `ALL` makes sharing read-only by construction and operator-free |
-
-Bet 3 is not a niche preference. It is a category-wide blind spot, and it is the
-only thing in this document that nobody else is attempting.
-
-### Bet 4 — Borrowed UI, zero fork. **Occupied. Not differentiated.**
-
-Analytics over the same files is a crowded, mature niche: ccusage (17.8k stars),
-CodexBar (19.8k). Agent Sessions beats us on the analytics *idea* with a per-session
-"Quota Meter / Session Runway" priced per model against 5-hour and weekly windows.
-AgentsView ships cache-aware, LiteLLM-priced cost reporting plus a REST usage API.
-
-Zero-fork was the right call for build cost. It buys no position.
-
----
-
-## The field, ranked by how directly it competes
-
-| # | Project | What it is | Source | Store | Team | Editors | Licence | Signal (2026-08-07) |
-|---|---|---|---|---|---|---:|---|---|
-| 1 | **AgentsView** | Go binary + Tauri app + Docker image | reads disk | SQLite/FTS5, opt. DuckDB, opt. **PostgreSQL** | shared pool, free | 50+ | MIT | **4,723★**, 574 forks, 100 contributors, six months old, MCP server, semantic search |
-| 2 | **claude-mem** | npm plugin + MCP + web viewer | **hooks** | SQLite + Chroma, opt. cloud | none | ~8 | Apache-2.0 | **89,967★**, 7,831 forks, **62,940 npm dl/mo**. The category's centre of gravity |
-| 3 | **MemPalace** | local-first memory, verbatim | mixed, mining transcripts | pluggable | none | — | MIT | **58,182★ in four months**, 696 open issues, contested benchmarks |
-| 4 | **deja-vu** | zero-dep Go binary, CLI + MCP + hook | reads disk | `records.bin`, no server | none — personal SSH sync | 17 | MIT | 593★, HN 131 pts, redacts secrets at index |
-| 5 | **Contextify** | macOS app + CLI, cloud **and** self-hosted | reads disk | local + optional cloud | **real**: seats, roles, per-project opt-in | 2 | proprietary / FSL | $8–15/seat/mo; self-host $132/seat/yr |
-| 6 | **ctx** | Rust CLI, event-level provenance | reads disk | local SQLite | **ctx cloud**, hosted, private beta | 8 | Apache-2.0 | 1,013★ |
-| 7 | **SpecStory** | IDE extensions + CLI | **writes its own** | local + cloud | team rollups | 9 | Apache-2.0 | 1,296★; **Team $300/mo**; "Lore" mines history into installable skills |
-| 8 | **Conare** | CLI + hosted, MCP | reads disk | vendor cloud | shared memory, audit logs, SSO | 7 | proprietary | **Team $500/mo** |
-| 9 | **memsearch** | Markdown + Milvus shadow index | Stop hooks | Markdown truth + Milvus | Docker, no isolation | 4 | MIT | 2,431★, Zilliz-backed |
-| 10 | **CCHV** | Tauri app + **headless server** | reads disk | provider files + cache | server mode w/ accounts | 28 | MIT | 2,020★, 45 contributors |
-| 11 | **Agent Sessions** | native macOS app | reads disk | SQLite/FTS5 | none | 10 | MIT | 762★; best-in-class quota metering; resume + write-back restore |
-| 12 | **ContextPool** | CLI + MCP | reads disk | local + repo dir | shared pool, $7.99/mo | 4 | mixed | 188 PH upvotes |
-
-Adjacent and **not** competitors, but they own the vocabulary and the capital:
-mem0 (62.8k★, $24M), cognee (29.8k★), graphiti (29.6k★), supermemory (28.8k★),
-letta (24.1k★, $10M seed), memori (15.7k★), OpenViking (28.1k★, ByteDance),
-Hindsight (19.2k★, $3.6M seed). All of them require the developer to write the
-memory. None ingest agent sessions.
-
----
-
-## What they do better
-
-- **Distribution.** memhouse: 0 stars, 655 npm downloads/month, no HN or search
-  presence. claude-mem: 89,967 stars and 62,940 downloads/month, free, no company.
-  This dominates every other consideration in the document.
-- **Automatic recall.** deja-vu installs a SessionStart hook; claude-mem injects into
-  future sessions; ContextPool loads at session start; SpecStory converts history
-  into *installed skills*. Our skills must be chosen. One independent analysis of 270
-  real sessions found **only 4.8% involved an explicit history query** — a pull-only
-  model gets invoked rarely.
-- **Install weight — still the heaviest in the category, but half the tax is paid.**
-  AgentsView, deja-vu and ctx are single dependency-free binaries via Homebrew, Docker,
-  `go install` or curl. We are Node and need a ClickHouse to point at.
-  **Resolved 2026-08-16:** the native-dependency half is gone. `better-sqlite3` was
-  replaced by `node:sqlite`, so `npm i -g memhouse` with no flags is now a complete,
-  fully working install — no `--allow-scripts`, no build step, and no five-adapters-
-  silently-read-nothing failure mode. What remains of the tax is the runtime (Node,
-  not a static binary), the ClickHouse dependency, and the `EACCES`/`sudo` prefix
-  triage, which was never about the flag and is not fixable from our side.
-- **Semantic search.** AgentsView (opt-in index), claude-mem (Chroma),
-  claude-history (local embedding model). We are FTS-only. Contested rather than
-  settled — deja-vu made the same choice and was criticised for it on HN.
-- **Secret redaction at ingest.** deja-vu redacts credential patterns on index *and*
-  on sync export. Whether we do is *unverified* — and it matters more here than
-  elsewhere, because Claude Code caches unredacted secrets in transcripts
-  (anthropics/claude-code#43675) and we ship those rows to a shared server.
-- **Resume and write-back.** Agent Sessions copies resume commands for six CLIs and
-  restores into the archive; claude-history resumes *and forks* worktree-aware. We
-  read but do not hand the pilot back in.
-- **Price ceiling.** AgentsView gives the whole stack away under MIT. That caps what
-  a self-hosted OSS competitor can charge for.
-
----
-
-## Unclaimed ground
-
-Two positions nobody occupies, both reachable from where we already are.
-
-**1. Evidence and claims as two layers.** The sharpest architectural critique found
-anywhere in the survey, and no product in the field claims to do it: keep the capture
-log and the memory layer distinct. The capture log is chronological evidence; memory
-is a set of derived, revisable claims. Each claim cites the exact spans supporting
-it, records when it was inferred, and marks itself current, disputed or superseded —
-and deletion follows that lineage. This is available **only** to a system that keeps
-verbatim transcripts with provenance. Every extract-only competitor has discarded the
-evidence by the time the claim is written. We and MemPalace are the two systems
-positioned to build it. Neither has.
-
-**2. The 30-day deletion window.** Claude Code deletes JSONL transcripts after 30
-days. Contextify was built because of it; vibe-replay documents it; **nobody markets
-on it.** A durable server-side store is the strongest possible answer, and we are
-better positioned than any local-index tool. This is free ground.
-
----
-
-## Three cautions
-
-**Do not compete on benchmark scores.** The benchmarks are broken. An independent
-LOCOMO audit found 99 score-corrupting errors in 1,540 questions (6.4%), and the
-standard LLM judge accepted 62.81% of adversarially-generated wrong-but-topical
-answers. Nine vendors claim mutually incompatible SOTA on it. MemPalace's claimed
-100% was reverse-engineered publicly to 98.4%, achieved with `top-k=50` — which
-exceeds the session count. deja-vu's 84.9% hit@1 carries the same asterisk. Entering
-this contest means measuring the field against itself.
-
-**Stars are not traction, and are farmed in this category.** `mindverse/Second-Me`
-holds 15,648 stars and has been dead for ten months. MemPalace took 58k stars in four
-months while accumulating 2,183 issues, one titled *"in short: This sucks shit."*
-Screenpipe reportedly mails its stargazers.
-
-**The free incumbent sets the floor.** claude-mem is Apache-2.0, free, no cloud tier,
-no company, one dominant author. Any paid or heavier-install offering is measured
-against that baseline, not against a vendor's price list.
-
----
-
-## Net position
-
-Not differentiated on parse-on-client, editor breadth, self-hosting, analytics, or
-agent-facing skills — all matched or beaten, most comprehensively by AgentsView
-(MIT, free, 50+ editors, 4,723 stars, six months old).
-
-Two things hold: **grant-enforced per-member isolation**, which nobody attempts, and
-**verbatim transcripts with provenance**, which is the prerequisite for the
-evidence/claims separation the field has identified but not built.
-
-The liabilities are zero distribution and the heaviest install in the category.
-Both are fixable; neither is fixed by adding another editor adapter.