replen 1.0.40 → 1.2.0

package/README.md

@@ -72,7 +72,7 @@ Every data command accepts `--json` for scripting.
 Three layers, defence-in-depth — at least one will fire:
 
 1. **SessionStart hook** runs `npx replen check-new --hook` at the start of every Claude Code session. If there's anything new, the JSON output appears in the agent's opening context.
-2. **MCP tool** `replen_check_new` is exposed to the agent at all times. The instructions in `CLAUDE.md` tell it to call this tool early in each session.
+2. **MCP tool** `replen_match` is exposed to the agent at all times. The instructions in `CLAUDE.md` tell it to call this once early in each session (it returns the footnote + the candidate inventory).
 3. **CLAUDE.md / AGENTS.md instruction** (idempotent, marker-versioned) is injected into every tracked repo on setup. This is the most reliable layer — survives Claude Code version churn.
 
 Calm-cadence by design: most days are silent. 1-3 actionable matches a month per project.

package/dist/commands.js

@@ -335,7 +335,7 @@ export async function runCheckNew(argv) {
             console.log(`    ${m.oneLine}`);
     }
     console.log("");
-    console.log("Call replen_today for the full writeups.");
+    console.log("Open /replen (replen_match) for the full writeups.");
 }
 // Watch for new matches in the background. Polls /api/mcp/today, diffs against
 // the matchIds seen on the previous poll, prints anything new, and rings the

package/dist/index.js

@@ -26,6 +26,12 @@ Usage:
                              ~/.replen/atlas/ (projects, capabilities,
                              decisions, themes, all cross-linked)
   npx replen logout          Forget saved auth
+  npx replen uninstall       Remove Replen's local footprint (MCP wiring,
+       [--dry-run] [-y]      skills, per-repo doc blocks, ~/.replen). Asks
+       [--root PATH ...]     before each category; nothing goes without a yes.
+                             Server-side profile is untouched (delete that at
+                             app.replen.dev). --dry-run previews, -y skips
+                             prompts.
   npx replen --help          This help
 
 Use replen from a plain shell (no Claude Code / Codex needed):
@@ -96,6 +102,11 @@ async function main() {
         console.log(`\nRestart Claude Code to pick up the change.`);
         return;
     }
