nlm-memory 0.21.0 → 0.21.13

package/dist/cli/nlm.js

@@ -22,12 +22,13 @@
  *   nlm disconnect claude-code — remove MCP block from ~/.mcp.json
  *   nlm disconnect codex       — remove Codex plugin
  *   nlm digest   — print a daily-activity digest (or --telegram to post)
+ *   nlm reconcile-facts — retire live facts contradicting an authorities file
  *   nlm init     - print (or write) the agent recall contract snippet
  */
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname, resolve, join } from "node:path";
 import { homedir } from "node:os";
-import { mkdirSync, readFileSync, writeFileSync, existsSync, rmSync, copyFileSync, realpathSync, appendFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync, existsSync, rmSync, copyFileSync, realpathSync, appendFileSync, renameSync } from "node:fs";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { Command } from "commander";
 import pkg from "../../package.json" with { type: "json" };
@@ -39,6 +40,7 @@ import { ProviderRegistry } from "../core/providers/provider-registry.js";
 import { SqliteStorage } from "../core/storage/sqlite-storage.js";
 import { PgStorage } from "../core/storage/pg-storage.js";
 import { applyPendingRestore, stageRestore } from "../core/storage/db-restore.js";
+import { applyRetirements, findContradictions, formatReport, loadAuthorities, } from "../core/facts/reconcile-facts.js";
 import { listBackupDates, resolveBackup, runRollingBackup } from "../core/storage/backup-rotation.js";
 import { createApp } from "../http/app.js";
 import { createMcpServer, listMergeSuggestionsHandler, mergeWorkstreamsHandler, rebindSessionHandler, recallWorkstreamHandler, renameWorkstreamHandler, retireWorkstreamHandler } from "../mcp/server.js";
@@ -50,32 +52,47 @@ import { resolveEmbedderInfo } from "../llm/embedder-info.js";
 import { autoloadEnv } from "../llm/env-autoload.js";
 import { buildEmbedder as _buildEmbedder } from "../llm/build-embedder.js";
 import { addHook, buildHookCommand, removeHook } from "../core/hook/claude-settings.js";
-import { codexBinaryAvailable, connectCodex, disconnectCodex, repairCodex, pluginScriptsDir, } from "../install/codex.js";
-import { connectClaudeCode, disconnectClaudeCode, installClaudeCodeHooks, mcpConfigPath } from "../install/claude-code.js";
+import { codexBinaryAvailable, codexHasEffectiveMcpServer, connectCodex, disconnectCodex, repairCodex, pluginScriptsDir, } from "../install/codex.js";
+import { connectClaudeCode, disconnectClaudeCode, installClaudeCodeHooks, mcpConfigPath, nvmPinnedHookWarning } from "../install/claude-code.js";
 import { evaluateInstallHealth, evaluateModelHealth, evaluateRecallSmoke } from "../install/health.js";
 import { codexConfigPath } from "../install/codex.js";
 import { hardenNlmDirPermissions } from "../install/nlm-dir-perms.js";
 import { embeddingModelPresent, ensureMcpToken, ollamaModelPresent } from "../install/ollama.js";
 import { connectCursor, disconnectCursor } from "../install/cursor.js";
+import { connectLocalSource } from "../install/local-source.js";
+import { defaultDbPath as openCodeDefaultDbPath } from "../core/adapters/opencode.js";
+import { defaultSessionsPath as museDefaultSessionsPath } from "../core/adapters/muse.js";
 import { describeRemove, describeUpsert, installCursorRules, installOpencodeRules, installWindsurfRules, uninstallCursorRules, uninstallOpencodeRules, uninstallWindsurfRules, } from "../install/rules-install.js";
 import { runSupersedeCommand } from "./supersede.js";
 import { runInitCommand } from "./init.js";
+import { DEFAULT_TEAM_ID } from "../core/tenancy/default-team.js";
+import { hashTeamToken } from "../core/tenancy/team-auth.js";
 import { runScopeBackfill, formatBackfillResult } from "./scope-backfill.js";
 import { runScopeCoverage, formatCoverageResult } from "./scope-coverage.js";
 import { loadAliasMap } from "../core/scope/alias-map.js";
 import { getUpdateStatus } from "../core/update-check/check.js";
+import { checkDriftAndAlert, checkEmbedderAndAlert } from "../core/alerts/check-and-alert.js";
+import { fireAlert } from "../core/alerts/fire-alert.js";
+import { buildJobAlertEvent } from "../core/alerts/job-alert.js";
+import { buildWikiDriftEvent, buildWikiFailureEvent } from "../core/alerts/wiki-alert.js";
+import { projectWiki } from "../core/wiki/project.js";
+import { FsWikiWriter } from "../core/adapters/fs-wiki-writer.js";
+import { JobSupervisor } from "../core/jobs/job-supervisor.js";
+import { realClock, createReprocessSpawnChild } from "./reprocess-job-adapters.js";
 import { connectHermes, disconnectHermes, hermesConfigPath } from "../install/hermes.js";
 import { connectHermesAgent, disconnectHermesAgent, hermesAgentPluginDir } from "../install/hermes-agent.js";
 import { connectWindsurf, disconnectWindsurf } from "../install/windsurf.js";
-import { connectPi, disconnectPi, piSettingsPath } from "../install/pi.js";
+import { connectPi, connectPiMcp, disconnectPi, piSettingsPath } from "../install/pi.js";
 import { runSetup } from "../install/setup.js";
 import { runParity } from "./classify-parity.js";
 import { reembedCorpus } from "../core/embedding/embed-backfill.js";
 import { reembedCorpusPg } from "../core/embedding/pg-embed-backfill.js";
 import { backfillExemplarEmbeddings } from "../core/exemplars/embed-backfill.js";
+import { backfillFactEmbeddings } from "../core/facts/embed-backfill.js";
 import { warmCodeEmbedder } from "../core/exemplars/warm-embedder.js";
-import { markWarm } from "../core/health/warmup-state.js";
+import { markWarm, markWarmFailure } from "../core/health/warmup-state.js";
 import { setLaneHealth } from "../core/health/embedding-lane-state.js";
+import { retryUntilWarm } from "../core/health/warmup-retry.js";
 import { setCorpusSnapshot, corpusSnapshot } from "../core/health/corpus-state.js";
 import { computeCorpusStats, sqliteCorpusStatsDeps, parseCorpusThresholds, thresholdState } from "../core/metrics/corpus-stats.js";
 import { computeReDerivationRate, sqliteReDerivationDeps } from "../core/metrics/re-derivation.js";
@@ -118,6 +135,10 @@ function port() {
         return DEFAULT_PORT;
     return n;
 }
