memhook 0.4.0 → 0.5.0

package/dist/src/index.d.ts

@@ -7,8 +7,11 @@
  */
 export { loadConfig, type MemhookConfig, type ProviderType } from "./config.js";
 export { loadYamlConfig, resolveConfigPath, type RawConfigFile } from "./configFile.js";
-export { route, type HookInput, type HookOutput } from "./router.js";
+export { route, runHarness, type HookInput, type HookOutput } from "./router.js";
+export { claudeCodeAdapter } from "./adapters/claudeCode.js";
+export type { HarnessAdapter, HarnessInput, RouteResult } from "./adapters/types.js";
 export { buildCatalog, type CatalogBuildOptions } from "./catalog.js";
+export { resolveCustomSources, activeCustomSources, resolveSources, expandPresets, resolveActivePresetNames, resolvePresetNames, isPresetName, globToRegExp, expandHome, HOST_PRESETS, PRESET_NAMES, PRESET_AUTO, type CustomSource, type SourceScope, type PresetDef, } from "./sources.js";
 export { LocalCache, type CacheKeyInput } from "./cache.js";
 export { PreFilter } from "./preFilter.js";
 export { MEMHOOK_VERSION } from "./version.js";
@@ -23,4 +26,3 @@ export { AnthropicProvider, type AnthropicProviderOptions } from "./providers/an
 export { OpenAIProvider } from "./providers/openai.js";
 export { OllamaProvider } from "./providers/ollama.js";
 export type { Provider, ProviderConfig, SelectionRequest, SelectionResponse, UsageBreakdown, } from "./providers/types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -7,12 +7,19 @@
  */
 export { loadConfig } from "./config.js";
 export { loadYamlConfig, resolveConfigPath } from "./configFile.js";
-export { route } from "./router.js";
+export { route, runHarness } from "./router.js";
+export { claudeCodeAdapter } from "./adapters/claudeCode.js";
 export { buildCatalog } from "./catalog.js";
+export { resolveCustomSources, activeCustomSources, resolveSources, expandPresets, resolveActivePresetNames, resolvePresetNames, isPresetName, globToRegExp, expandHome, HOST_PRESETS, PRESET_NAMES, PRESET_AUTO, } from "./sources.js";
 export { LocalCache } from "./cache.js";
 export { PreFilter } from "./preFilter.js";
 export { MEMHOOK_VERSION } from "./version.js";
 export { createProvider } from "./providers/factory.js";
+// ── Internal building blocks (NOT part of the semver-stable surface) ─────────
+// The install/init/skills/tail/ansi re-exports below back the CLI and tests.
+// They are exposed for power users but may change between 0.x minor releases;
+// the stable embedding API is the core above (route, loadConfig, buildCatalog,
+// LocalCache, PreFilter, MEMHOOK_VERSION) plus the provider exports.
 export { addHooks, removeHooks, memhookSubcommand, MEMHOOK_HOOKS, } from "./install.js";
 export { runInit, runUninstall, buildConfigObject, backupPath, } from "./init.js";
 export { COMPANION_SKILLS, SKILL_FILES, isCompanionSkill, diffSkill, planInstall, planUninstall, } from "./skills.js";
@@ -22,4 +29,3 @@ export { makeAnsi, colorEnabled, visibleWidth } from "./ansi.js";
 export { AnthropicProvider } from "./providers/anthropic.js";
 export { OpenAIProvider } from "./providers/openai.js";
 export { OllamaProvider } from "./providers/ollama.js";
-//# sourceMappingURL=index.js.map

package/dist/src/init.d.ts

@@ -45,4 +45,3 @@ export declare function buildConfigObject(opts: {
 }): Record<string, unknown> | null;
 export declare function runInit(opts: InitOptions, env?: NodeJS.ProcessEnv): Promise<number>;
 export declare function runUninstall(opts: UninstallOptions, env?: NodeJS.ProcessEnv): Promise<number>;
-//# sourceMappingURL=init.d.ts.map

package/dist/src/init.js