+    if (cmd === "uninstall") {
+        const { runUninstall } = await import("./uninstall.js");
+        await runUninstall(argv.slice(1));
+        return;
+    }
     if (cmd === "logout") {
         const { unlink } = await import("node:fs/promises");
         try {

package/dist/init.js

@@ -141,7 +141,14 @@ export async function runInit() {
         savedAt: new Date().toISOString(),
     });
     console.log(`  ✓ Saved auth to ${configPath()}`);
-    await setupMcp(exchange.token, exchange.base);
+    // Let the user choose, up front, which repos Replen works on. Default is
+    // ALL; a subset (or none) gates BOTH the doc-injection inside setupMcp
+    // AND the project registration below, so we never touch a repo they
+    // opted out of. Non-interactive / single-repo / no-repo cases keep the
+    // default automatically.
+    const { chooseRepoScope } = await import("./select-repos.js");
+    const { onlyRepos } = await chooseRepoScope();
+    await setupMcp(exchange.token, exchange.base, { onlyRepos });
     // Phase A: auto-discover the user's local projects, extract tags
     // from manifests, and register them in one shot. Replaces the
     // legacy "paste a GitHub PAT and let us call api.github.com" flow
@@ -149,7 +156,7 @@ export async function runInit() {
     console.log("");
     console.log("  Scanning your local repos for projects…");
     const { syncDiscoveredProjects } = await import("./sync-projects.js");
-    await syncDiscoveredProjects({ token: exchange.token, base: exchange.base });
+    await syncDiscoveredProjects({ token: exchange.token, base: exchange.base, onlyRepos });
     // Phase B: trigger the first ingest and stream progress until the
     // discovered pool is ready (~30-60s). Without this, a new user
     // would open Claude Code and find replen_match returning nothing —

package/dist/inject-instruction.js

@@ -81,11 +81,6 @@ On your **very first response** of each session:
 - The user directly asked for Replen output ("anything from replen
   today?", "what\'s new from replen?"). Just answer.
 
-**Do NOT use \`replen_check_new\` for the conversational footnote.**
-That tool is cursor-based and meant for SessionStart shell hooks.
-\`replen_match\` queries inventory state directly and is the right
-primitive here.
-
 **Don\'t call \`replen_match\` again on subsequent turns** — once
 per session at start only. The user explicitly types
 \`/replen\` if they want a fresh triage mid-session.
@@ -111,12 +106,21 @@ to say "you know I use scrapling elsewhere" — knowing is your job.
 // only repos that Replen can't match against anyway — the injected
 // instruction tells the agent to call `replen_match`, which is a no-op
 // without a registered project.
-async function discoverRepos(explicitRoots) {
+async function discoverRepos(explicitRoots, onlyRepos) {
     // Reuse sync-projects' resolveAndWalk via the previewDiscovery helper
     // so inject and sync-projects find the exact same set of repos.
     const { previewDiscovery } = await import("./sync-projects.js");
     const result = await previewDiscovery(explicitRoots);
-    return result.projects.map((p) => p.localPath);
+    let paths = result.projects.map((p) => p.localPath);
+    // Honour an explicit onboarding scope choice: when the user picked a
+    // subset of repos (or "none"), restrict doc-injection to exactly that
+    // set so we never edit a CLAUDE.md in a repo they opted out of.
+    // `undefined` means "no scope choice made" → inject into all (default).
+    if (onlyRepos !== undefined) {
+        const allow = new Set(onlyRepos);
+        paths = paths.filter((p) => allow.has(p));
+    }
+    return paths;
 }
 function applyToClaudeMd(claudeMdPath) {
     if (!existsSync(claudeMdPath)) {
@@ -256,7 +260,7 @@ async function promptYes(question) {
     });
 }
 export async function injectInstructions(opts = {}) {
-    const repos = await discoverRepos(opts.explicitRoots ?? []);
+    const repos = await discoverRepos(opts.explicitRoots ?? [], opts.onlyRepos);
     const outcome = {
         scanned: repos.length,
         created: 0,

package/dist/mcp-setup.js

@@ -55,25 +55,27 @@ const CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
 const GEMINI_CONFIG = join(homedir(), ".gemini", "settings.json");
 // Read/triage replen MCP tools that are safe to auto-allow so the proactive
 // footnote (replen_match) and in-session triage don't trigger a permission
-// prompt every session. Deliberately EXCLUDES replen_run / replen_handoff /
-// replen_feedback — those trigger pipeline runs / open PRs and should keep
-// prompting for explicit consent.
+// prompt every session. Deliberately EXCLUDES replen_handoff — it opens PRs and
+// should keep prompting for explicit consent.
 const REPLEN_AUTO_ALLOW = [
     "mcp__replen__replen_match",
-    "mcp__replen__replen_check_new",
-    "mcp__replen__replen_analyze",
-    "mcp__replen__replen_state",
     "mcp__replen__replen_record_triage",
-    "mcp__replen__replen_today",
-    "mcp__replen__replen_search",
-    "mcp__replen__replen_starred",
-    "mcp__replen__replen_status",
+    "mcp__replen__replen_state",
+    "mcp__replen__replen_capture_insight",
+    "mcp__replen__replen_recall",
+    "mcp__replen__replen_leaps",
+    "mcp__replen__replen_queue",
+    "mcp__replen__replen_onboard_state",
+    "mcp__replen__replen_set_tags",
+    "mcp__replen__replen_set_capabilities",
+    "mcp__replen__replen_set_versions",
+    "mcp__replen__replen_set_product",
     "mcp__replen__replen_help",
 ];
 // ============================================================================
 // Public entry point
 // ============================================================================
-export async function setupMcp(token, base) {
+export async function setupMcp(token, base, opts = {}) {
     console.log(`  Wiring replen MCP into agent configs…`);
     // Pin the exact latest MCP version (deterministic; avoids npx serving a stale
     // `@^1` build and the spurious upgrade nudge that follows).
@@ -99,10 +101,10 @@ export async function setupMcp(token, base) {
     installSkills();
     // CLAUDE.md / AGENTS.md / GEMINI.md inject is the proactive-surfacing
     // mechanism for each host. Without it, the agent doesn't know to
-    // call replen_check_new at session start. Idempotent + versioned.
+    // call replen_match at session start. Idempotent + versioned.
     console.log("");
     const { injectInstructions, summariseOutcome } = await import("./inject-instruction.js");
-    const outcome = await injectInstructions();
+    const outcome = await injectInstructions({ onlyRepos: opts.onlyRepos });
     const summary = summariseOutcome(outcome);
     if (summary)
         console.log(summary);

package/dist/project-init.js

@@ -25,12 +25,11 @@ Total length target: 200-500 words, bullet points over paragraphs.
 
 Also append a short "## Replen integration" section with this exact guidance:
 
-  At the start of every session, if the \`replen_check_new\` tool is
-  available, call it once before asking the user what to work on.
-  If \`hasNew\` is true, summarise the count + repos in 1-2 lines and
-  ask if the user wants the full writeups (which they get via
-  \`replen_today\`). If \`hasNew\` is false, say nothing — silence is
-  the correct response, not "no new matches found".
+  At the start of every session, if the \`replen_match\` tool is
+  available, call it once (no repo arg — it defaults to the cwd repo)
+  before asking the user what to work on. Relay the USER-FACING MESSAGE
+  block it returns VERBATIM if it's non-empty; if it's empty, say
+  nothing — silence is the correct response, not "no new matches found".
 
 This instruction is a fallback for AI tools that don't run Claude Code's SessionStart hooks (e.g. Codex, Cursor, Aider). For Claude Code users the hook calls \`replen check-new\` automatically and Claude Code injects the result into the opening context — but the CLAUDE.md guidance is durable across tools and survives hook misconfiguration.`;
 export function runProjectInit() {

package/dist/select-repos.js

@@ -0,0 +1,108 @@
+// Onboarding repo-scope choice. Run once during `npx replen`, AFTER auth
+// and BEFORE we wire MCP / inject docs / register projects, so the user
+// decides up front which of their repos Replen works on.
+//
+// Default is ALL — the cross-repo view (Atlas, Recall, far-away matches)
+// is the product's value, and most users want everything in. But a
+// cautious first-time user (or anyone testing) can scope to a subset, or
+// opt out entirely, and that choice gates BOTH server registration AND
+// the per-repo CLAUDE.md/AGENTS.md/GEMINI.md doc edits — Replen never
+// touches a repo they didn't pick.
+//
+// Returns `{ onlyRepos }`:
+//   - undefined  → "all" (no scope restriction; the default everywhere)
+//   - string[]   → exactly these absolute localPaths (may be empty = none)
+import { createInterface } from "node:readline/promises";
+import { previewDiscovery } from "./sync-projects.js";
+export async function chooseRepoScope() {
+    // Discover the same set inject + sync will see.
+    let projects = [];
+    try {
+        const result = await previewDiscovery([]);
+        projects = result.projects;
+    }
+    catch {
+        return {}; // discovery failed — fall back to default (all)
+    }
+    // Nothing to choose, or non-interactive (CI / hook / piped): keep the
+    // default. We never block onboarding on a prompt that can't be answered.
+    if (projects.length === 0)
+        return {};
+    if (!process.stdin.isTTY)
+        return {};
+    // A single repo isn't worth a selection menu — just include it.
+    if (projects.length === 1)
+        return {};
+    const home = process.env.HOME ?? "";
+    const label = (p) => {
+        const disp = home && p.localPath.startsWith(home) ? "~" + p.localPath.slice(home.length) : p.localPath;
+        return p.githubFullName ? `${p.githubFullName}  (${disp})` : disp;
+    };
+    console.log("");
+    console.log(`  Replen found ${projects.length} repos it can work with.`);
+    console.log("  Replen works best across all of them — that's how it spots a tool you");
+    console.log("  use in one project that fits another. You can also start with a subset.");
+    console.log("");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const choice = (await rl.question("  Include  [A]ll (default) · [s]elect a subset · [n]one for now? "))
+            .trim()
+            .toLowerCase();
+        if (choice === "" || choice === "a" || choice === "all") {
+            return {}; // all
+        }
+        if (choice === "n" || choice === "none") {
+            console.log("  · None for now. Run `npx replen sync-projects` anytime to add them.");
+            return { onlyRepos: [] };
+        }
+        // Subset: show the numbered list and parse an inclusion spec.
+        console.log("");
+        projects.forEach((p, i) => console.log(`    ${String(i + 1).padStart(2)}. ${label(p)}`));
+        console.log("");
+        const spec = (await rl.question("  Numbers to include (e.g. 1,3,5 or 1-4,7), blank = all: ")).trim();
+        if (spec === "")
+            return {}; // blank ⇒ all
+        const picked = parseSelection(spec, projects.length);
+        if (picked.size === 0) {
+            console.log("  · Nothing parsed from that — including all.");
+            return {};
+        }
+        const onlyRepos = projects.filter((_, i) => picked.has(i + 1)).map((p) => p.localPath);
+        console.log(`  ✓ Including ${onlyRepos.length} of ${projects.length} repos.`);
+        return { onlyRepos };
+    }
+    catch {
+        return {}; // any prompt error ⇒ safe default (all)
+    }
+    finally {
+        rl.close();
+    }
+}
+// Parse "1,3,5" / "1-4" / "2-3,7" into a set of 1-based indices, clamped
+// to [1, max]. Tolerant of spaces and stray separators.
+export function parseSelection(spec, max) {
+    const out = new Set();
+    for (const part of spec.split(",")) {
+        const token = part.trim();
+        if (!token)
+            continue;
+        const range = token.match(/^(\d+)\s*-\s*(\d+)$/);
+        if (range) {
+            let lo = parseInt(range[1], 10);
+            let hi = parseInt(range[2], 10);
+            if (lo > hi)
+                [lo, hi] = [hi, lo];
+            for (let n = lo; n <= hi; n++)
+                if (n >= 1 && n <= max)
+                    out.add(n);
+            continue;
+        }
+        const single = token.match(/^\d+$/);
+        if (single) {
+            const n = parseInt(token, 10);
+            if (n >= 1 && n <= max)
+                out.add(n);
+        }
+    }
+    return out;
+}

package/dist/sync-projects.js

@@ -9,8 +9,14 @@
 import { readConfig, writeConfig } from "./config.js";
 import { discoverProjects } from "./discover-projects.js";
 import { promptForRoot, rootsFromClaudeJson, rootsFromConfig, rootsFromCwdWalkUp, rootsFromEnv, rootsFromFlag, rootsFromHardcoded, } from "./discover-roots.js";
-export async function syncDiscoveredProjects({ token, base, explicitRoots = [], }) {
+export async function syncDiscoveredProjects({ token, base, explicitRoots = [], onlyRepos, }) {
     const { result, source, prompted } = await resolveAndWalk(explicitRoots);
+    // Apply the onboarding scope choice before reporting / registering, so
+    // a user who picked a subset never has the opted-out repos registered.
+    if (onlyRepos !== undefined) {
+        const allow = new Set(onlyRepos);
+        result.projects = result.projects.filter((p) => allow.has(p.localPath));
+    }
     // Tell the user what we did, regardless of outcome.
     reportDiscovery(result, source);
     if (result.projects.length === 0) {

package/dist/uninstall.js

@@ -0,0 +1,504 @@
+// `npx replen uninstall` — reverse every local change `npx replen` made,
+// interactively and per-category, so a tester (or anyone) can cleanly back
+// out. The inverse of mcp-setup.ts + skill-install.ts + inject-instruction.ts.
+//
+// Design constraints (deliberate):
+//   - INTERACTIVE BY DEFAULT. Every destructive category asks its own
+//     y/N question, and the default is always NO. There is no single
+//     "nuke everything" keystroke — the user has to acknowledge each
+//     class of change so they understand what's being removed.
+//   - LOCAL ONLY. This touches the user's machine; it does NOT delete
+//     server-side data (project profiles, capabilities, matches). There
+//     is no account-delete endpoint yet — we tell the user how to request
+//     that separately rather than pretending we did it.
+//   - BACKUP BEFORE WRITE. Any host config we edit gets a timestamped
+//     `.bak` first, mirroring mcp-setup's contract, so even an unwanted
+//     removal is recoverable.
+//   - Per-repo doc edits are git-tracked, so stripping the Replen section
+//     shows up as a normal diff the user can review or revert.
+//
+// Flags:
+//   --yes / -y   Skip the per-category prompts (scripted / CI use). Still
+//                prints exactly what it removed.
+//   --dry-run    Show what WOULD be removed, change nothing.
+//   --root PATH  Extra root(s) to scan for repos with injected doc blocks
+//                (same semantics as `sync-projects --root`).
+import { readFileSync, writeFileSync, existsSync, rmSync, renameSync, chmodSync, mkdirSync, } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname, basename } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { configPath } from "./config.js";
+const SERVER_NAME = "replen";
+const CLAUDE_CONFIG = join(homedir(), ".claude.json");
+const CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
+const CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
+const GEMINI_CONFIG = join(homedir(), ".gemini", "settings.json");
+const CLAUDE_SKILLS = join(homedir(), ".claude", "skills");
+const REPLEN_DIR = join(homedir(), ".replen");
+// Must match mcp-setup.ts: the tools it adds to permissions.allow and the
+// substring marker on the SessionStart hook command.
+const REPLEN_AUTO_ALLOW_PREFIX = "mcp__replen__";
+const HOOK_MARKER = "check-new --hook";
+// Must match inject-instruction.ts.
+const SECTION_HEADER = "## Replen integration";
+const MARKER_RE = /<!--\s*replen-integration:\s*v(\d+)\s*-->/;
+// The auto-generated stub header we write into a freshly-created doc, so we
+// can recognise a file that exists ONLY because Replen created it.
+const STUB_HINT = "the Replen integration section below is auto-managed";
+const SKILL_DIRS = ["replen", "replen-onboard"];
+export async function runUninstall(argv) {
+    const opts = {
+        yes: argv.includes("--yes") || argv.includes("-y"),
+        dryRun: argv.includes("--dry-run"),
+        explicitRoots: collectRoots(argv),
+    };
+    banner(opts);
+    // Top-level gate. Even with the per-category prompts below, the user
+    // confirms once up front that they understand what "uninstall" means.
+    if (!opts.yes && !opts.dryRun) {
+        const go = await confirm("Continue with uninstall?", false);
+        if (!go) {
+            console.log("\n  Nothing changed. Replen is still installed.");
+            return;
+        }
+    }
+    await removeMcpWiring(opts);
+    await removeSkills(opts);
+    await removeDocBlocks(opts);
+    await removeLocalConfig(opts);
+    console.log("");
+    if (opts.dryRun) {
+        console.log("  Dry run — nothing was changed. Re-run without --dry-run to apply.");
+    }
+    else {
+        console.log("  Done. Restart Claude Code / Codex / Gemini to drop the MCP server.");
+    }
+    console.log("");
+    console.log("  Note: this removed Replen from THIS machine only. Your server-side");
+    console.log("  profile (project capabilities, match history) still exists. To delete");
+    console.log("  that too, sign in at https://app.replen.dev and use account deletion,");
+    console.log("  or email support@replen.dev to request a full purge.");
+}
+// ============================================================================
+// Category 1 — MCP wiring across the three host configs + the allowlist + hook
+// ============================================================================
+async function removeMcpWiring(opts) {
+    // Probe what's actually present so we don't prompt about nothing.
+    const targets = [
+        {
+            label: "Claude Code MCP + SessionStart hook",
+            path: CLAUDE_CONFIG,
+            present: () => jsonHasServer(CLAUDE_CONFIG) || jsonHasHook(CLAUDE_CONFIG),
+            remove: () => stripClaudeConfig(),
+        },
+        {
+            label: "Claude Code tool allowlist",
+            path: CLAUDE_SETTINGS,
+            present: () => jsonHasAllow(CLAUDE_SETTINGS),
+            remove: () => stripClaudeAllowlist(),
+        },
+        {
+            label: "Codex MCP server",
+            path: CODEX_CONFIG,
+            present: () => tomlHasServer(CODEX_CONFIG),
+            remove: () => stripTomlServer(CODEX_CONFIG),
+        },
+        {
+            label: "Gemini CLI MCP server",
+            path: GEMINI_CONFIG,
+            present: () => jsonHasServer(GEMINI_CONFIG),
+            remove: () => stripJsonServer(GEMINI_CONFIG),
+        },
+    ];
+    const found = targets.filter((t) => safe(t.present));
+    if (found.length === 0) {
+        console.log("\n  ① MCP wiring — none found, skipping.");
+        return;
+    }
+    console.log("\n  ① MCP wiring found in:");
+    for (const t of found)
+        console.log(`       • ${t.label}  (${t.path})`);
+    if (!(await gate(opts, "Remove the replen MCP entries above?"))) {
+        console.log("       · kept.");
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    for (const t of found) {
+        try {
+            t.remove();
+            console.log(`       ✓ removed: ${t.label}`);
+        }
+        catch (e) {
+            console.warn(`       ⚠ ${t.label}: ${e.message}`);
+        }
+    }
+}
+// ============================================================================
+// Category 2 — installed skills
+// ============================================================================
+async function removeSkills(opts) {
+    const present = SKILL_DIRS.map((n) => join(CLAUDE_SKILLS, n)).filter((p) => existsSync(p));
+    if (present.length === 0) {
+        console.log("\n  ② Skills — none found, skipping.");
+        return;
+    }
+    console.log("\n  ② Installed skills:");
+    for (const p of present)
+        console.log(`       • ${p}`);
+    if (!(await gate(opts, "Remove these skill directories?"))) {
+        console.log("       · kept.");
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    for (const p of present) {
+        try {
+            rmSync(p, { recursive: true, force: true });
+            console.log(`       ✓ removed: ${basename(p)}`);
+        }
+        catch (e) {
+            console.warn(`       ⚠ ${p}: ${e.message}`);
+        }
+    }
+}
+// ============================================================================
+// Category 3 — the "## Replen integration" block in per-repo doc files
+// ============================================================================
+async function removeDocBlocks(opts) {
+    let repos = [];
+    try {
+        const { previewDiscovery } = await import("./sync-projects.js");
+        const result = await previewDiscovery(opts.explicitRoots);
+        repos = result.projects.map((p) => p.localPath);
+    }
+    catch {
+        repos = [];
+    }
+    // Find every doc file under those repos that carries our section.
+    const hits = [];
+    for (const repo of repos) {
+        for (const fileName of ["CLAUDE.md", "AGENTS.md", "GEMINI.md"]) {
+            const file = join(repo, fileName);
+            if (!existsSync(file))
+                continue;
+            let text;
+            try {
+                text = readFileSync(file, "utf8");
+            }
+            catch {
+                continue;
+            }
+            if (!hasReplenSection(text))
+                continue;
+            hits.push({ file, stubOnly: isStubOnly(text) });
+        }
+    }
+    if (hits.length === 0) {
+        console.log("\n  ③ Per-repo doc edits — none found, skipping.");
+        if (repos.length === 0) {
+            console.log("       (no repos discovered — pass --root PATH if your code lives somewhere non-conventional)");
+        }
+        return;
+    }
+    console.log(`\n  ③ "${SECTION_HEADER}" blocks found in ${hits.length} file(s):`);
+    for (const h of hits.slice(0, 10)) {
+        console.log(`       • ${h.file}${h.stubOnly ? "   (Replen-created — will delete whole file)" : "   (strip section, keep your content)"}`);
+    }
+    if (hits.length > 10)
+        console.log(`       … and ${hits.length - 10} more`);
+    console.log("       These are git-tracked, so the change shows as a normal diff you can review.");
+    if (!(await gate(opts, "Strip the Replen section from these files?"))) {
+        console.log("       · kept.");
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    for (const h of hits) {
+        try {
+            if (h.stubOnly) {
+                rmSync(h.file, { force: true });
+                console.log(`       ✓ deleted (Replen-created): ${h.file}`);
+            }
+            else {
+                writeFileSync(h.file, stripReplenSection(readFileSync(h.file, "utf8")));
+                console.log(`       ✓ stripped section: ${h.file}`);
+            }
+        }
+        catch (e) {
+            console.warn(`       ⚠ ${h.file}: ${e.message}`);
+        }
+    }
+}
+// ============================================================================
+// Category 4 — ~/.replen (auth token + saved roots + Atlas vault export)
+// ============================================================================
+async function removeLocalConfig(opts) {
+    if (!existsSync(REPLEN_DIR)) {
+        console.log("\n  ④ Local config (~/.replen) — none found, skipping.");
+        return;
+    }
+    const cfg = existsSync(configPath());
+    const atlas = existsSync(join(REPLEN_DIR, "atlas"));
+    console.log("\n  ④ Local Replen directory:");
+    console.log(`       • ${REPLEN_DIR}`);
+    if (cfg)
+        console.log("         - config.json (auth token + saved project roots)");
+    if (atlas)
+        console.log("         - atlas/ (your exported knowledge-graph vault)");
+    if (!(await gate(opts, "Remove ~/.replen entirely?"))) {
+        console.log("       · kept (you stay signed in).");
+        return;
+    }
+    if (opts.dryRun)
+        return;
+    try {
+        rmSync(REPLEN_DIR, { recursive: true, force: true });
+        console.log("       ✓ removed: ~/.replen");
+    }
+    catch (e) {
+        console.warn(`       ⚠ ${REPLEN_DIR}: ${e.message}`);
+    }
+}
+// ============================================================================
+// Host-config mutation helpers (mirror mcp-setup's read/backup/atomic-write)
+// ============================================================================
+function jsonHasServer(path) {
+    const c = readJson(path);
+    const servers = c.mcpServers;
+    return !!servers && SERVER_NAME in servers;
+}
+function jsonHasHook(path) {
+    const c = readJson(path);
+    const ss = c.hooks?.SessionStart;
+    if (!Array.isArray(ss))
+        return false;
+    return ss.some((e) => (e.hooks ?? []).some((h) => typeof h.command === "string" && h.command.includes(HOOK_MARKER)));
+}
+function jsonHasAllow(path) {
+    const c = readJson(path);
+    const allow = c.permissions?.allow;
+    return Array.isArray(allow) && allow.some((a) => typeof a === "string" && a.startsWith(REPLEN_AUTO_ALLOW_PREFIX));
+}
+function tomlHasServer(path) {
+    const c = readTomlSafe(path);
+    const servers = c.mcp_servers;
+    return !!servers && SERVER_NAME in servers;
+}
+// Remove mcpServers.replen AND our SessionStart hook from ~/.claude.json.
+function stripClaudeConfig() {
+    const c = readJson(CLAUDE_CONFIG);
+    const servers = c.mcpServers ?? {};
+    delete servers[SERVER_NAME];
+    const hooks = c.hooks ?? {};
+    const ss = hooks.SessionStart ?? [];
+    const cleanedSS = ss.filter((e) => !(e.hooks ?? []).some((h) => typeof h.command === "string" && h.command.includes(HOOK_MARKER)));
+    const nextHooks = { ...hooks };
+    if (cleanedSS.length > 0)
+        nextHooks.SessionStart = cleanedSS;
+    else
+        delete nextHooks.SessionStart;
+    const next = { ...c, mcpServers: servers };
+    if (Object.keys(nextHooks).length > 0)
+        next.hooks = nextHooks;
+    else
+        delete next.hooks;
+    if (Object.keys(servers).length === 0)
+        delete next.mcpServers;
+    backupIfExists(CLAUDE_CONFIG);
+    writeJsonAtomic(CLAUDE_CONFIG, next);
+}
+function stripClaudeAllowlist() {
+    const c = readJson(CLAUDE_SETTINGS);
+    const permissions = c.permissions ?? {};
+    const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+    const kept = allow.filter((a) => !(typeof a === "string" && a.startsWith(REPLEN_AUTO_ALLOW_PREFIX)));
+    const nextPerms = { ...permissions };
+    if (kept.length > 0)
+        nextPerms.allow = kept;
+    else
+        delete nextPerms.allow;
+    const next = { ...c };
+    if (Object.keys(nextPerms).length > 0)
+        next.permissions = nextPerms;
+    else
+        delete next.permissions;
+    backupIfExists(CLAUDE_SETTINGS);
+    writeJsonAtomic(CLAUDE_SETTINGS, next);
+}
+function stripJsonServer(path) {
+    const c = readJson(path);
+    const servers = c.mcpServers ?? {};
+    delete servers[SERVER_NAME];
+    const next = { ...c, mcpServers: servers };
+    if (Object.keys(servers).length === 0)
+        delete next.mcpServers;
+    backupIfExists(path);
+    writeJsonAtomic(path, next);
+}
+function stripTomlServer(path) {
+    const c = readTomlSafe(path);
+    const servers = c.mcp_servers ?? {};
+    delete servers[SERVER_NAME];
+    const next = { ...c, mcp_servers: servers };
+    if (Object.keys(servers).length === 0)
+        delete next.mcp_servers;
+    backupIfExists(path);
+    writeTomlAtomic(path, next);
+}
+// ============================================================================
+// Doc-section helpers (mirror inject-instruction's section anchoring)
+// ============================================================================
+function hasReplenSection(text) {
+    return text.split("\n").some((l) => l.trim() === SECTION_HEADER);
+}
+// A file is "stub only" if Replen created it: it carries our generated stub
+// hint AND contains nothing but the header + the Replen section. Removing the
+// section would leave an empty husk, so we delete the whole file instead.
+function isStubOnly(text) {
+    if (!text.includes(STUB_HINT))
+        return false;
+    const stripped = stripReplenSection(text).trim();
+    // After removing the section, all that's left is the auto-generated H1 +
+    // stub comment. If there's no other prose, treat it as Replen-owned.
+    const meaningful = stripped
+        .split("\n")
+        .filter((l) => l.trim() && !l.trim().startsWith("# ") && !l.trim().startsWith("<!--"))
+        .join("")
+        .trim();
+    return meaningful.length === 0;
+}
+// Remove the `## Replen integration` block: from its H2 header to the next H2
+// (not H3+) or EOF. Mirrors replaceSection() in inject-instruction.ts but
+// deletes rather than replaces. Collapses any duplicate blocks too.
+function stripReplenSection(text) {
+    let out = text;
+    // Loop until no section remains (defends against legacy duplicate blocks).
+    // Bounded to avoid any pathological non-progress.
+    for (let guard = 0; guard < 10; guard++) {
+        const lines = out.split("\n");
+        let start = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].trim() === SECTION_HEADER) {
+                start = i;
+                break;
+            }
+        }
+        if (start === -1)
+            break;
+        let end = lines.length;
+        for (let j = start + 1; j < lines.length; j++) {
+            if (lines[j].startsWith("## ") && !lines[j].startsWith("### ")) {
+                end = j;
+                break;
+            }
+        }
+        const before = lines.slice(0, start).join("\n").replace(/\n+$/, "");
+        const after = end < lines.length ? lines.slice(end).join("\n") : "";
+        out = (before + (after ? "\n\n" + after : "\n")).replace(/\n{3,}/g, "\n\n");
+    }
+    void MARKER_RE; // marker presence already implied by header; kept for parity
+    return out.replace(/\s+$/, "") + "\n";
+}
+// ============================================================================
+// File primitives
+// ============================================================================
+function readJson(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, "utf8");
+    if (!raw.trim())
+        return {};
+    return JSON.parse(raw);
+}
+function readTomlSafe(path) {
+    if (!existsSync(path))
+        return {};
+    const raw = readFileSync(path, "utf8");
+    if (!raw.trim())
+        return {};
+    return parseToml(raw);
+}
+function writeJsonAtomic(path, data) {
+    writeAtomic(path, JSON.stringify(data, null, 2) + "\n");
+}
+function writeTomlAtomic(path, data) {
+    writeAtomic(path, stringifyToml(data) + "\n");
+}
+function writeAtomic(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp.${Date.now()}`;
+    writeFileSync(tmp, content, { mode: 0o600 });
+    renameSync(tmp, path);
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function backupIfExists(path) {
+    if (!existsSync(path))
+        return;
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    writeFileSync(`${path}.bak.${ts}`, readFileSync(path));
+}
+// ============================================================================
+// CLI plumbing
+// ============================================================================
+function banner(opts) {
+    console.log("");
+    console.log("  Replen uninstall — removes Replen's LOCAL footprint from this machine.");
+    console.log("  You'll be asked before each category; nothing is removed without a yes.");
+    if (opts.dryRun)
+        console.log("  (--dry-run: previewing only, no changes)");
+    console.log("");
+    console.log("  In scope:  MCP wiring (Claude/Codex/Gemini), the /replen skills,");
+    console.log("             the per-repo \"## Replen integration\" doc blocks, and ~/.replen.");
+    console.log("  NOT in scope: server-side profiles & match history (see note at the end).");
+}
+// Per-category gate. --yes bypasses (scripted). Default is NO.
+async function gate(opts, question) {
+    if (opts.dryRun)
+        return true; // show what would happen, but caller no-ops
+    if (opts.yes)
+        return true;
+    return confirm(question, false);
+}
+async function confirm(question, defaultYes) {
+    if (!process.stdin.isTTY)
+        return false; // non-interactive + no --yes ⇒ refuse to delete
+    const hint = defaultYes ? "[Y/n]" : "[y/N]";
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const ans = (await rl.question(`       ${question} ${hint} `)).trim().toLowerCase();
+        if (ans === "")
+            return defaultYes;
+        return ans === "y" || ans === "yes";
+    }
+    catch {
+        return false;
+    }
+    finally {
+        rl.close();
+    }
+}
+function collectRoots(argv) {
+    const out = [];
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--root" && argv[i + 1])
+            out.push(argv[++i]);
+        else if (argv[i].startsWith("--root="))
+            out.push(argv[i].slice("--root=".length));
+    }
+    return out;
+}
+function safe(fn) {
+    try {
+        return fn();
+    }
+    catch {
+        return false;
+    }
+}

package/extras/skills/replen-onboard/SKILL.md

@@ -335,10 +335,11 @@ If several repos are one product (e.g. `aegis-web`/`aegis-api`/`aegis-cv`), grou
 them with `replen_set_product` so Replen unions the whole product's capabilities
 when the user is in any one of them.
 
-## Step 4 — Warm + close out
+## Step 4 — Close out
 
-1. Trigger an embedding/inventory pass so everything's ready: `replen_run` (it's
-   async; the per-project facets you set are already live regardless).
+1. Nothing to trigger — the per-project facets, capabilities, and versions you
+   set are live immediately, and the next scheduled run refreshes the candidate
+   inventory automatically.
 2. Summarise what you did, calmly:
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replen",
-  "version": "1.0.40",
+  "version": "1.2.0",
   "description": "Make your AI coding tools smarter. One command, no API keys, free. Replen watches what your projects actually do and surfaces a few things worth bringing in each month. Use one as is, port a piece of another, cherry pick an idea, or build it clean room. The match happens inside your AI tool's session. A few actionable matches a month, by design.",
   "type": "module",
   "bin": {