+function positiveIntEnv(name, fallback) {
+    const parsed = Number.parseInt(process.env[name] ?? "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
 function ollamaUrl() {
     return process.env["NLM_OLLAMA_URL"] ?? "http://localhost:11434";
 }
@@ -150,6 +171,28 @@ export function shouldAppendTrend(lastLineTs, now) {
         return true;
     return now - parsed >= TREND_INTERVAL_MS;
 }
+/**
+ * Recomputes `computeReDerivationRate` and overwrites the pairs cache file
+ * (#405) that `@core/storage/sqlite-outcome-store.js` reads instead of
+ * recomputing the same O(n^2) scan inline. Called every 24h corpus-monitor
+ * cycle (not gated by `shouldAppendTrend`, which only paces the separate
+ * append-only trend log) so the cache stays ~24h fresh while the monitor
+ * runs. Exported for direct testing and smoke runs against a corpus copy.
+ * `tenantId` scopes both the session scan (sqliteReDerivationDeps) and the
+ * cache file this write targets — two tenants must never compute or read
+ * each other's pairs.
+ */
+export async function persistReDerivationPairs(rawDb, tenantId, pairsPath, windowDays) {
+    const deps = sqliteReDerivationDeps(rawDb, tenantId);
+    const report = await computeReDerivationRate(deps, windowDays);
+    // Write-temp-then-rename: the outcome adapters read this file on every
+    // get_session, so a crash mid-write must never leave truncated JSON at
+    // the final path. rename is atomic within the same directory.
+    const tmpPath = `${pairsPath}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmpPath, JSON.stringify(report.pairs), "utf8");
+    renameSync(tmpPath, pairsPath);
+    return report;
+}
 function loadTopicProvider() {
     try {
         const raw = readFileSync(join(homedir(), ".nlm", "work-topics.json"), "utf8");
@@ -237,14 +280,14 @@ async function reconcileEmbeddingLanes(storage, embedder, codeEmbedder) {
         // probe failure; code lane stays unknown
     }
 }
-async function buildAdapters(sources) {
+async function buildAdapters(sources, tenantId) {
     // Sources table is the source of truth. Each enabled row maps to one
     // adapter via adapterFromSource(). Detection still gates registration —
     // a row pointing at a missing dir won't poll. NLM_ADAPTERS keeps working
     // as a name-based filter for forcing a subset during dev.
     const explicit = process.env["NLM_ADAPTERS"];
     const allowed = explicit ? new Set(explicit.split(",").map((s) => s.trim())) : null;
-    const rows = await sources.list();
+    const rows = await sources.list(tenantId);
     const out = [];
     for (const row of rows) {
         if (!row.enabled)
@@ -290,13 +333,13 @@ async function buildStack() {
     const signals = storage.signals;
     const scope = installScope();
     const sources = storage.sources;
-    await sources.seedDefaults();
+    await sources.seedDefaults(DEFAULT_TEAM_ID);
     const providers = storage.providers;
     // Provider seeding is SQLite-only: it bridges from the local DEEPSEEK_API_KEY
     // env, which is wrong for a hosted multi-tenant PG. PgProviderRegistry has no
     // seedDefaults (not on ProviderRegistryPort), so this narrows to the SQLite case.
     if (providers instanceof ProviderRegistry)
-        await providers.seedDefaults();
+        await providers.seedDefaults(DEFAULT_TEAM_ID);
     // Recall only uses embed(). Default embedder is local Ollama; NLM_EMBED_*
     // can point it at any OpenAI-compatible endpoint. Classifier is wired
     // separately for Phase D ingest.
@@ -307,11 +350,12 @@ async function buildStack() {
         store,
         llm: embedder,
         factStore: facts,
+        learnerDeps: { learners: storage.learners, sessions: store },
         exemplarStore: storage.exemplars,
         codeEmbedder: buildCodeEmbedder(),
         installScope: scope,
         resolveWorkstreamMembers: async (idOrLabel) => {
-            const all = await wsStore.listAll();
+            const all = await wsStore.listAll(DEFAULT_TEAM_ID);
             const byId = new Map(all.map((w) => [w.id, { id: w.id, mergedInto: w.mergedInto }]));
             const target = all.find((w) => w.id === idOrLabel)
                 ?? all.find((w) => normalizeLabel(w.label) === normalizeLabel(idOrLabel));
@@ -364,11 +408,32 @@ program
     // Generate NLM_MCP_TOKEN if missing so /api/* gets Bearer-protected for
     // non-browser callers. Idempotent: re-reads persisted token first.
     autoloadEnv();
-    ensureMcpToken();
+    const mcpToken = ensureMcpToken();
     const { storage, store, facts, signals, scope, sources, providers, recall, factRecall, embedder, classifier } = await buildStack();
+    // Local-mode continuity (program spec §3 M3): idempotently seed the
+    // existing NLM_MCP_TOKEN's hash for the default team, so an install that
+    // already has a token keeps authenticating through the same
+    // resolveTeamByToken path as any future per-team token. No-op after the
+    // first boot (ensureActive is insert-if-absent).
+    await storage.teamTokens.ensureActive(hashTeamToken(mcpToken), DEFAULT_TEAM_ID);
     const { existsSync } = await import("node:fs");
     const hasMcpToken = Boolean(process.env["NLM_MCP_TOKEN"]);
     const codeEmb = buildCodeEmbedder();
+    // Job supervision: owns the daemon's own reprocess child, restarting it
+    // on a non-clean exit while work remains and reporting stalls — see
+    // core/jobs/job-supervisor.ts for why this exists (a detached
+    // `nlm reprocess` died on OOM and sat unobserved).
+    // onEvent -> fireAlert is fire-and-forget on purpose: fireAlert already
+    // never throws (best-effort delivery, see fire-alert.ts) and JobSupervisor
+    // itself catches/logs anything an onEvent callback throws, so this can't
+    // crash the daemon either way.
+    const jobSupervisor = new JobSupervisor({
+        spawnChild: createReprocessSpawnChild({ execPath: process.execPath, nlmScriptPath: __filename }),
+        clock: realClock,
+        onEvent: (event) => {
+            void fireAlert(buildJobAlertEvent(event));
+        },
+    });
     const app = createApp({
         recall,
         store,
@@ -378,7 +443,9 @@ program
         dbPath: dbPath(),
         classifier,
         sources,
+        jobSupervisor,
         providers,
+        teamTokens: storage.teamTokens,
         ingest: {
             classifier,
             embedder,
@@ -387,6 +454,7 @@ program
             classifierDescriptor: { provider: classifier.provider, model: classifier.model },
         },
         signalStore: signals,
+        learnerRecall: { learners: storage.learners, sessions: store },
         installScope: scope,
         // Signal scope inheritance (NLM_SCOPE_STAMP): a signal with only a
         // session_id inherits that session's stamped scope at ingest.
@@ -417,19 +485,29 @@ program
                     sessionScopeReader: store,
                     workDigest: { store, topicProvider: loadTopicProvider(), workstreams: storage.workstreams, ...workDigestEnv() },
                     workstreams: { store: storage.workstreams, sessions: store, facts: facts, exemplars: storage.exemplars },
+                    learners: { store: storage.learners, workstreams: storage.workstreams, sessions: store },
                 },
             }
             : {}),
     });
     warmCodeEmbedder(codeEmb);
     void reconcileEmbeddingLanes(storage, embedder, codeEmb).catch(() => { });
-    void embedder
-        .embed("warmup init", "query")
-        .then(() => markWarm("textEmbedder"))
-        .catch(() => { });
+    // Retried, not one-shot. A single attempt with a swallowed catch latched
+    // this stage cold for the whole uptime whenever the backend was not yet
+    // servable, which is the normal case when the embedder host is started by
+    // hand after a reboot.
+    void retryUntilWarm({
+        attempt: () => embedder.embed("warmup init", "query"),
+        onSuccess: () => {
+            markWarm("textEmbedder");
+            setLaneHealth("prose", "ok");
+        },
+        onFailure: (reason, attempt) => markWarmFailure("textEmbedder", reason, attempt),
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms).unref?.()),
+    });
     setImmediate(() => {
         void recall
-            .search({ query: "warmup init", mode: "keyword", limit: 1 })
+            .search(DEFAULT_TEAM_ID, { query: "warmup init", mode: "keyword", limit: 1 })
             .then(() => markWarm("fts5"))
             .catch(() => { });
     });
@@ -492,17 +570,36 @@ program
     const SIGNAL_PRUNE_INTERVAL_MS = 6 * 60 * 60_000;
     const signalPruneTimer = setInterval(() => {
         const cutoff = new Date(Date.now() - SIGNAL_RETENTION_DAYS * 86_400_000).toISOString();
-        void signals.pruneOlderThan(cutoff).catch(() => { });
+        void signals.pruneOlderThan(DEFAULT_TEAM_ID, cutoff).catch(() => { });
     }, SIGNAL_PRUNE_INTERVAL_MS);
     signalPruneTimer.unref();
-    // Corpus monitor: 24h stats job + weekly re-derivation trend. SQLite only.
-    // First run is delayed ~60s so warmup finishes first; then repeats every 24h.
+    // NLM_ALERT_WEBHOOK self-reporting: version-drift + embedder-cold
+    // transitions POST to an operator-owned webhook. No-op (zero network
+    // calls) when the env var is unset — see core/alerts/fire-alert.ts.
+    const ALERT_DRIFT_CHECK_INTERVAL_MS = 60 * 60_000;
+    const alertDriftTimer = setInterval(() => {
+        void checkDriftAndAlert({ currentVersion: pkg.version }).catch(() => {
+            // Best-effort self-reporting — a failed check never blocks the daemon.
+        });
+    }, ALERT_DRIFT_CHECK_INTERVAL_MS);
+    alertDriftTimer.unref();
+    const ALERT_EMBEDDER_CHECK_INTERVAL_MS = 5 * 60_000;
+    const alertEmbedderTimer = setInterval(() => {
+        void checkEmbedderAndAlert().catch(() => {
+            // Best-effort self-reporting — a failed check never blocks the daemon.
+        });
+    }, ALERT_EMBEDDER_CHECK_INTERVAL_MS);
+    alertEmbedderTimer.unref();
+    // Corpus monitor: 24h stats job + pairs-cache refresh + weekly trend log.
+    // SQLite only. First run is delayed ~60s so warmup finishes first; then
+    // repeats every 24h.
     if (!(storage instanceof PgStorage)) {
         const CORPUS_MONITOR_INTERVAL_MS = 24 * 60 * 60 * 1000;
         const CORPUS_MONITOR_INITIAL_DELAY_MS = 60 * 1000;
         const nlmDataDir = join(homedir(), ".nlm");
         const corpusStatsPath = join(nlmDataDir, "corpus-stats.jsonl");
         const rederivTrendPath = join(nlmDataDir, "re-derivation-trend.jsonl");
+        const rederivPairsPath = join(nlmDataDir, "re-derivation-pairs.json");
         const runCorpusMonitor = async () => {
             try {
                 const sqliteStorage = storage;
@@ -536,9 +633,14 @@ program
                 catch {
                     // file absent or unreadable; treat as no prior entry
                 }
+                // Pairs cache is refreshed every 24h cycle regardless of the trend
+                // gate below - the trend JSONL is an append-only history and stays
+                // on its existing weekly cadence, but the pairs cache is a single
+                // overwritten file so refreshing it daily costs nothing extra and
+                // keeps sqlite-outcome-store.ts's reads within a ~24h staleness
+                // bound (see #405).
+                const report = await persistReDerivationPairs(rawDb, DEFAULT_TEAM_ID, rederivPairsPath, 42);
                 if (shouldAppendTrend(lastTrendTs, now)) {
-                    const rdDeps = sqliteReDerivationDeps(rawDb);
-                    const report = await computeReDerivationRate(rdDeps, 42);
                     appendFileSync(rederivTrendPath, JSON.stringify({ ts, windowDays: 42, rate: report.rate, pairCount: report.pairs.length, eligible: report.eligible }) + "\n", "utf8");
                 }
             }
@@ -549,6 +651,78 @@ program
         const corpusMonitorTimer = setInterval(() => { void runCorpusMonitor(); }, CORPUS_MONITOR_INTERVAL_MS);
         corpusMonitorTimer.unref();
         setTimeout(() => { void runCorpusMonitor(); }, CORPUS_MONITOR_INITIAL_DELAY_MS).unref();
+        // Wiki projection: regenerate the generated markdown tree. SQLite only,
+        // same as the corpus monitor. Idempotent, so a run with no corpus change
+        // writes zero bytes. Failure leaves the previous tree untouched and
+        // self-reports on the operator's webhook if one is configured. Opt-in:
+        // nlm-memory is a published public package, so the projection only
+        // registers (timer, directory, log line) when an operator explicitly
+        // sets NLM_WIKI_DIR — an upgrade must never start writing ~500 markdown
+        // files under a stranger's home directory on its own.
+        const wikiDir = process.env["NLM_WIKI_DIR"];
+        if (wikiDir) {
+            const parsedWikiHours = Number.parseInt(process.env["NLM_WIKI_INTERVAL_HOURS"] ?? "6", 10);
+            const WIKI_INTERVAL_MS = (Number.isFinite(parsedWikiHours) && parsedWikiHours > 0 ? parsedWikiHours : 6) * 60 * 60_000;
+            const WIKI_INITIAL_DELAY_MS = 90 * 1000;
+            const wikiConfig = {
+                minFacts: positiveIntEnv("NLM_WIKI_MIN_FACTS", 3),
+                minSessions: positiveIntEnv("NLM_WIKI_MIN_SESSIONS", 3),
+                linkBase: process.env["NLM_WIKI_LINK_BASE"] ?? `http://127.0.0.1:${p}`,
+            };
+            const wikiTarget = join(wikiDir, "Memory");
+            const runWikiProjection = async () => {
+                try {
+                    const writer = new FsWikiWriter(wikiTarget);
+                    const today = new Date().toISOString().slice(0, 10);
+                    const result = await projectWiki({ facts, writer }, DEFAULT_TEAM_ID, wikiConfig, today);
+                    console.error(`[wiki] ${result.written} written, ${result.unchanged} unchanged, ${result.removed} removed`);
+                    const drift = buildWikiDriftEvent(result);
+                    if (drift)
+                        await fireAlert(drift);
+                }
+                catch (e) {
+                    console.error(`[wiki] error: ${e instanceof Error ? e.message : String(e)}`);
+                    await fireAlert(buildWikiFailureEvent(e)).catch(() => {
+                        // Self-reporting is best-effort; a webhook outage never escalates.
+                    });
+                }
+            };
+            console.error(`  wiki: enabled, projecting to ${wikiTarget}`);
+            const wikiTimer = setInterval(() => { void runWikiProjection(); }, WIKI_INTERVAL_MS);
+            wikiTimer.unref();
+            setTimeout(() => { void runWikiProjection(); }, WIKI_INITIAL_DELAY_MS).unref();
+        }
+    }
+    // Exemplar embed-backfill: repairs code_exemplars rows whose vector was
+    // dropped by a cold CodeRankEmbed on first capture (see
+    // core/exemplars/embed-backfill.ts). SQLite only, same constraint as the
+    // corpus monitor above — discovery reads code_exemplars_vec directly via
+    // dbPath(). Daily cadence: the drop is a rare cold-embedder race, not a
+    // steady leak, so this just keeps recall_code from silently degrading
+    // between operator-run `nlm embed-backfill --exemplars` passes.
+    if (!(storage instanceof PgStorage) && process.env["NLM_CODE_EXEMPLARS_ENABLED"] === "1") {
+        const EXEMPLAR_BACKFILL_INTERVAL_MS = 24 * 60 * 60 * 1000;
+        const EXEMPLAR_BACKFILL_INITIAL_DELAY_MS = 120 * 1000;
+        const runExemplarBackfill = async () => {
+            try {
+                const report = await backfillExemplarEmbeddings({
+                    tenantId: DEFAULT_TEAM_ID,
+                    dbPath: dbPath(),
+                    embedder: buildCodeEmbedder(),
+                    store: storage.exemplars,
+                });
+                if (report.succeeded > 0 || report.failed > 0) {
+                    console.error(`[exemplar-backfill] ${report.succeeded}/${report.total} repaired (${report.failed} failed)`);
+                }
+            }
+            catch (e) {
+                console.error(`[exemplar-backfill] error: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        };
+        const exemplarBackfillTimer = setInterval(() => { void runExemplarBackfill(); }, EXEMPLAR_BACKFILL_INTERVAL_MS);
+        exemplarBackfillTimer.unref();
+        setTimeout(() => { void runExemplarBackfill(); }, EXEMPLAR_BACKFILL_INITIAL_DELAY_MS).unref();
+        console.error("  exemplar-backfill: enabled, repair sweep every 24h");
     }
     // Memo sweep runs independently of the transcript scheduler — it's the
     // backstop for SessionEnd hook unreliability (crashes, kill -9, IDE
@@ -558,7 +732,7 @@ program
     memoSweep.start();
     console.error("  memo sweep: dormant cleanup every 5m (threshold 24h)");
     if (opts.scheduler !== false) {
-        const adapters = await buildAdapters(sources);
+        const adapters = await buildAdapters(sources, DEFAULT_TEAM_ID);
         if (adapters.length === 0) {
             console.error("  scheduler: no adapters detected (set NLM_ADAPTERS to force-enable)");
         }
@@ -584,6 +758,10 @@ program
                     clearInterval(checkpointTimer);
                 scheduler.stop();
                 memoSweep.stop();
+                // Reaps an active reprocess child instead of leaving it orphaned
+                // when the daemon exits. stop() is idempotent and a no-op when no
+                // run is active.
+                jobSupervisor.stop();
                 await storage.close();
                 process.exit(0);
             };
@@ -619,7 +797,7 @@ program
     .action(async (query, opts) => {
     const { storage, recall } = await buildStack();
     try {
-        const result = await recall.search({
+        const result = await recall.search(DEFAULT_TEAM_ID, {
             query,
             mode: opts.mode,
             limit: opts.limit,
@@ -653,7 +831,7 @@ program
     .action(async (idOrLabel) => {
     const { storage, store } = await buildStack();
     try {
-        const r = await recallWorkstreamHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, { idOrLabel });
+        const r = await recallWorkstreamHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, DEFAULT_TEAM_ID, { idOrLabel });
         process.stdout.write(r.content[0].text + "\n");
     }
     finally {
@@ -668,7 +846,7 @@ program
     .action(async (sessionId, workstream) => {
     const { storage, store } = await buildStack();
     try {
-        const r = await rebindSessionHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, { sessionId, workstream });
+        const r = await rebindSessionHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, DEFAULT_TEAM_ID, { sessionId, workstream });
         process.stdout.write(r.content[0].text + "\n");
     }
     finally {
@@ -683,7 +861,7 @@ program
     .action(async (from, into) => {
     const { storage, store } = await buildStack();
     try {
-        const r = await mergeWorkstreamsHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, { from, into });
+        const r = await mergeWorkstreamsHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, DEFAULT_TEAM_ID, { from, into });
         process.stdout.write(r.content[0].text + "\n");
     }
     finally {
@@ -698,7 +876,7 @@ program
     .action(async (idOrLabel, label) => {
     const { storage, store } = await buildStack();
     try {
-        const r = await renameWorkstreamHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, { idOrLabel, label });
+        const r = await renameWorkstreamHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, DEFAULT_TEAM_ID, { idOrLabel, label });
         process.stdout.write(r.content[0].text + "\n");
     }
     finally {
@@ -712,7 +890,7 @@ program
     .action(async (idOrLabel) => {
     const { storage, store } = await buildStack();
     try {
-        const r = await retireWorkstreamHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, { idOrLabel });
+        const r = await retireWorkstreamHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, DEFAULT_TEAM_ID, { idOrLabel });
         process.stdout.write(r.content[0].text + "\n");
     }
     finally {
@@ -732,7 +910,7 @@ program
     }
     const { storage, store } = await buildStack();
     try {
-        const r = await listMergeSuggestionsHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, { minScore });
+        const r = await listMergeSuggestionsHandler({ recall: {}, store, workstreams: { store: storage.workstreams, sessions: store, facts: storage.facts, exemplars: storage.exemplars } }, DEFAULT_TEAM_ID, { minScore });
         process.stdout.write(r.content[0].text + "\n");
     }
     finally {
@@ -777,7 +955,7 @@ program
     const { runEval } = await import("../core/eval/run-eval.js");
     const { storage, recall } = await buildStack();
     try {
-        const report = await runEval({ recall }, queries, { mode: opts.mode, k: 5 });
+        const report = await runEval({ recall: { search: (q) => recall.search(DEFAULT_TEAM_ID, q) } }, queries, { mode: opts.mode, k: 5 });
         if (opts.json) {
             process.stdout.write(JSON.stringify(report, null, 2) + "\n");
             return;
@@ -808,7 +986,7 @@ program
     const { installScope: getScope } = await import("../core/signals/install-scope.js");
     try {
         const embedder = buildCodeEmbedder();
-        const result = await recallCode({
+        const result = await recallCode(DEFAULT_TEAM_ID, {
             query,
             installScope: getScope(),
             ...(opts.repo ? { repo: opts.repo } : {}),
@@ -889,7 +1067,7 @@ program
     .option("--json", "emit JSON instead of a human-readable table")
     .action(async (opts) => {
     const { missStats } = await import("../core/recall/miss-log.js");
-    const stats = await missStats(opts.days);
+    const stats = await missStats(DEFAULT_TEAM_ID, opts.days);
     if (opts.json) {
         process.stdout.write(`${JSON.stringify(stats, null, 2)}\n`);
         return;
@@ -924,9 +1102,9 @@ program
     const { readQueryLog } = await import("../core/recall/query-log.js");
     const { readCitationLog } = await import("../core/recall/citation-log.js");
     const [recallEntries, queryEntries, citationEntries] = await Promise.all([
-        readHookRecallLog(opts.days),
-        readQueryLog(opts.days),
-        readCitationLog(opts.days),
+        readHookRecallLog(DEFAULT_TEAM_ID, opts.days),
+        readQueryLog(DEFAULT_TEAM_ID, opts.days),
+        readCitationLog(DEFAULT_TEAM_ID, opts.days),
     ]);
     const result = computePrecision(recallEntries, citationEntries);
     const { perSource, unmeasurable } = computePerSourcePrecision(queryEntries, citationEntries);
@@ -984,7 +1162,7 @@ program
             process.exitCode = 1;
             return;
         }
-        const deps = sqliteReDerivationDeps(store.rawDb());
+        const deps = sqliteReDerivationDeps(store.rawDb(), DEFAULT_TEAM_ID);
         const report = await computeReDerivationRate(deps, opts.window);
         if (opts.json) {
             process.stdout.write(JSON.stringify(report, null, 2) + "\n");
@@ -1016,6 +1194,46 @@ program
         yes: Boolean(opts.yes),
     });
 });
+program
+    .command("reconcile-facts")
+    .description("Find live facts that contradict an authorities file (dry run unless --apply)")
+    .requiredOption("--authorities <file>", "JSON file of authoritative values and deleted files")
+    .option("--apply", "retire the findings (backs up the DB first)")
+    .option("-l, --limit <n>", "max facts changed per run", (v) => Number.parseInt(v, 10), 100)
+    .option("--json", "emit the report as JSON")
+    .action(async (opts) => {
+    if (process.env["NLM_PG_URL"]) {
+        console.error("nlm reconcile-facts: the Postgres backend is not supported yet");
+        process.exit(1);
+    }
+    const storage = SqliteStorage.create({ dbPath: dbPath(), migrationsDir: MIGRATIONS_DIR });
+    try {
+        const db = storage.rawDb();
+        const findings = findContradictions(db, loadAuthorities(opts.authorities));
+        const limit = opts.limit;
+        const applied = opts.apply ? await applyRetirements(db, dbPath(), findings, limit) : null;
+        if (opts.json) {
+            process.stdout.write(JSON.stringify({
+                applied: Boolean(opts.apply),
+                total: findings.length,
+                findings,
+                retired: applied?.retired.map((f) => f.factId) ?? [],
+                backupPath: applied?.backupPath ?? null,
+            }, null, 2) + "\n");
+            return;
+        }
+        console.log(formatReport(findings, limit));
+        if (applied) {
+            console.log(`retired ${applied.retired.length} fact(s); backup: ${applied.backupPath ?? "none"}`);
+        }
+        else {
+            console.log("dry run: nothing written (pass --apply to retire)");
+        }
+    }
+    finally {
+        await storage.close();
+    }
+});
 program
     .command("classify-parity")
     .description("Run TS classifier against ~/.nlm/canonical.sqlite and diff vs persisted Python output")
@@ -1042,13 +1260,39 @@ program
     .option("-l, --limit <n>", "session cap (default: all)", (v) => Number.parseInt(v, 10))
     .option("--state <path>", "resume state file (default ~/.nlm/embed_reembed.state)")
     .option("--exemplars", "instead: embed code_exemplars rows missing a vector (repairs dropped capture embeds)")
+    .option("--facts", "instead: embed active facts missing a vector (repairs dropped ingest embeds)")
     .option("--dry-run", "report dim mismatch and what would be dropped without writing")
     .option("-v, --verbose", "per-session progress on stderr")
     .action(async (opts) => {
+    if (opts.facts) {
+        const { storage } = await buildStack();
+        try {
+            const report = await backfillFactEmbeddings({
+                tenantId: DEFAULT_TEAM_ID,
+                dbPath: dbPath(),
+                embedder: buildEmbedder(),
+                store: storage.facts,
+                ...(opts.limit ? { limit: opts.limit } : {}),
+                ...(opts.verbose
+                    ? {
+                        onProgress: (i, n, id, status) => {
+                            process.stderr.write(`  [${i}/${n}] ${id}  ${status}\n`);
+                        },
+                    }
+                    : {}),
+            });
+            process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+        }
+        finally {
+            await storage.close();
+        }
+        return;
+    }
     if (opts.exemplars) {
         const { storage } = await buildStack();
         try {
             const report = await backfillExemplarEmbeddings({
+                tenantId: DEFAULT_TEAM_ID,
                 dbPath: dbPath(),
                 embedder: buildCodeEmbedder(),
                 store: storage.exemplars,
@@ -1120,7 +1364,7 @@ program
                     },
                 }
                 : {}),
-        });
+        }, DEFAULT_TEAM_ID);
         process.stdout.write(JSON.stringify(report, null, 2) + "\n");
     }
     finally {
@@ -1141,7 +1385,7 @@ program
             await stack.storage.close();
             process.exit(1);
         }
-        const adapters = await buildAdapters(stack.sources);
+        const adapters = await buildAdapters(stack.sources, DEFAULT_TEAM_ID);
         const r = await reclassifyOversized({
             db: stack.storage.rawDb(),
             store: stack.storage.sessions,
@@ -1150,7 +1394,7 @@ program
             classifier: stack.classifier,
             classifierDescriptor: { provider: stack.classifier.provider, model: stack.classifier.model },
             adapters,
-        }, { ...(opts.limit ? { limit: opts.limit } : {}), dryRun: Boolean(opts.dryRun) });
+        }, DEFAULT_TEAM_ID, { ...(opts.limit ? { limit: opts.limit } : {}), dryRun: Boolean(opts.dryRun) });
         console.log(`reclassify-oversized: attempted=${r.attempted} ingested=${r.ingested} ` +
             `lowConfidence=${r.skippedLowConfidence} missingFile=${r.missingFile} failed=${r.failed} ` +
             `| gained entities=${r.entities} decisions=${r.decisions} facts=${r.facts}`);
@@ -1172,7 +1416,59 @@ program
     .option("--dry-run", "print cohort report without writing")
     .option("-v, --verbose", "per-session progress on stderr")
     .option("--force-embed", "proceed even when the stored prose embedding lane mismatches the runtime embedder")
+    .option("--daemon", "submit to the running daemon's job supervisor instead of running in this process (restarts on OOM/crash, reports stalls)")
     .action(async (opts) => {
+    if (opts.daemon) {
+        // Same daemon-call auth pattern as `nlm ui`'s bootstrap-nonce POST:
+        // autoload ~/.nlm/.env so a fresh shell still has NLM_MCP_TOKEN, then
+        // send it as Authorization: Bearer (absent token = local-mode
+        // fallback on the daemon side, never a hard requirement).
+        autoloadEnv();
+        const p = port();
+        const token = process.env["NLM_MCP_TOKEN"];
+        const args = [];
+        if (opts.limit !== undefined)
+            args.push("--limit", String(opts.limit));
+        if (opts.minConfidence !== undefined)
+            args.push("--min-confidence", String(opts.minConfidence));
+        if (opts.onlyNull)
+            args.push("--only-null");
+        for (const tag of opts.excludeModel ?? [])
+            args.push("--exclude-model", tag);
+        if (opts.state)
+            args.push("--state", opts.state);
+        if (opts.dryRun)
+            args.push("--dry-run");
+        if (opts.forceEmbed)
+            args.push("--force-embed");
+        // -v is always added by the daemon's spawn adapter (job-supervisor.ts
+        // parses reprocess's [i/n] progress lines from it) — a local
+        // --verbose here would only affect this short-lived CLI invocation's
+        // own stdout, which prints nothing itself, so it's not forwarded.
+        try {
+            const res = await fetch(`http://localhost:${p}/api/jobs/reprocess`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    ...(token ? { authorization: `Bearer ${token}` } : {}),
+                },
+                body: JSON.stringify({ args }),
+            });
+            const body = await res.json().catch(() => ({}));
+            if (res.status === 202) {
+                console.log(`reprocess --daemon: submitted (${JSON.stringify(body)})`);
+                process.exit(0);
+            }
+            console.error(`reprocess --daemon: daemon returned ${res.status}: ${JSON.stringify(body)}`);
+            process.exit(1);
+        }
+        catch (e) {
+            console.error(`reprocess --daemon: could not reach the daemon at localhost:${p}. Is it running?`);
+            console.error(`  ${e instanceof Error ? e.message : String(e)}`);
+            process.exit(1);
+        }
+        return;
+    }
     const { reprocess: runReprocess } = await import("../core/ingest/reprocess.js");
     const stack = await buildStack();
     try {
@@ -1191,7 +1487,7 @@ program
             classifierDescriptor: { provider: stack.classifier.provider, model: stack.classifier.model },
             embeddingConfig: stack.storage.embeddingConfig,
             embedderDescriptor: { provider: embedderInfo.provider, model: embedderInfo.model },
-        }, {
+        }, DEFAULT_TEAM_ID, {
             ...(opts.limit ? { limit: opts.limit } : {}),
             ...(opts.minConfidence !== undefined ? { minConfidence: opts.minConfidence } : {}),
             ...(opts.onlyNull ? { onlyNull: true } : {}),
@@ -1259,10 +1555,14 @@ program
         sessionScopeReader: store,
         workDigest: { store, topicProvider: loadTopicProvider(), workstreams: storage.workstreams, ...workDigestEnv() },
         workstreams: { store: storage.workstreams, sessions: store, facts: facts, exemplars: storage.exemplars },
+        learners: { store: storage.learners, workstreams: storage.workstreams, sessions: store },
         // Tier-B outcome rollup (#352 phase 2) only has a SQLite adapter today;
         // PgStorage deployments skip get_session's `outcome` field until parity lands.
         ...(storage instanceof SqliteStorage ? { outcomeDb: storage.rawDb() } : {}),
-    });
+    }, 
+    // stdio MCP transport carries no bearer token — it is local-mode only
+    // by construction (program spec §3), bound to the default team.
+    DEFAULT_TEAM_ID);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 });
@@ -1690,6 +1990,9 @@ hook
     console.error("  Session-end hook cleans up ~/.nlm/hook-state/<session>.json on session close.");
     console.error("  To run silently for calibration (no injection): set NLM_HOOK_MODE=shadow in the command.");
     console.error("  To remove: nlm hook uninstall");