@@ -324,4 +324,3 @@ export async function runUninstall(opts, env = process.env) {
     io.out(`\n${ansi.green("Done.")} Restart Claude Code to drop the hooks.`);
     return 0;
 }
-//# sourceMappingURL=init.js.map

package/dist/src/install.d.ts

@@ -84,4 +84,3 @@ export declare function addHooks(input: unknown, bin?: string): AddResult;
  * group list becomes empty — are pruned so no dangling shells are left behind.
  */
 export declare function removeHooks(input: unknown): RemoveResult;
-//# sourceMappingURL=install.d.ts.map

package/dist/src/install.js

@@ -121,4 +121,3 @@ export function removeHooks(input) {
     }
     return { settings, removed, removedEvents };
 }
-//# sourceMappingURL=install.js.map

package/dist/src/preFilter.d.ts

@@ -13,4 +13,3 @@ export declare class PreFilter {
     constructor(filePath: string | undefined, defaults: string[]);
     isTrivial(prompt: string): boolean;
 }
-//# sourceMappingURL=preFilter.d.ts.map

package/dist/src/preFilter.js

@@ -37,4 +37,3 @@ export class PreFilter {
 function normalise(input) {
     return input.replace(/[\s\p{P}]/gu, "").toLowerCase();
 }
-//# sourceMappingURL=preFilter.js.map

package/dist/src/presetsCmd.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `memhook presets list|detect` — discover the built-in per-host source presets
+ * so the user never has to know a preset's name or hand-write its paths.
+ *
+ *   list    Show every built-in preset (name, summary, the dirs/globs it points
+ *           at). Static — no disk access.
+ *   detect  Scan this project (cwd) + the home dir for the preset directories
+ *           that actually hold matching `.md` files, then print the YAML snippet
+ *           (`presets: [...]`) that enables the ones found.
+ *
+ * This is the I/O shell around the pure detector in `src/sources.ts`
+ * (`detectPresets`), the same functional-core / imperative-shell split as
+ * init.ts ↔ install.ts and skillsCmd.ts ↔ skills.ts. `presets` is NOT on the
+ * hook path, so it may exit non-zero on user error and use the TTY
+ * (docs/SPECIFICATION.md §9). The detector never throws (a missing/denied dir is
+ * recorded as absent), so detect/list always exit 0.
+ */
+export type PresetsSubcommand = "list" | "detect";
+export interface RunPresetsOptions {
+    subcommand: PresetsSubcommand;
+    /** Test seams. */
+    cwd?: string | undefined;
+    home?: string | undefined;
+    readDir?: ((dir: string) => string[]) | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    out?: ((s: string) => void) | undefined;
+}
+export declare function runPresets(opts: RunPresetsOptions): number;

package/dist/src/presetsCmd.js

@@ -0,0 +1,94 @@
+/**
+ * `memhook presets list|detect` — discover the built-in per-host source presets
+ * so the user never has to know a preset's name or hand-write its paths.
+ *
+ *   list    Show every built-in preset (name, summary, the dirs/globs it points
+ *           at). Static — no disk access.
+ *   detect  Scan this project (cwd) + the home dir for the preset directories
+ *           that actually hold matching `.md` files, then print the YAML snippet
+ *           (`presets: [...]`) that enables the ones found.
+ *
+ * This is the I/O shell around the pure detector in `src/sources.ts`
+ * (`detectPresets`), the same functional-core / imperative-shell split as
+ * init.ts ↔ install.ts and skillsCmd.ts ↔ skills.ts. `presets` is NOT on the
+ * hook path, so it may exit non-zero on user error and use the TTY
+ * (docs/SPECIFICATION.md §9). The detector never throws (a missing/denied dir is
+ * recorded as absent), so detect/list always exit 0.
+ */
+import { readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { makeAnsi } from "./ansi.js";
+import { HOST_PRESETS, PRESET_NAMES, detectPresets } from "./sources.js";
+function makeIo(env, out) {
+    const ansi = makeAnsi({ isTTY: Boolean(process.stdout.isTTY), env });
+    return { out: out ?? ((s) => process.stdout.write(s + "\n")), ansi };
+}
+/** Display a source dir + glob with a portable separator (path.join, never "/"). */
+function dirGlob(dir, glob) {
+    return join(dir, glob);
+}
+export function runPresets(opts) {
+    const env = opts.env ?? process.env;
+    const cwd = opts.cwd ?? process.cwd();
+    const home = opts.home ?? homedir();
+    const readDir = opts.readDir ?? ((dir) => readdirSync(dir));
+    const io = makeIo(env, opts.out);
+    if (opts.subcommand === "list")
+        return runList(io, cwd, home);
+    return runDetect(io, cwd, home, readDir);
+}
+function runList(io, cwd, home) {
+    const { ansi } = io;
+    io.out(ansi.bold("memhook host presets") + ansi.dim(" — built-in source bundles (all experimental)\n"));
+    for (const name of PRESET_NAMES) {
+        const def = HOST_PRESETS[name];
+        if (!def)
+            continue;
+        io.out(`  ${ansi.cyan(name)} ${ansi.dim("(experimental)")}`);
+        io.out(`      ${ansi.dim(def.summary)}`);
+        for (const s of def.sources) {
+            const dir = join(s.base === "cwd" ? cwd : home, s.rel);
+            io.out(`      ${ansi.dim(dirGlob(dir, s.glob))}`);
+        }
+    }
+    io.out(ansi.dim("\nAll presets are doc-verified but not live-tested → experimental " +
+        "until an echo-test.\nEnable in ~/.config/memhook/config.yaml:  " +
+        "presets: [name, …]\nFind which apply here with `memhook presets detect`."));
+    return 0;
+}
+function runDetect(io, cwd, home, readDir) {
+    const { ansi } = io;
+    const detections = detectPresets(cwd, home, readDir);
+    const matched = detections.filter((d) => d.matched);
+    io.out(ansi.bold("memhook presets detect") +
+        ansi.dim(" — scan this project + home for known host memory\n"));
+    for (const d of detections) {
+        const total = fileCount(d);
+        if (d.matched) {
+            io.out(`  ${ansi.green("●")} ${ansi.cyan(d.name)} ${ansi.dim(`— ${total} file(s)`)}`);
+            for (const dir of d.dirs) {
+                if (dir.files.length === 0)
+                    continue;
+                io.out(`      ${ansi.dim(`${dirGlob(dir.dir, dir.glob)} (${dir.files.length})`)}`);
+            }
+        }
+        else {
+            io.out(`  ${ansi.dim("○")} ${ansi.dim(`${d.name} — no matching files`)}`);
+        }
+    }
+    if (matched.length === 0) {
+        io.out(ansi.dim("\nNo known host memory found under this project or home. Nothing to enable."));
+        return 0;
+    }
+    const names = matched.map((d) => d.name).join(", ");
+    io.out("\n" +
+        ansi.bold(`Found ${matched.length} host preset(s) with memory.`) +
+        ansi.dim(" Enable (experimental) by adding to\n~/.config/memhook/config.yaml:\n"));
+    io.out(`  ${ansi.cyan(`presets: [${names}]`)}`);
+    io.out(ansi.dim("\nThen run `memhook build-catalog` (or restart Claude Code) to catalog them."));
+    return 0;
+}
+function fileCount(d) {
+    return d.dirs.reduce((n, dir) => n + dir.files.length, 0);
+}

package/dist/src/providers/anthropic.d.ts

@@ -30,4 +30,3 @@ export declare class AnthropicProvider implements Provider {
     constructor(config: ProviderConfig, options?: AnthropicProviderOptions);
     select(req: SelectionRequest): Promise<SelectionResponse>;
 }
-//# sourceMappingURL=anthropic.d.ts.map

package/dist/src/providers/anthropic.js

@@ -95,4 +95,3 @@ function extractUsage(json) {
         cacheReadTokens: num("cache_read_input_tokens"),
     };
 }
-//# sourceMappingURL=anthropic.js.map

package/dist/src/providers/factory.d.ts

@@ -12,4 +12,3 @@
 import type { Provider } from "./types.js";
 import type { MemhookConfig } from "../config.js";
 export declare function createProvider(cfg: MemhookConfig, apiKey: string | undefined): Provider;
-//# sourceMappingURL=factory.d.ts.map

package/dist/src/providers/factory.js

@@ -34,4 +34,3 @@ export function createProvider(cfg, apiKey) {
         }
     }
 }
