memhook 0.3.0 → 0.4.1

package/dist/src/router.js

@@ -18,7 +18,7 @@
  * Fail-soft: every error path falls back to empty additionalContext.
  * Never blocks Claude Code.
  */
-import { existsSync, readFileSync, openSync, fstatSync, closeSync, appendFileSync, mkdirSync, readdirSync, } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, openSync, fstatSync, closeSync, appendFileSync, mkdirSync, readdirSync, } from "node:fs";
 import { join, dirname, basename } from "node:path";
 import { LocalCache } from "./cache.js";
 import { loadConfig } from "./config.js";
@@ -192,12 +192,19 @@ export async function route(stdinJson, env = process.env) {
         additionalSizeTokensEst: Math.floor(additional.length / 4),
         status,
     });
-    return {
+    const output = {
         hookSpecificOutput: {
             hookEventName: "UserPromptSubmit",
             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.
+    const nudge = maybeCurateNudge(config, catalogContent, Date.now());
+    if (nudge)
+        output.systemMessage = nudge;
+    return output;
 }
 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.
@@ -239,18 +246,29 @@ 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.
@@ -261,11 +279,16 @@ function readSelected(basenames, cwd, config) {
     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);
@@ -323,6 +346,77 @@ function evictStale(config) {
         // silent — eviction is best-effort
     }
 }
+/**
+ * Proactive `/curate` nudge. Returns a one-line `systemMessage` when the memory
+ * catalog has grown past a threshold and the cooldown has elapsed, else
+ * undefined. Local-only: it reads the already-loaded catalog length, counts
+ * memory files, and stamps a local cooldown file — NO outbound call. The whole
+ * body is wrapped so any failure yields no nudge (fail-soft is never affected).
+ *
+ * Cost: within the cooldown it pays one tiny stamp read and returns; only once
+ * the cooldown elapses does it count files (a readdir per memory dir, the same
+ * order of I/O the router already does in `readSelected`).
+ *
+ * Exported for direct unit testing.
+ */
+export function maybeCurateNudge(config, catalogContent, now) {
+    try {
+        if (!config.curateNudge.enabled)
+            return undefined;
+        const stampFile = join(config.cache.dir, ".curate-nudge");
+        const last = readNudgeStamp(stampFile);
+        if (last !== null && now - last < config.curateNudge.cooldownDays * 86_400_000) {
+            return undefined;
+        }
+        const tokensEst = Math.floor(catalogContent.length / 4);
+        const fileCount = countMemoryFiles(config.searchDirs[0]);
+        const over = tokensEst >= config.curateNudge.thresholdTokens ||
+            fileCount >= config.curateNudge.thresholdFiles;
+        if (!over)
+            return undefined;
+        writeNudgeStamp(stampFile, now);
+        const tokK = tokensEst >= 10_000 ? Math.round(tokensEst / 1000) : (tokensEst / 1000).toFixed(1);
+        return `📚 memhook: memory catalog is large (~${tokK}k tokens, ${fileCount} files). Run /curate to prune duplicate and stale entries.`;
+    }
+    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;
+    for (const dir of listProjectsMemoryDirs(projectsRoot)) {
+        let entries = [];
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            if (e.endsWith(".md") && e !== "MEMORY.md")
+                total++;
+        }
+    }
+    return total;
+}
+function readNudgeStamp(file) {
+    try {
+        const n = Number(readFileSync(file, "utf8").trim());
+        return Number.isFinite(n) ? n : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeNudgeStamp(file, now) {
+    try {
+        writeFileSync(file, String(now), "utf8");
+    }
+    catch {
+        // best-effort — a missed stamp just means the nudge may repeat
+    }
+}
 function baseLog(prompt, status) {
     return {
         ts: nowIso(),
@@ -366,4 +460,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

@@ -0,0 +1,67 @@
+/**
+ * Pure planning core for `memhook skills install|uninstall|list`.
+ *
+ * Like src/install.ts, this module has NO file I/O. The orchestration layer
+ * (src/skillsCmd.ts) reads the bundled skill files and the files already on
+ * disk, calls these pure planners, and applies the result with backups.
+ * Keeping the plan pure means the idempotency + non-clobbering guarantees are
+ * unit-tested without touching anyone's real `~/.claude/skills`.
+ *
+ * memhook ships three STANDALONE companion skills in Claude Code's skill format
+ * (`~/.claude/skills/<name>/SKILL.md`, invoked as `/<name>`):
+ *
+ *   /wrap   — end-of-session wrap-up (capture lessons into memory + journal)
+ *   /curate — memory hygiene (dedupe, index sync, rebuild the catalog)
+ *   /relay  — generate a handoff prompt for a fresh session
+ *
+ * Standalone — not a plugin — so the command names stay bare (`/wrap`, not
+ * `/memhook:wrap`). See docs/SPECIFICATION.md "Companion skills".
+ */
+export declare const COMPANION_SKILLS: readonly ["wrap", "curate", "relay"];
+export type CompanionSkill = (typeof COMPANION_SKILLS)[number];
+/**
+ * Files bundled for each skill, relative to the skill's own directory. The
+ * orchestration layer reads `<sourceDir>/<name>/<relPath>` and writes
+ * `~/.claude/skills/<name>/<relPath>`.
+ */
+export declare const SKILL_FILES: Record<CompanionSkill, readonly string[]>;
+export declare function isCompanionSkill(name: string): name is CompanionSkill;
+/** Bundled content for one skill, keyed by relative path. */
+export type SkillSources = Record<string, string>;
+/** Installed content per relative path; `null` means the file is not on disk. */
+export type InstalledFiles = Record<string, string | null>;
+export type SkillStatus = "absent" | "identical" | "differs";
+export type InstallAction = "install" | "skip" | "overwrite" | "blocked";
+/**
+ * Compare a skill's bundled files against what's on disk.
+ *   - `absent`    — none of the skill's files are installed.
+ *   - `identical` — every bundled file is installed with matching content.
+ *   - `differs`   — installed but a file is missing or its content changed
+ *                   (a user edit, or an older shipped version).
+ */
+export declare function diffSkill(source: SkillSources, installed: InstalledFiles): SkillStatus;
+export interface SkillInstallPlan {
+    name: CompanionSkill;
+    status: SkillStatus;
+    action: InstallAction;
+    /** Relative paths that will be written for `install` / `overwrite`. */
+    writes: string[];
+}
+/**
+ * Plan one skill install. Idempotent: an `identical` skill is skipped. A skill
+ * that `differs` is NEVER clobbered without `force` (it's reported `blocked`),
+ * matching install.ts's "back up + never overwrite silently" stance. With
+ * `force`, a differing skill is `overwrite` (the caller backs up first).
+ */
+export declare function planInstall(name: CompanionSkill, source: SkillSources, installed: InstalledFiles, opts: {
+    force: boolean;
+}): SkillInstallPlan;
+export interface SkillUninstallPlan {
+    name: CompanionSkill;
+    present: boolean;
+    action: "remove" | "skip";
+    /** Relative paths that exist on disk and will be deleted. */
+    removes: string[];
+}
+/** Plan one skill uninstall: remove only the files memhook ships, if present. */
+export declare function planUninstall(name: CompanionSkill, source: SkillSources, installed: InstalledFiles): SkillUninstallPlan;

package/dist/src/skills.js

@@ -0,0 +1,72 @@
+/**
+ * Pure planning core for `memhook skills install|uninstall|list`.
+ *
+ * Like src/install.ts, this module has NO file I/O. The orchestration layer
+ * (src/skillsCmd.ts) reads the bundled skill files and the files already on
+ * disk, calls these pure planners, and applies the result with backups.
+ * Keeping the plan pure means the idempotency + non-clobbering guarantees are
+ * unit-tested without touching anyone's real `~/.claude/skills`.
+ *
+ * memhook ships three STANDALONE companion skills in Claude Code's skill format
+ * (`~/.claude/skills/<name>/SKILL.md`, invoked as `/<name>`):
+ *
+ *   /wrap   — end-of-session wrap-up (capture lessons into memory + journal)
+ *   /curate — memory hygiene (dedupe, index sync, rebuild the catalog)
+ *   /relay  — generate a handoff prompt for a fresh session
+ *
+ * Standalone — not a plugin — so the command names stay bare (`/wrap`, not
+ * `/memhook:wrap`). See docs/SPECIFICATION.md "Companion skills".
+ */
+export const COMPANION_SKILLS = ["wrap", "curate", "relay"];
+/**
+ * Files bundled for each skill, relative to the skill's own directory. The
+ * orchestration layer reads `<sourceDir>/<name>/<relPath>` and writes
+ * `~/.claude/skills/<name>/<relPath>`.
+ */
+export const SKILL_FILES = {
+    wrap: ["SKILL.md"],
+    curate: ["SKILL.md", "reference.md"],
+    relay: ["SKILL.md"],
+};
+export function isCompanionSkill(name) {
+    return COMPANION_SKILLS.includes(name);
+}
+/**
+ * Compare a skill's bundled files against what's on disk.
+ *   - `absent`    — none of the skill's files are installed.
+ *   - `identical` — every bundled file is installed with matching content.
+ *   - `differs`   — installed but a file is missing or its content changed
+ *                   (a user edit, or an older shipped version).
+ */
+export function diffSkill(source, installed) {
+    const rels = Object.keys(source);
+    const anyPresent = rels.some((r) => installed[r] != null);
+    if (!anyPresent)
+        return "absent";
+    const allMatch = rels.every((r) => installed[r] != null && installed[r] === source[r]);
+    return allMatch ? "identical" : "differs";
+}
+/**
+ * Plan one skill install. Idempotent: an `identical` skill is skipped. A skill
+ * that `differs` is NEVER clobbered without `force` (it's reported `blocked`),
+ * matching install.ts's "back up + never overwrite silently" stance. With
+ * `force`, a differing skill is `overwrite` (the caller backs up first).
+ */
+export function planInstall(name, source, installed, opts) {
+    const status = diffSkill(source, installed);
+    let action;
+    if (status === "absent")
+        action = "install";
+    else if (status === "identical")
+        action = "skip";
+    else
+        action = opts.force ? "overwrite" : "blocked";
+    const writes = action === "install" || action === "overwrite" ? Object.keys(source) : [];
+    return { name, status, action, writes };
+}
+/** Plan one skill uninstall: remove only the files memhook ships, if present. */
+export function planUninstall(name, source, installed) {
+    const removes = Object.keys(source).filter((r) => installed[r] != null);
+    const present = removes.length > 0;
+    return { name, present, action: present ? "remove" : "skip", removes };
+}

package/dist/src/skillsCmd.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `memhook skills install|uninstall|list` — copy the bundled companion skills
+ * (/wrap, /curate, /relay) into `~/.claude/skills/<name>/`.
+ *
+ * This is the I/O shell around the pure planner in src/skills.ts (same split as
+ * init.ts ↔ install.ts). All reads/writes/backups live here; the plan logic is
+ * pure and unit-tested. These are INTERACTIVE, user-invoked commands — not the
+ * hook path — so they may use the TTY and exit non-zero on user error
+ * (docs/SPECIFICATION.md §9). The one safety rule: never clobber a skill the
+ * user has edited without `--force`, and always back up before overwriting.
+ */
+import { type CompanionSkill, type SkillInstallPlan } from "./skills.js";
+/**
+ * Directory holding the bundled skill sources. The module lives at `src/` in
+ * dev/tests and `dist/src/` once published, so the relative depth to the
+ * package-root `skills/` differs — walk up from the module dir until we find a
+ * `skills/wrap/SKILL.md`, which is unambiguous in either layout.
+ */
+export declare function bundledSkillsDir(): string;
+export interface InstallSkillsOptions {
+    home?: string | undefined;
+    sourceDir?: string | undefined;
+    names?: CompanionSkill[] | undefined;
+    force?: boolean | undefined;
+    dryRun?: boolean | undefined;
+}
+export interface SkillInstallResult {
+    plan: SkillInstallPlan;
+    applied: boolean;
+    backedUp: string[];
+}
+/**
+ * Install (copy) the requested skills, backing up any file an `--force`
+ * overwrite would replace. Pure-of-prompts: callers handle confirmation + I/O
+ * reporting. Returns one result per requested skill.
+ */
+export declare function installCompanionSkills(opts?: InstallSkillsOptions): SkillInstallResult[];
+export type SkillsSubcommand = "install" | "uninstall" | "list";
+export interface RunSkillsOptions {
+    subcommand: SkillsSubcommand;
+    names?: CompanionSkill[] | undefined;
+    yes: boolean;
+    dryRun: boolean;
+    force: boolean;
+    /** Test seams. */
+    home?: string | undefined;
+    sourceDir?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+}
+export declare function runSkills(opts: RunSkillsOptions): Promise<number>;

package/dist/src/skillsCmd.js

@@ -0,0 +1,272 @@
+/**
+ * `memhook skills install|uninstall|list` — copy the bundled companion skills
+ * (/wrap, /curate, /relay) into `~/.claude/skills/<name>/`.
+ *
+ * This is the I/O shell around the pure planner in src/skills.ts (same split as
+ * init.ts ↔ install.ts). All reads/writes/backups live here; the plan logic is
+ * pure and unit-tested. These are INTERACTIVE, user-invoked commands — not the
+ * hook path — so they may use the TTY and exit non-zero on user error
+ * (docs/SPECIFICATION.md §9). The one safety rule: never clobber a skill the
+ * user has edited without `--force`, and always back up before overwriting.
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmdirSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
+import { makeAnsi } from "./ansi.js";
+import { backupPath, stampNow } from "./backup.js";
+import { COMPANION_SKILLS, SKILL_FILES, diffSkill, planInstall, planUninstall, } from "./skills.js";
+/**
+ * Directory holding the bundled skill sources. The module lives at `src/` in
+ * dev/tests and `dist/src/` once published, so the relative depth to the
+ * package-root `skills/` differs — walk up from the module dir until we find a
+ * `skills/wrap/SKILL.md`, which is unambiguous in either layout.
+ */
+export function bundledSkillsDir() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 6; i++) {
+        const candidate = join(dir, "skills");
+        if (existsSync(join(candidate, "wrap", "SKILL.md")))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Fallback: best guess relative to the published layout (dist/src → root).
+    return fileURLToPath(new URL("../../skills/", import.meta.url));
+}
+function skillDir(home, name) {
+    return join(home, ".claude", "skills", name);
+}
+/** Read a skill's bundled files. Throws if a shipped file is missing (a packaging bug). */
+function readSources(sourceDir, name) {
+    const dir = join(sourceDir, name);
+    const out = {};
+    for (const rel of SKILL_FILES[name])
+        out[rel] = readFileSync(join(dir, rel), "utf8");
+    return out;
+}
+/** Read what's installed for a skill; a missing/unreadable file maps to `null`. */
+function readInstalled(home, name) {
+    const dir = skillDir(home, name);
+    const out = {};
+    for (const rel of SKILL_FILES[name]) {
+        try {
+            out[rel] = readFileSync(join(dir, rel), "utf8");
+        }
+        catch {
+            out[rel] = null;
+        }
+    }
+    return out;
+}
+/**
+ * Install (copy) the requested skills, backing up any file an `--force`
+ * overwrite would replace. Pure-of-prompts: callers handle confirmation + I/O
+ * reporting. Returns one result per requested skill.
+ */
+export function installCompanionSkills(opts = {}) {
+    const home = opts.home ?? homedir();
+    const sourceDir = opts.sourceDir ?? bundledSkillsDir();
+    const names = opts.names ?? [...COMPANION_SKILLS];
+    const force = opts.force ?? false;
+    const dryRun = opts.dryRun ?? false;
+    const stamp = stampNow();
+    const results = [];
+    for (const name of names) {
+        const source = readSources(sourceDir, name);
+        const installed = readInstalled(home, name);
+        const plan = planInstall(name, source, installed, { force });
+        const backedUp = [];
+        let applied = false;
+        if (!dryRun && (plan.action === "install" || plan.action === "overwrite")) {
+            const dir = skillDir(home, name);
+            for (const rel of plan.writes) {
+                const dest = join(dir, rel);
+                if (plan.action === "overwrite" && installed[rel] != null) {
+                    const bak = backupPath(dest, stamp);
+                    try {
+                        copyFileSync(dest, bak);
+                        backedUp.push(bak);
+                    }
+                    catch {
+                        /* best-effort backup; never abort the install on a backup miss */
+                    }
+                }
+                mkdirSync(dirname(dest), { recursive: true });
+                writeFileSync(dest, source[rel], "utf8");
+            }
+            applied = true;
+        }
+        results.push({ plan, applied, backedUp });
+    }
+    return results;
+}
+function makeIo(env) {
+    const ansi = makeAnsi({ isTTY: Boolean(process.stdout.isTTY), env });
+    return { out: (s) => process.stdout.write(s + "\n"), ansi };
+}
+const STATUS_LABEL = {
+    absent: "not installed",
+    identical: "installed (up to date)",
+    differs: "installed (differs from shipped)",
+};
+export async function runSkills(opts) {
+    const env = opts.env ?? process.env;
+    const io = makeIo(env);
+    const { ansi } = io;
+    const home = opts.home ?? homedir();
+    const sourceDir = opts.sourceDir ?? bundledSkillsDir();
+    const names = opts.names && opts.names.length > 0 ? opts.names : [...COMPANION_SKILLS];
+    const interactive = !opts.yes && Boolean(process.stdin.isTTY) && !opts.dryRun;
+    if (opts.subcommand === "list") {
+        io.out(ansi.bold("memhook companion skills"));
+        for (const name of names) {
+            const status = diffSkill(readSources(sourceDir, name), readInstalled(home, name));
+            const dot = status === "identical"
+                ? ansi.green("●")
+                : status === "differs"
+                    ? ansi.yellow("●")
+                    : ansi.dim("○");
+            io.out(`  ${dot} /${name} ${ansi.dim(`— ${STATUS_LABEL[status]}`)}`);
+            io.out(`      ${ansi.dim(skillDir(home, name))}`);
+        }
+        io.out(ansi.dim("\nInstall with `memhook skills install`. Invoke as /wrap, /curate, /relay."));
+        return 0;
+    }
+    if (opts.subcommand === "uninstall") {
+        const plans = names.map((name) => planUninstall(name, readSources(sourceDir, name), readInstalled(home, name)));
+        const toRemove = plans.filter((p) => p.present);
+        io.out(ansi.bold("memhook skills uninstall") + ansi.dim(" — remove bundled companion skills\n"));
+        if (toRemove.length === 0) {
+            io.out(ansi.dim("No memhook companion skills found. Nothing to do."));
+            return 0;
+        }
+        io.out(ansi.bold("Plan"));
+        for (const p of plans) {
+            if (p.present) {
+                io.out(`  ${ansi.red("-")} /${p.name} ${ansi.dim(`(${p.removes.length} file(s))`)}`);
+            }
+            else {
+                io.out(`  ${ansi.dim("·")} /${p.name} ${ansi.dim("(not installed — skip)")}`);
+            }
+        }
+        if (opts.dryRun) {
+            io.out(ansi.dim("\n(dry run — nothing removed)"));
+            return 0;
+        }
+        if (interactive && !(await confirm(ansi, "[y/N]", false))) {
+            io.out(ansi.dim("Aborted. Nothing removed."));
+            return 0;
+        }
+        const stamp = stampNow();
+        const skillsRoot = join(home, ".claude", "skills");
+        let removed = 0;
+        for (const p of toRemove) {
+            const dir = skillDir(home, p.name);
+            const source = readSources(sourceDir, p.name);
+            for (const rel of p.removes) {
+                const target = join(dir, rel);
+                // Back up only a file the user edited (differs from shipped), and place
+                // the backup OUTSIDE the skill dir so the dir can be cleanly removed. A
+                // pristine shipped file is just deleted — it's recoverable by reinstall.
+                let content = null;
+                try {
+                    content = readFileSync(target, "utf8");
+                }
+                catch {
+                    /* already gone */
+                }
+                if (content !== null && content !== source[rel]) {
+                    const bak = join(skillsRoot, `${p.name}.${rel.replace(/[\\/]/g, "_")}.bak-${stamp}`);
+                    try {
+                        copyFileSync(target, bak);
+                    }
+                    catch {
+                        /* best-effort backup */
+                    }
+                }
+                try {
+                    unlinkSync(target);
+                    removed++;
+                }
+                catch {
+                    /* already gone */
+                }
+            }
+            try {
+                rmdirSync(dir); // only succeeds if the dir is now empty — leaves user files alone
+            }
+            catch {
+                /* non-empty or missing — fine */
+            }
+        }
+        io.out(`${ansi.green("✓")} removed ${removed} file(s) from ${toRemove.length} skill(s)`);
+        io.out(ansi.dim("Restart Claude Code to drop the skills from the menu."));
+        return 0;
+    }
+    // install
+    io.out(ansi.bold("memhook skills install") + ansi.dim(" — copy /wrap, /curate, /relay\n"));
+    const preview = installCompanionSkills({
+        home,
+        sourceDir,
+        names,
+        force: opts.force,
+        dryRun: true,
+    });
+    const willWrite = preview.filter((r) => r.plan.action === "install" || r.plan.action === "overwrite");
+    const blocked = preview.filter((r) => r.plan.action === "blocked");
+    io.out(ansi.bold("Plan"));
+    for (const r of preview) {
+        const { name, action, status } = r.plan;
+        if (action === "install")
+            io.out(`  ${ansi.green("+")} /${name} ${ansi.dim("(new)")}`);
+        else if (action === "overwrite")
+            io.out(`  ${ansi.yellow("~")} /${name} ${ansi.dim("(overwrite — backup first)")}`);
+        else if (action === "skip")
+            io.out(`  ${ansi.dim("·")} /${name} ${ansi.dim("(up to date — skip)")}`);
+        else
+            io.out(`  ${ansi.yellow("!")} /${name} ${ansi.dim(`(${STATUS_LABEL[status]} — use --force to overwrite)`)}`);
+    }
+    if (willWrite.length === 0) {
+        if (blocked.length > 0) {
+            io.out(ansi.dim(`\n${blocked.length} skill(s) differ from shipped. Re-run with --force to overwrite (a backup is made first).`));
+        }
+        else {
+            io.out(ansi.dim("\nAll skills are already up to date. Nothing to do."));
+        }
+        return 0;
+    }
+    if (opts.dryRun) {
+        io.out(ansi.dim("\n(dry run — nothing written)"));
+        return 0;
+    }
+    if (interactive && !(await confirm(ansi, "[Y/n]", true))) {
+        io.out(ansi.dim("Aborted. Nothing written."));
+        return 0;
+    }
+    const results = installCompanionSkills({ home, sourceDir, names, force: opts.force });
+    const applied = results.filter((r) => r.applied);
+    io.out(`${ansi.green("✓")} installed ${applied.length} skill(s) into ${skillDir(home, "<name>")}`);
+    if (blocked.length > 0) {
+        io.out(ansi.dim(`  ${blocked.length} skill(s) left untouched (differ from shipped — use --force).`));
+    }
+    io.out(ansi.dim("Restart Claude Code, then use /wrap, /curate, /relay."));
+    return 0;
+}
+async function confirm(ansi, hint, defaultYes) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const a = (await rl.question(`\n${ansi.bold("Proceed?")} ${ansi.dim(hint)} `))
+            .trim()
+            .toLowerCase();
+        if (a === "")
+            return defaultYes;
+        return a === "y" || a === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/src/tail.d.ts

@@ -73,4 +73,3 @@ export interface TailOptions {
     status?: string[] | undefined;
 }
 export declare function runTail(opts: TailOptions, env?: NodeJS.ProcessEnv): Promise<number>;
-//# sourceMappingURL=tail.d.ts.map

package/dist/src/tail.js

@@ -227,10 +227,15 @@ export async function runTail(opts, env = process.env) {
         if (passesFilter(row, filter))
             out(formatRow(row, ansi, columns));
     };
-    // Initial tail of the existing log.
+    // Initial tail of the existing log. Capture the follow offset from the SAME
+    // buffer rendered here, so a line appended between this read and the offset
+    // snapshot can't be skipped in the live view.
+    let offset = 0;
     if (existsSync(logPath)) {
-        for (const line of tailLines(readFileSync(logPath, "utf8"), opts.lines))
+        const initial = readFileSync(logPath, "utf8");
+        for (const line of tailLines(initial, opts.lines))
             render(line);
+        offset = Buffer.byteLength(initial, "utf8");
     }
     if (opts.noFollow) {
         out(formatFooter(stats, ansi, columns));
@@ -246,7 +251,6 @@ export async function runTail(opts, env = process.env) {
     });
     if (!existsSync(logPath))
         out(ansi.dim("  waiting for the first prompt…"));
-    let offset = existsSync(logPath) ? statSync(logPath).size : 0;
     let buffer = "";
     while (!stop) {
         await Promise.race([sleep(POLL_MS), stopped]);
@@ -277,4 +281,3 @@ export async function runTail(opts, env = process.env) {
     out("\n" + formatFooter(stats, ansi, columns));
     return 0;
 }
-//# sourceMappingURL=tail.js.map

package/dist/src/version.d.ts

@@ -9,5 +9,4 @@
  * the literal in lockstep with `package.json` + `.release-please-manifest.json`.
  * Do not bump it by hand.
  */
-export declare const MEMHOOK_VERSION = "0.3.0";
-//# sourceMappingURL=version.d.ts.map
+export declare const MEMHOOK_VERSION = "0.4.1";