+    const nvmWarning = nvmPinnedHookWarning(process.execPath, homedir());
+    if (nvmWarning)
+        console.error(`nlm: ${nvmWarning}`);
 });
 hook
     .command("uninstall")
@@ -1714,13 +2017,19 @@ connect
     .option("--with-hooks", "additionally write absolute paths to ~/.codex/hooks.json (Codex Desktop fallback for openai/codex#16430)")
     .option("--repair", "first strip a stale pre-rename nlm-memory-ts install (config block + plugin + marketplace), then connect")
     .option("--dry-run", "print what would happen without invoking codex")
+    .option("--stdio", "use the stdio transport instead of the shared HTTP endpoint (works with the daemon stopped)")
     .action((opts) => {
     if (!opts.dryRun && !codexBinaryAvailable()) {
         console.error("nlm connect codex: `codex` binary not on PATH. Install via `npm i -g @openai/codex` or `brew install codex`.");
         process.exit(1);
     }
     const source = opts.local ? REPO_ROOT : opts.source;
-    const connectOpts = { source, withHooks: Boolean(opts.withHooks), dryRun: Boolean(opts.dryRun) };
+    const connectOpts = {
+        source,
+        withHooks: Boolean(opts.withHooks),
+        dryRun: Boolean(opts.dryRun),
+        transport: opts.stdio ? "stdio" : "http",
+    };
     const repair = opts.repair
         ? repairCodex(connectOpts, pluginScriptsDir(REPO_ROOT))
         : null;
@@ -1773,17 +2082,25 @@ connect
     .description("Write the nlm-memory MCP server block into ~/.mcp.json")
     .option("--with-hooks", "also install Claude Code session hooks")
     .option("--dry-run", "print what would happen without changing files")
+    .option("--stdio", "use the stdio transport instead of the shared HTTP endpoint (works with the daemon stopped)")
     .action((opts) => {
+    // A fresh shell has no NLM_MCP_TOKEN exported even though ~/.nlm/.env
+    // holds one; the HTTP block needs it. Mirror `nlm ui`'s lookup.
+    autoloadEnv();
+    const transport = opts.stdio ? "stdio" : "http";
     if (opts.dryRun) {
         console.error("nlm connect claude-code (dry run):");
-        console.error(`  write [mcpServers.nlm-memory] to ${mcpConfigPath()}`);
+        console.error(`  write [mcpServers.nlm-memory] (${transport}) to ${mcpConfigPath()}`);
         if (opts.withHooks)
             console.error("  install 6 Claude Code hooks");
         return;
     }
-    const report = connectClaudeCode({ nlmBinPath: __filename, nodeExecPath: process.execPath });
+    const report = connectClaudeCode({ nlmBinPath: __filename, nodeExecPath: process.execPath, transport });
     const action = report.alreadyPresent ? "updated" : "written";
-    console.error(`nlm: [mcpServers.nlm-memory] ${action} → ${report.mcpConfigPath}`);
+    console.error(`nlm: [mcpServers.nlm-memory] ${action} (${report.transport}) → ${report.mcpConfigPath}`);
+    if (report.migratedFromStdio) {
+        console.error("  migrated from stdio → shared HTTP endpoint (one daemon-backed server for every session).");
+    }
     console.error("  Restart Claude Code to activate the MCP server.");
     if (opts.withHooks) {
         const path = claudeSettingsPath();
@@ -1800,20 +2117,31 @@ connect
             process.exit(1);
         }
         console.error(`nlm: ${result.count} hooks installed → ${path}`);
+        const nvmWarning = nvmPinnedHookWarning(process.execPath, homedir());
+        if (nvmWarning)
+            console.error(`nlm: ${nvmWarning}`);
     }
 });
 connect
     .command("hermes")
     .description("Write the nlm-memory MCP server entry into ~/.hermes/config.yaml")
     .option("--dry-run", "print what would happen without changing files")
+    .option("--stdio", "use the stdio transport instead of the shared HTTP endpoint (works with the daemon stopped)")
     .action((opts) => {
+    // A fresh shell has no NLM_MCP_TOKEN exported even though ~/.nlm/.env
+    // holds one; the HTTP block needs it. Mirror `nlm ui`'s lookup.
+    autoloadEnv();
+    const transport = opts.stdio ? "stdio" : "http";
     if (opts.dryRun) {
-        console.error(`nlm connect hermes (dry run): write [mcp_servers.nlm-memory] to ${hermesConfigPath()}`);
+        console.error(`nlm connect hermes (dry run): write [mcp_servers.nlm-memory] (${transport}) to ${hermesConfigPath()}`);
         return;
     }
-    const report = connectHermes({ nlmBinPath: __filename, nodeExecPath: process.execPath, dryRun: false });
+    const report = connectHermes({ nlmBinPath: __filename, nodeExecPath: process.execPath, dryRun: false, transport });
     const action = report.alreadyPresent ? "updated" : "written";
-    console.error(`nlm: [mcp_servers.nlm-memory] ${action} → ${report.configPath}`);
+    console.error(`nlm: [mcp_servers.nlm-memory] ${action} (${report.transport}) → ${report.configPath}`);
+    if (report.migratedFromStdio) {
+        console.error("  migrated from stdio → shared HTTP endpoint (one daemon-backed server for every session).");
+    }
     console.error("  Restart Hermes to activate the MCP server.");
 });
 connect
@@ -1848,7 +2176,7 @@ connect
     const storage = SqliteStorage.create({ dbPath: dbPath(), migrationsDir: MIGRATIONS_DIR });
     await storage.init();
     try {
-        const report = await connectCursor(storage.sources, {
+        const report = await connectCursor(storage.sources, DEFAULT_TEAM_ID, {
             ...(opts.dbPath ? { dbPath: opts.dbPath } : {}),
             dryRun: Boolean(opts.dryRun),
         });
@@ -1880,7 +2208,7 @@ connect
     const storage = SqliteStorage.create({ dbPath: dbPath(), migrationsDir: MIGRATIONS_DIR });
     await storage.init();
     try {
-        const report = await connectWindsurf(storage.sources, {
+        const report = await connectWindsurf(storage.sources, DEFAULT_TEAM_ID, {
             ...(opts.userDir ? { userDir: opts.userDir } : {}),
             dryRun: Boolean(opts.dryRun),
         });
@@ -1904,30 +2232,66 @@ connect
 connect
     .command("opencode")
     .description("Register OpenCode as an nlm source (reads opencode.db directly) and optionally install rules nudge")
+    .option("--db-path <path>", "override path to opencode.db")
     .option("--with-rules", "also install global rules nudge at ~/.config/opencode/AGENTS.md")
     .option("--dry-run", "print what would happen without changing files")
-    .action((opts) => {
+    .action(async (opts) => {
+    const spec = {
+        kind: "opencode",
+        name: "OpenCode",
+        runtimeLabel: "opencode/1.0",
+        path: opts.dbPath ?? openCodeDefaultDbPath(),
+    };
+    await connectLocalSourceCommand(spec, Boolean(opts.dryRun));
     if (opts.dryRun) {
-        console.error("nlm connect opencode (dry run):");
-        console.error("  OpenCode adapter is already wired via migrations/010_sources_opencode.sql — no source-registry mutation required");
         if (opts.withRules)
-            console.error("  install global rules nudge at ~/.config/opencode/AGENTS.md");
+            console.error("  also install global rules nudge at ~/.config/opencode/AGENTS.md");
         return;
     }
-    console.error("nlm: OpenCode source already registered (see migration 010). No source-registry changes needed.");
     if (opts.withRules) {
         const rules = installOpencodeRules();
         console.error(`  ${describeUpsert("OpenCode", rules)}`);
     }
-    else {
-        console.error("  Pass --with-rules to install the recall nudge at ~/.config/opencode/AGENTS.md");
-    }
 });
+connect
+    .command("muse")
+    .description("Register Muse as an nlm source (reads its session store directly — no files installed)")
+    .option("--sessions-path <path>", "override path to the Muse sessions directory")
+    .option("--dry-run", "print what would happen without changing files")
+    .action(async (opts) => {
+    await connectLocalSourceCommand({
+        kind: "muse",
+        name: "Muse",
+        runtimeLabel: "muse/1.0",
+        path: opts.sessionsPath ?? museDefaultSessionsPath(),
+    }, Boolean(opts.dryRun));
+});
+async function connectLocalSourceCommand(spec, dryRun) {
+    const storage = SqliteStorage.create({ dbPath: dbPath(), migrationsDir: MIGRATIONS_DIR });
+    await storage.init();
+    try {
+        const report = await connectLocalSource(storage.sources, DEFAULT_TEAM_ID, spec, { dryRun });
+        const missing = report.exists ? "" : " (not found yet)";
+        if (dryRun) {
+            console.error(`nlm connect ${spec.kind} (dry run): register source at ${report.path}${missing}`);
+            return;
+        }
+        console.error(`nlm: ${spec.name} source ${report.action} → ${report.path}${missing}`);
+        console.error("  restart the daemon to start scanning it");
+    }
+    finally {
+        await storage.close();
+    }
+}
 connect
     .command("pi")
-    .description("Register the nlm-memory prompt-recall extension in ~/.pi/agent/settings.json")
+    .description("Register the nlm-memory prompt-recall extension + MCP server for pi")
     .option("--dry-run", "print what would happen without changing files")
+    .option("--stdio", "use the stdio transport instead of the shared HTTP endpoint (works with the daemon stopped)")
     .action((opts) => {
+    // The HTTP block needs NLM_MCP_TOKEN, which a fresh shell has not exported.
+    autoloadEnv();
+    const transport = opts.stdio ? "stdio" : "http";
     const pluginDir = join(REPO_ROOT, "nlm");
     const report = connectPi({ pluginDir, dryRun: Boolean(opts.dryRun) });
     if (opts.dryRun) {
@@ -1942,6 +2306,19 @@ connect
         console.error(`nlm: pi extension registered → ${report.settingsPath}`);
         console.error(`  Packages entry: ${report.pluginDir}`);
     }
+    // Two different files: the extension supplies the hook, mcp.json supplies
+    // the callable tools. pi core has no MCP concept; pi-mcp-adapter reads it.
+    const mcp = connectPiMcp({
+        transport,
+        nlmBinPath: __filename,
+        nodeExecPath: process.execPath,
+        dryRun: Boolean(opts.dryRun),
+    });
+    const mcpVerb = opts.dryRun ? "would write" : (mcp.alreadyPresent ? "updated" : "written");
+    console.error(`nlm: [mcpServers.nlm-memory] ${mcpVerb} (${mcp.transport}) → ${mcp.mcpConfigPath}`);
+    if (mcp.migratedFromStdio) {
+        console.error("  migrated from stdio → shared HTTP endpoint (one daemon-backed server for every session).");
+    }
     console.error("  Restart pi to activate the prompt-recall hook.");
     console.error("  Set NLM_HOOK_MODE=live in ~/.nlm/.env to flip from shadow → live.");
 });
@@ -1953,6 +2330,7 @@ disconnect
     .description("Remove the nlm-memory plugin + marketplace from Codex")
     .option("--with-hooks", "also strip our entries from ~/.codex/hooks.json")
     .option("--dry-run", "print what would happen without invoking codex")
+    .option("--stdio", "use the stdio transport instead of the shared HTTP endpoint (works with the daemon stopped)")
     .action((opts) => {
     if (!opts.dryRun && !codexBinaryAvailable()) {
         console.error("nlm disconnect codex: `codex` binary not on PATH.");
@@ -2043,7 +2421,7 @@ disconnect
     const storage = SqliteStorage.create({ dbPath: dbPath(), migrationsDir: MIGRATIONS_DIR });
     await storage.init();
     try {
-        const report = await disconnectCursor(storage.sources, { dryRun: Boolean(opts.dryRun) });
+        const report = await disconnectCursor(storage.sources, DEFAULT_TEAM_ID, { dryRun: Boolean(opts.dryRun) });
         if (opts.dryRun) {
             console.error("nlm disconnect cursor (dry run): disable Cursor source in registry");
             if (opts.withRules)
@@ -2071,7 +2449,7 @@ disconnect
     const storage = SqliteStorage.create({ dbPath: dbPath(), migrationsDir: MIGRATIONS_DIR });
     await storage.init();
     try {
-        const report = await disconnectWindsurf(storage.sources, { dryRun: Boolean(opts.dryRun) });
+        const report = await disconnectWindsurf(storage.sources, DEFAULT_TEAM_ID, { dryRun: Boolean(opts.dryRun) });
         if (opts.dryRun) {
             console.error("nlm disconnect windsurf (dry run): disable Windsurf source in registry");
             if (opts.withRules)
@@ -2149,7 +2527,7 @@ program
     const storage = await buildStorage(dbPath());
     const scope = installScope();
     const sinceTs = new Date(Date.now() - opts.days * 86_400_000).toISOString();
-    const rows = await storage.signals.listForAggregation({ installScope: scope, sinceTs });
+    const rows = await storage.signals.listForAggregation(DEFAULT_TEAM_ID, { installScope: scope, sinceTs });
     const { aggregateFailureModes } = await import("../core/signals/aggregate.js");
     const { recommendActions } = await import("../core/signals/recommend.js");
     const modes = aggregateFailureModes(rows);
@@ -2196,7 +2574,7 @@ program
     const date = resolveDigestDate(opts.date);
     const { storage, store } = await buildStack();
     try {
-        const digest = await buildWorkDigest({ store, topicProvider: loadTopicProvider(), workstreams: storage.workstreams, ...workDigestEnv() }, date);
+        const digest = await buildWorkDigest({ store, topicProvider: loadTopicProvider(), workstreams: storage.workstreams, ...workDigestEnv() }, DEFAULT_TEAM_ID, date);
         console.log(composeWorkDigest(digest));
     }
     finally {
@@ -2246,6 +2624,13 @@ async function gatherInstallProbe() {
         // trust entry is Codex's registry (not nlm's), so it must not trip this check.
         codexStale = txt.includes("@nlm-memory-ts");
     }
+    // Codex plugins contribute MCP servers to the effective configuration
+    // without writing a table into config.toml. Prefer Codex's own resolved
+    // view so `nlm verify` does not report a healthy plugin install as unwired.
+    if (!codexMcp && codexBinaryAvailable()) {
+        codexPresent = true;
+        codexMcp = codexHasEffectiveMcpServer("nlm-memory");
+    }
     const envPath = join(homedir(), ".nlm", ".env");
     return {
         daemon: { reachable, version, expectedVersion: pkg.version },
@@ -2558,7 +2943,7 @@ entitiesCmd
     if (opts.applySafe) {
         for (const s of safe) {
             try {
-                await storage.entities.merge(s.source, s.target);
+                await storage.entities.merge(DEFAULT_TEAM_ID, s.source, s.target);
                 console.log(`merged: ${s.source} -> ${s.target}`);
                 merged++;
             }
@@ -2582,7 +2967,7 @@ entitiesCmd
             const answer = await ask(`merge ${s.source} -> ${s.target}? [y/N] `);
             if (answer.trim().toLowerCase() === "y") {
                 try {
-                    await storage.entities.merge(s.source, s.target);
+                    await storage.entities.merge(DEFAULT_TEAM_ID, s.source, s.target);
                     console.log(`merged: ${s.source} -> ${s.target}`);
                     merged++;
                 }