-//# sourceMappingURL=factory.js.map

package/dist/src/providers/http.d.ts

@@ -31,4 +31,3 @@ export interface RawHttpResult {
     latencyMs: number;
 }
 export declare function postJsonWithRetry(opts: PostJsonOptions): Promise<RawHttpResult>;
-//# sourceMappingURL=http.d.ts.map

package/dist/src/providers/http.js

@@ -57,4 +57,3 @@ export async function postJsonWithRetry(opts) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=http.js.map

package/dist/src/providers/ollama.d.ts

@@ -27,4 +27,3 @@ export declare class OllamaProvider implements Provider {
     constructor(config: ProviderConfig);
     select(req: SelectionRequest): Promise<SelectionResponse>;
 }
-//# sourceMappingURL=ollama.d.ts.map

package/dist/src/providers/ollama.js

@@ -86,4 +86,3 @@ function extractUsage(json) {
         cacheReadTokens: 0,
     };
 }
-//# sourceMappingURL=ollama.js.map

package/dist/src/providers/openai.d.ts

@@ -28,4 +28,3 @@ export declare class OpenAIProvider implements Provider {
     constructor(config: ProviderConfig);
     select(req: SelectionRequest): Promise<SelectionResponse>;
 }
-//# sourceMappingURL=openai.d.ts.map

package/dist/src/providers/openai.js

@@ -91,4 +91,3 @@ function extractUsage(json) {
         cacheReadTokens: cachedTokens,
     };
 }
-//# sourceMappingURL=openai.js.map

package/dist/src/providers/types.d.ts

@@ -45,4 +45,3 @@ export interface Provider {
     readonly name: string;
     select(req: SelectionRequest): Promise<SelectionResponse>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/src/providers/types.js

@@ -15,4 +15,3 @@
  * `createProvider()` in `factory.ts`.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/src/router.d.ts

@@ -19,6 +19,7 @@
  * Never blocks Claude Code.
  */
 import { type MemhookConfig } from "./config.js";
+import type { HarnessAdapter } from "./adapters/types.js";
 export interface HookInput {
     prompt: string;
     cwd?: string;
@@ -36,7 +37,19 @@ export interface HookOutput {
      */
     systemMessage?: string;
 }
+/**
+ * Claude Code hook entry point. Unchanged signature and output shape — a thin
+ * wrapper that drives the harness-agnostic pipeline through the Claude Code
+ * adapter (src/adapters/claudeCode.ts). Byte-identical to the pre-adapter hook.
+ */
 export declare function route(stdinJson: string, env?: NodeJS.ProcessEnv): Promise<HookOutput>;
+/**
+ * Generic harness entry point: parse the host's stdin into `{prompt, cwd}` with
+ * the adapter, run the selection pipeline, then serialise the result into the
+ * host's stdout envelope with the same adapter. The pipeline (`selectMemory`) is
+ * identical for every host; only `parseInput` / `formatOutput` differ.
+ */
+export declare function runHarness<T>(adapter: HarnessAdapter<T>, stdinJson: string, env?: NodeJS.ProcessEnv): Promise<T>;
 /**
  * Proactive `/curate` nudge. Returns a one-line `systemMessage` when the memory
  * catalog has grown past a threshold and the cooldown has elapsed, else
@@ -51,4 +64,23 @@ export declare function route(stdinJson: string, env?: NodeJS.ProcessEnv): Promi
  * Exported for direct unit testing.
  */
 export declare function maybeCurateNudge(config: MemhookConfig, catalogContent: string, now: number): string | undefined;
-//# sourceMappingURL=router.d.ts.map
+/**
+ * Proactive presets nudge. Returns a one-line `systemMessage` when a known
+ * host's memory directory exists in this project (or home) but no `presets:`
+ * entry routes it yet, else undefined. It makes `memhook presets detect` (the
+ * #42 discovery command) self-announcing instead of something the user must know
+ * to run.
+ *
+ * Opt-in is preserved: the nudge only *suggests* the explicit `presets:` config;
+ * it never auto-routes anything (every preset is experimental — see
+ * `docs/SPECIFICATION.md` §24). Local-only and fully wrapped so any failure
+ * yields no nudge (fail-soft is never affected). The cooldown stamp is keyed by
+ * cwd because the presets signal is per-project (unlike the catalog-size signal
+ * behind the `/curate` nudge), so one project firing must not silence another's.
+ * Cost: like the curate nudge, the stamp is written only on a fire, so until one
+ * fires the detection runs per prompt — a few `readdir`s on mostly-absent dirs,
+ * the same order of I/O `readSelected` already does.
+ *
+ * Exported for direct unit testing.
+ */
+export declare function maybePresetsNudge(config: MemhookConfig, cwd: string, home: string, now: number): string | undefined;

package/dist/src/router.js

@@ -20,37 +20,55 @@
  */
 import { existsSync, readFileSync, writeFileSync, openSync, fstatSync, closeSync, appendFileSync, mkdirSync, readdirSync, } from "node:fs";
 import { join, dirname, basename } from "node:path";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
 import { LocalCache } from "./cache.js";
 import { loadConfig } from "./config.js";
 import { PreFilter } from "./preFilter.js";
 import { createProvider } from "./providers/factory.js";
+import { activeCustomSources, resolveSources, resolveActivePresetNames, detectPresets, } from "./sources.js";
+import { claudeCodeAdapter } from "./adapters/claudeCode.js";
 const SAFE_BASENAME_RE = /^[A-Za-z0-9._-]+\.md$/;
-const EMPTY = {
-    hookSpecificOutput: {
-        hookEventName: "UserPromptSubmit",
-        additionalContext: "",
-    },
-};
+/** The harness-agnostic empty outcome: inject nothing, no nudge (fail-soft). */
+const EMPTY_RESULT = { additionalContext: "" };
+/**
+ * Claude Code hook entry point. Unchanged signature and output shape — a thin
+ * wrapper that drives the harness-agnostic pipeline through the Claude Code
+ * adapter (src/adapters/claudeCode.ts). Byte-identical to the pre-adapter hook.
+ */
 export async function route(stdinJson, env = process.env) {
+    return runHarness(claudeCodeAdapter, stdinJson, env);
+}
+/**
+ * Generic harness entry point: parse the host's stdin into `{prompt, cwd}` with
+ * the adapter, run the selection pipeline, then serialise the result into the
+ * host's stdout envelope with the same adapter. The pipeline (`selectMemory`) is
+ * identical for every host; only `parseInput` / `formatOutput` differ.
+ */
+export async function runHarness(adapter, stdinJson, env = process.env) {
+    const result = await selectMemory(stdinJson, adapter.parseInput, env);
+    return adapter.formatOutput(result);
+}
+/**
+ * Harness-agnostic selection pipeline. Owns the config gate, prefilter, catalog
+ * + API-key checks, the local cache, the provider call, file injection, the
+ * JSONL log, and the `/curate` nudge. Every error path returns `EMPTY_RESULT`
+ * (fail-soft) — the hook never throws out of here.
+ */
+async function selectMemory(stdinJson, parseInput, env) {
     const config = loadConfig(env);
     ensureDirs(config);
     evictStale(config);
     if (!config.enabled)
-        return EMPTY;
-    let input;
-    try {
-        input = JSON.parse(stdinJson);
-    }
-    catch {
-        return EMPTY;
-    }
-    if (!input.prompt || typeof input.prompt !== "string")
-        return EMPTY;
+        return EMPTY_RESULT;
+    const input = parseInput(stdinJson);
+    if (!input || !input.prompt || typeof input.prompt !== "string")
+        return EMPTY_RESULT;
     const cwd = input.cwd ?? process.cwd();
     const preFilter = new PreFilter(config.preFilter.trivialWordsFile, config.preFilter.defaultWords);
     if (config.preFilter.enabled && preFilter.isTrivial(input.prompt)) {
         logEntry(config, baseLog(input.prompt, "pre_filter_skip"));
-        return EMPTY;
+        return EMPTY_RESULT;
     }
     // Read the catalog through a single fd: `fstat` gives the cache-key mtime and
     // we read the content from the same handle. Using one open fd — instead of
@@ -73,14 +91,14 @@ export async function route(stdinJson, env = process.env) {
     }
     catch {
         logEntry(config, baseLog(input.prompt, "no_catalog"));
-        return EMPTY;
+        return EMPTY_RESULT;
     }
     // Provider-aware key gate: local providers (Ollama) need no API key.
     const needsKey = config.provider.type !== "ollama";
     const apiKey = config.provider.apiKeyEnv ? env[config.provider.apiKeyEnv] : undefined;
     if (needsKey && !apiKey) {
         logEntry(config, baseLog(input.prompt, "no_api_key"));
-        return EMPTY;
+        return EMPTY_RESULT;
     }
     const cache = new LocalCache(config.cache.dir, config.cache.ttlMin, config.cache.evictionDays);
     const cacheKey = config.cache.enabled
@@ -120,7 +138,7 @@ export async function route(stdinJson, env = process.env) {
         }
         catch {
             logEntry(config, baseLog(input.prompt, "provider_init_failed"));
-            return EMPTY;
+            return EMPTY_RESULT;
         }
         let resp;
         try {
@@ -133,7 +151,7 @@ export async function route(stdinJson, env = process.env) {
         }
         catch {
             logEntry(config, baseLog(input.prompt, "api_no_response"));
-            return EMPTY;
+            return EMPTY_RESULT;
         }
         latencyMs = resp.latencyMs;
         usage = resp.usage;
@@ -146,7 +164,7 @@ export async function route(stdinJson, env = process.env) {
                 cacheCreate: usage.cacheCreateTokens,
                 cacheRead: usage.cacheReadTokens,
             });
-            return EMPTY;
+            return EMPTY_RESULT;
         }
         const extracted = extractJsonArray(resp.rawText);
         if (extracted === null) {
@@ -158,7 +176,7 @@ export async function route(stdinJson, env = process.env) {
                 cacheCreate: usage.cacheCreateTokens,
                 cacheRead: usage.cacheReadTokens,
             });
-            return EMPTY;
+            return EMPTY_RESULT;
         }
         selectedJson = JSON.stringify(extracted);
         if (config.cache.enabled && selectedJson !== "[]") {
@@ -192,19 +210,25 @@ export async function route(stdinJson, env = process.env) {
         additionalSizeTokensEst: Math.floor(additional.length / 4),
         status,
     });
-    const output = {
-        hookSpecificOutput: {
-            hookEventName: "UserPromptSubmit",
-            additionalContext: additional,
-        },
-    };
+    const result = { additionalContext: additional };
     // Proactive `/curate` nudge — best-effort, local-only, never affects the
     // additionalContext contract or fail-soft. `catalogContent` is already in hand
-    // (read above), so the catalog-size signal is free.
+    // (read above), so the catalog-size signal is free. The adapter serialises it
+    // into the host's notice channel (Claude Code: `systemMessage`); a host with
+    // no equivalent simply drops it.
     const nudge = maybeCurateNudge(config, catalogContent, Date.now());
-    if (nudge)
-        output.systemMessage = nudge;
-    return output;
+    if (nudge) {
+        result.systemMessage = nudge;
+    }
+    else {
+        // Only one notice channel (`systemMessage`) exists, so the presets nudge is
+        // a fallback: it fires only on a turn the curate nudge did not. Each has its
+        // own long cooldown, so the collision is rare and never produces two notices.
+        const pnudge = maybePresetsNudge(config, cwd, homedir(), Date.now());
+        if (pnudge)
+            result.systemMessage = pnudge;
+    }
+    return result;
 }
 function buildSystemPrompt(catalog) {
     return `Tu es un sélecteur de mémoire pour Claude Code. Tu identifies les feedbacks et règles pertinents pour le prompt utilisateur. Tu réponds UNIQUEMENT avec un JSON array de basenames .md, sans explication, sans markdown code fence.
@@ -246,33 +270,53 @@ function parseBasenames(raw) {
 }
 function extractJsonArray(text) {
     const flat = text.replace(/\n/g, " ");
-    const match = flat.match(/\[[^\]]*\]/);
-    if (!match)
+    const matches = flat.match(/\[[^\]]*\]/g);
+    if (!matches)
         return null;
-    try {
-        const parsed = JSON.parse(match[0]);
+    // A compliant response is a single bare array, but a model may wrap it in
+    // prose containing a decoy `[...]`. Scan every bracketed candidate and prefer
+    // the LAST one that yields usable string basenames; keep an empty array only
+    // as a fallback when no non-empty array is found, else null.
+    let result = null;
+    for (const candidate of matches) {
+        let parsed;
+        try {
+            parsed = JSON.parse(candidate);
+        }
+        catch {
+            continue;
+        }
         if (!Array.isArray(parsed))
-            return null;
-        return parsed.filter((x) => typeof x === "string");
-    }
-    catch {
-        return null;
+            continue;
+        const strings = parsed.filter((x) => typeof x === "string");
+        if (strings.length > 0 || result === null)
+            result = strings;
     }
+    return result;
 }
 function readSelected(basenames, cwd, config) {
-    // Build search dirs: ~/.claude/projects/*/memory + global rules + cwd rules.
+    // Build search dirs: ~/.claude/projects/*/memory + global rules + cwd rules +
+    // any user-declared custom sources (host-autoloaded ones only when resurfacing,
+    // mirroring the catalog so the router never finds what the catalog omitted).
     const projectDirs = listProjectsMemoryDirs(config.searchDirs[0]);
     const rulesDir = config.searchDirs[1];
     const cwdRulesDir = join(cwd, ".claude", "rules");
-    const dirs = [...projectDirs, rulesDir, cwdRulesDir].filter((d) => typeof d === "string" && d.length > 0);
+    const allSources = resolveSources(config.customSources, config.presets, cwd, homedir(), readdirSync);
+    const customDirs = activeCustomSources(allSources, config.resurfaceHostLoaded).map((s) => s.dir);
+    const dirs = [...projectDirs, rulesDir, cwdRulesDir, ...customDirs].filter((d) => typeof d === "string" && d.length > 0);
     let additional = "";
     let injected = 0;
     const seen = [];
+    const seenNames = new Set();
     for (const name of basenames) {
         if (injected >= config.selection.maxFiles)
             break;
         if (!SAFE_BASENAME_RE.test(name))
             continue;
+        // De-dup: a basename the model repeats is injected once and uses one slot.
+        if (seenNames.has(name))
+            continue;
+        seenNames.add(name);
         seen.push(name);
         for (const dir of dirs) {
             const file = join(dir, name);
@@ -366,6 +410,59 @@ export function maybeCurateNudge(config, catalogContent, now) {
         return undefined; // a nudge must never break fail-soft
     }
 }
+/**
+ * Proactive presets nudge. Returns a one-line `systemMessage` when a known
+ * host's memory directory exists in this project (or home) but no `presets:`
+ * entry routes it yet, else undefined. It makes `memhook presets detect` (the
+ * #42 discovery command) self-announcing instead of something the user must know
+ * to run.
+ *
+ * Opt-in is preserved: the nudge only *suggests* the explicit `presets:` config;
+ * it never auto-routes anything (every preset is experimental — see
+ * `docs/SPECIFICATION.md` §24). Local-only and fully wrapped so any failure
+ * yields no nudge (fail-soft is never affected). The cooldown stamp is keyed by
+ * cwd because the presets signal is per-project (unlike the catalog-size signal
+ * behind the `/curate` nudge), so one project firing must not silence another's.
+ * Cost: like the curate nudge, the stamp is written only on a fire, so until one
+ * fires the detection runs per prompt — a few `readdir`s on mostly-absent dirs,
+ * the same order of I/O `readSelected` already does.
+ *
+ * Exported for direct unit testing.
+ */
+export function maybePresetsNudge(config, cwd, home, now) {
+    try {
+        if (!config.presetsNudge.enabled)
+            return undefined;
+        // Per-project stamp: a global stamp would let the first project hit in a
+        // window silence every other project's (per-cwd) presets signal.
+        const cwdHash = createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+        const stampFile = join(config.cache.dir, `.presets-nudge-${cwdHash}`);
+        const last = readNudgeStamp(stampFile);
+        if (last !== null && now - last < config.presetsNudge.cooldownDays * 86_400_000) {
+            return undefined;
+        }
+        // Suggest a preset only when it has memory on disk that is NOT already routed
+        // — neither by an effective preset name (named entries AND `presets: [auto]`
+        // expansion, so an `auto` user is never nudged) nor by a hand-written
+        // `customSources` dir pointing at the same place (`presets:` is sugar over
+        // `customSources`, D31/D32). `enabled` keys on the EXPANDED names (not the raw
+        // config) so it suppresses regardless of the `resurfaceHostLoaded` gate, which
+        // would otherwise drop a hostAutoLoaded preset's dirs from `routedDirs`.
+        const enabled = new Set(resolveActivePresetNames(config.presets, cwd, home, readdirSync));
+        const routedDirs = new Set(activeCustomSources(resolveSources(config.customSources, config.presets, cwd, home, readdirSync), config.resurfaceHostLoaded).map((s) => s.dir));
+        const found = detectPresets(cwd, home, readdirSync)
+            .filter((d) => d.matched && !enabled.has(d.name))
+            .filter((d) => d.dirs.some((dir) => dir.files.length > 0 && !routedDirs.has(dir.dir)))
+            .map((d) => d.name);
+        if (found.length === 0)
+            return undefined;
+        writeNudgeStamp(stampFile, now);
+        return `🔌 memhook: found ${found.join(", ")} memory not yet routed by memhook. Run \`memhook presets detect\` to enable it.`;
+    }
+    catch {
+        return undefined; // a nudge must never break fail-soft
+    }
+}
 /** Count top-level `*.md` memory files (excludes MEMORY.md and the journal/ subdir). */
 function countMemoryFiles(projectsRoot) {
     let total = 0;
@@ -444,4 +541,3 @@ function logEntry(config, entry) {
 function nowIso() {
     return new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 }
-//# sourceMappingURL=router.js.map

package/dist/src/skills.d.ts

@@ -65,4 +65,3 @@ export interface SkillUninstallPlan {
 }
 /** Plan one skill uninstall: remove only the files memhook ships, if present. */
 export declare function planUninstall(name: CompanionSkill, source: SkillSources, installed: InstalledFiles): SkillUninstallPlan;
-//# sourceMappingURL=skills.d.ts.map

package/dist/src/skills.js

@@ -70,4 +70,3 @@ export function planUninstall(name, source, installed) {
     const present = removes.length > 0;
     return { name, present, action: present ? "remove" : "skip", removes };
 }
-//# sourceMappingURL=skills.js.map

package/dist/src/skillsCmd.d.ts

@@ -48,4 +48,3 @@ export interface RunSkillsOptions {
     env?: NodeJS.ProcessEnv | undefined;
 }
 export declare function runSkills(opts: RunSkillsOptions): Promise<number>;
-//# sourceMappingURL=skillsCmd.d.ts.map

package/dist/src/skillsCmd.js

@@ -270,4 +270,3 @@ async function confirm(ansi, hint, defaultYes) {
         rl.close();
     }
 }
-//# sourceMappingURL=skillsCmd.js.map