greprag 5.78.7 → 5.80.0

package/dist/claude-lifecycle-cutover.js

@@ -66,11 +66,11 @@ function adapterFor(skill) {
 function safeTimestamp(now) {
     return now.toISOString().replace(/[:.]/g, '-');
 }
-function requiredSkills(skills) {
+function requiredSkills(skills, names) {
     const byName = new Map(skills
         .filter(skill => skill.scope !== 'project')
         .map(skill => [skill.skillName, skill]));
-    return exports.CLAUDE_LIFECYCLE_SKILLS.map(name => {
+    return names.map(name => {
         const skill = byName.get(name);
         if (!skill)
             throw new Error(`Canonical Claude lifecycle skill missing: ${name}.`);
@@ -80,12 +80,17 @@ function requiredSkills(skills) {
 /**
  * Explicit, narrow Claude cutover. Only SKILL.md becomes mirror-managed;
  * companion scripts and docs remain untouched in the native package.
+ *
+ * `names` selects which mirrored skills to materialize; it defaults to the
+ * lifecycle triple. Naming skills explicitly is how a Claude Code operator
+ * closes an adapter gap without arming a fleet-wide sweep.
  */
 function applyClaudeLifecycleCutover(params) {
     const homeDir = params.homeDir || os.homedir();
     const root = (0, native_skill_mirror_1.nativeSkillRoot)('claude-code', homeDir);
     const state = readState(root);
-    const prepared = requiredSkills(params.skills).map(skill => {
+    const names = params.names?.length ? params.names : exports.CLAUDE_LIFECYCLE_SKILLS;
+    const prepared = requiredSkills(params.skills, names).map(skill => {
         const target = path.join(root, skill.skillName);
         const skillMd = path.join(target, 'SKILL.md');
         const adapterFiles = adapterFor(skill);
@@ -137,16 +142,18 @@ function applyClaudeLifecycleCutover(params) {
     return result;
 }
 async function syncClaudeLifecycleCutover(params) {
+    const names = params.names?.length ? [...new Set(params.names)] : [...exports.CLAUDE_LIFECYCLE_SKILLS];
     const list = await fetch(`${params.apiUrl}/v1/skillmirror`, {
         headers: { Authorization: `Bearer ${params.apiKey}` },
     });
     if (!list.ok)
         throw new Error(`skill mirror list failed: HTTP ${list.status}`);
     const data = await list.json();
-    const wanted = new Set(exports.CLAUDE_LIFECYCLE_SKILLS);
+    const wanted = new Set(names);
     const rows = (data.skills || []).filter(row => wanted.has(row.skillName) && row.scope !== 'project');
-    if (rows.length !== exports.CLAUDE_LIFECYCLE_SKILLS.length) {
-        throw new Error('Canonical Claude lifecycle skill list is incomplete; native files preserved.');
+    if (rows.length !== names.length) {
+        const missing = names.filter(name => !rows.some(row => row.skillName === name));
+        throw new Error(`Not in the global skill mirror: ${missing.join(', ')}; native files preserved.`);
     }
     const fetched = await Promise.all(rows.map(async (row) => {
         const query = new URLSearchParams({ skillId: row.skillId || `global:${row.skillName}` });
@@ -170,5 +177,6 @@ async function syncClaudeLifecycleCutover(params) {
     return applyClaudeLifecycleCutover({
         skills: fetched,
         homeDir: params.homeDir,
+        names,
     });
 }

package/dist/commands/announce.js

@@ -0,0 +1,97 @@
+"use strict";
+/** `greprag announce` — print the full SessionStart announce.
+ *
+ *  The Claude Code harness inlines only ~2KB of hook context (measured; see
+ *  ANNOUNCE_INLINE_BUDGET). The recap hook therefore parks the complete announce
+ *  under ~/.greprag/announce/<session>.md and inlines a pointer naming this
+ *  command. Without it the overflow is unreachable — which is exactly the
+ *  failure this exists to end.
+ *
+ *  adr: adr/announce-inline-budget.md
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAnnounce = runAnnounce;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const session_id_1 = require("../session-id");
+function announceDir() {
+    return path.join(os.homedir(), '.greprag', 'announce');
+}
+/** Newest cached announce, by mtime. Used when no session id is given — the
+ *  common case, since an agent asking for its own announce rarely wants to
+ *  first go find its session id. */
+function newestCached() {
+    try {
+        const dir = announceDir();
+        const files = fs.readdirSync(dir)
+            .filter(f => f.endsWith('.md'))
+            .map(f => ({ f, t: fs.statSync(path.join(dir, f)).mtimeMs }))
+            .sort((a, b) => b.t - a.t);
+        return files.length ? path.join(dir, files[0].f) : null;
+    }
+    catch {
+        return null;
+    }
+}
+function runAnnounce(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write('greprag announce — print the full SessionStart announce\n\n'
+            + 'USAGE\n'
+            + '  greprag announce [--session <8hex>] [--path]\n\n'
+            + '  The harness inlines only ~2KB of session-start context. The rest is\n'
+            + '  parked on disk; this prints all of it.\n\n'
+            + '  --session <8hex>  a specific session (default: most recent)\n'
+            + '  --path            print the cache file path instead of its contents\n');
+        return;
+    }
+    const i = args.indexOf('--session');
+    const wanted = i !== -1 ? args[i + 1] : undefined;
+    const file = wanted
+        ? path.join(announceDir(), `${(0, session_id_1.truncateSessionId)(wanted) || wanted}.md`)
+        : newestCached();
+    if (!file || !fs.existsSync(file)) {
+        process.stderr.write('No cached announce found. It is written at SessionStart, so a session '
+            + 'must have started since this greprag version was installed.\n');
+        process.exitCode = 1;
+        return;
+    }
+    if (args.includes('--path')) {
+        process.stdout.write(file + '\n');
+        return;
+    }
+    process.stdout.write(fs.readFileSync(file, 'utf-8').trimEnd() + '\n');
+}

package/dist/commands/init.js

@@ -1459,13 +1459,26 @@ function applySettings(settings, apiKey) {
         matcher: '',
         hooks: [{ type: 'command', command: 'greprag-hook store', timeout: 10000 }],
     };
+    // Migrate stale installs onto the every-source matcher. `hasGrepragHook` only
+    // asks whether a recap hook EXISTS, so an install written by an older version
+    // kept its narrow matcher forever while init reported "already configured".
+    // Field state 2026-09-03: `matcher: 'startup'`, so a resumed session — and
+    // every /new and dashboard-dispatched agent — got no announce at all, Persona
+    // included. Same failure and same fix as the Grok path above.
+    // adr: adr/announce-inline-budget.md
+    const retargetedRecap = settings.hooks.SessionStart
+        ? retargetGrepragHookMatcher(settings.hooks.SessionStart, 'recap', ['startup', 'startup|resume', 'startup|resume|compact', 'startup|clear|compact'], recapHook.matcher)
+        : 0;
+    if (retargetedRecap > 0) {
+        changes.push(`Retargeted SessionStart recap matcher to every source (${retargetedRecap})`);
+    }
     if (!hasGrepragHook(settings.hooks.SessionStart, 'recap')) {
         if (!settings.hooks.SessionStart)
             settings.hooks.SessionStart = [];
         settings.hooks.SessionStart.push(recapHook);
         changes.push('Added SessionStart hook (memory recap + inbox digest)');
     }
-    else {
+    else if (retargetedRecap === 0) {
         changes.push('SessionStart hook already configured (skipped)');
     }
     if (!hasGrepragHook(settings.hooks.Stop, 'store')) {

package/dist/commands/load.js

@@ -55,6 +55,9 @@ exports.runLoad = runLoad;
 exports.normalizeLoadName = normalizeLoadName;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const harness_1 = require("../harness");
+const skill_activation_manifest_1 = require("../skill-activation-manifest");
 const project_anchor_1 = require("../project-anchor");
 const proc_1 = require("../proc");
 const skill_staleness_1 = require("../skill-staleness");
@@ -171,13 +174,30 @@ async function printCatalog() {
     const data = await mirrorGet('/v1/skillmirror');
     const skills = data?.skills || [];
     if (skills.length > 0) {
+        // A mirrored skill with no native adapter on this harness never reaches the
+        // harness's own skill list — the agent can only reach it through this
+        // catalog. Mark the gap here and name the command that closes it.
+        const platform = (0, harness_1.inferCurrentHarness)() || '';
+        const installed = platform
+            ? (0, skill_activation_manifest_1.readNativeSkillNames)({ platform, cwd: process.cwd(), homeDir: os.homedir() })
+            : new Set();
+        const missing = platform
+            ? skills.map((s) => s.skillName || '').filter((n) => n && !installed.has(n.toLowerCase()))
+            : [];
         const w = Math.max(...skills.map((s) => (s.skillName || '').length), 8);
         console.log('\nYour mirrored skills (auto-fresh from use — work on any machine/harness):\n');
         for (const s of skills) {
             if (!s.skillName)
                 continue;
             const scope = s.scope === 'project' && s.projectId ? ` [project:${s.projectId.slice(0, 8)}]` : '';
-            console.log(`  ${(s.skillName + scope).padEnd(w + 20)}  ${(s.description || '').slice(0, 110)}`);
+            const gap = missing.includes(s.skillName) ? ' *' : '';
+            console.log(`  ${(s.skillName + scope + gap).padEnd(w + 20)}  ${(s.description || '').slice(0, 110)}`);
+        }
+        const installCommand = (0, skill_activation_manifest_1.nativeAdapterInstallCommand)(platform, missing);
+        if (installCommand) {
+            console.log(`\n  * ${missing.length} skill(s) have no ${platform} adapter installed — they never appear`);
+            console.log('    in this harness\'s own skill list. Install the adapters with:\n');
+            console.log(`      ${installCommand}\n`);
         }
     }
     console.log('\n  greprag load <name>            print the full entry / mirrored skill');

package/dist/commands/reminder-registry.js

@@ -5,10 +5,12 @@
  *  PURE over ReminderEnv — the hook assembles env (i/o) and emits the returned lines;
  *  a broken module never blocks a turn (fail-open per module). */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compactReannounceModules = exports.commandModules = exports.promptModules = exports.harnessModules = exports.REGISTRY = void 0;
+exports.ANNOUNCE_HARNESS_CAP = exports.ANNOUNCE_INLINE_BUDGET = exports.compactReannounceModules = exports.commandModules = exports.promptModules = exports.harnessModules = exports.REGISTRY = void 0;
 exports.collectReminders = collectReminders;
 exports.bootOrder = bootOrder;
 exports.collectAnnounces = collectAnnounces;
+exports.collectAnnounceBlocks = collectAnnounceBlocks;
+exports.fitAnnounceBudget = fitAnnounceBudget;
 const os_primer_reminder_1 = require("./os-primer-reminder");
 const inbox_primer_reminder_1 = require("./inbox-primer-reminder");
 const load_primer_reminder_1 = require("./load-primer-reminder");
@@ -147,3 +149,89 @@ function collectAnnounces(env, registry = exports.REGISTRY) {
     }
     return out;
 }
+/** Same as collectAnnounces, but keeps each block paired with the module that
+ *  produced it so the budget fitter can rank and name them.
+ *  adr: adr/announce-inline-budget.md */
+function collectAnnounceBlocks(env, registry = exports.REGISTRY) {
+    const out = [];
+    for (const m of bootOrder(registry)) {
+        let a = null;
+        try {
+            a = m.announce(env);
+        }
+        catch {
+            continue;
+        }
+        if (a)
+            out.push({ id: m.id, text: a });
+    }
+    return out;
+}
+/** Bytes of SessionStart context a harness will actually inline. MEASURED, not
+ *  guessed: Claude Code wraps any hook output over 2048 bytes in
+ *  `<persisted-output>`, spills the full text to a tool-results file, and injects
+ *  only "Preview (first 2KB)". This is true of BOTH raw stdout and the
+ *  `additionalContext` envelope — the cap is on inline context, not the channel.
+ *  Measured 2026-09-03 with an 80-marker ruler: markers 250..2000 arrived, 2250
+ *  and beyond did not. 1800 leaves headroom for the harness's own wrapper text.
+ *  adr: adr/announce-inline-budget.md */
+exports.ANNOUNCE_INLINE_BUDGET = 1650;
+/** The harness's hard ceiling. Past this, output is replaced by a 2KB preview and
+ *  a `<persisted-output>` file reference. ANNOUNCE_INLINE_BUDGET must stay under
+ *  it with room for the trailing memory-recap pointer. */
+exports.ANNOUNCE_HARNESS_CAP = 2048;
+/** Inline-worthiness ranking, most-keepable first. The rule: a block earns inline
+ *  space when it is SHORT, SESSION-SPECIFIC, and available nowhere else. A block
+ *  that is long, static, and already loadable on demand does not — it is exactly
+ *  what `greprag load` exists for. Anything unlisted sorts last.
+ *
+ *  Persona leads because it is 523 bytes of tenant-set speaking instructions that
+ *  no other surface carries. The grepragOS laws are deliberately NOT here: 1753
+ *  bytes of static doctrine that `greprag load os` already serves on demand, which
+ *  until now consumed the entire budget and starved everything behind it. */
+const ANNOUNCE_PRIORITY = [
+    'persona-announce',
+    'setup-warning',
+    'version-upgrade',
+    'enrichment-health',
+    'watcher-arm',
+    'skill-mirror-announce',
+    'delivery-control',
+    'doc-pointer-announce',
+];
+function announceRank(id) {
+    const i = ANNOUNCE_PRIORITY.indexOf(id);
+    return i === -1 ? ANNOUNCE_PRIORITY.length : i;
+}
+/** Fit the announce into the harness's inline budget.
+ *
+ *  Returns the blocks that fit (restored to boot order, so a primer still precedes
+ *  anything that depends on it) plus the ids that did not. The caller is expected
+ *  to persist the FULL text and give the agent a way to read it — dropping content
+ *  silently is the failure this whole mechanism exists to end.
+ *
+ *  A single block larger than the budget is never emitted; it would blow the cap
+ *  on its own and take everything after it down too. */
+function fitAnnounceBudget(blocks, budget = exports.ANNOUNCE_INLINE_BUDGET, reserve = 0) {
+    const order = new Map(blocks.map((b, i) => [b.id, i]));
+    const ranked = [...blocks].sort((a, b) => {
+        const d = announceRank(a.id) - announceRank(b.id);
+        return d !== 0 ? d : (order.get(a.id) - order.get(b.id));
+    });
+    const kept = [];
+    const droppedIds = [];
+    let used = reserve;
+    const SEP = 2; // the '\n\n' join between blocks
+    for (const b of ranked) {
+        const cost = b.text.length + (kept.length ? SEP : 0);
+        if (used + cost <= budget) {
+            kept.push(b);
+            used += cost;
+        }
+        else {
+            droppedIds.push(b.id);
+        }
+    }
+    kept.sort((a, b) => order.get(a.id) - order.get(b.id));
+    return { kept, droppedIds };
+}

package/dist/commands/skill-mirror-reminder.js

@@ -8,13 +8,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.skillMirrorAnnounceModule = exports.SKILL_ACTIVATION_MANIFEST_MAX_CHARS = void 0;
 exports.buildSkillMirrorAnnounce = buildSkillMirrorAnnounce;
+const skill_activation_manifest_1 = require("../skill-activation-manifest");
 exports.SKILL_ACTIVATION_MANIFEST_MAX_CHARS = 64_000;
 function renderEntry(skill) {
     const description = skill.triggerDescription.trim().replace(/\r\n?/g, '\n');
     const lines = description.split('\n');
     return `- ${skill.skillName}: ${lines[0]}${lines.slice(1).map(line => `\n  ${line}`).join('')}`;
 }
-function buildSkillMirrorAnnounce(m) {
+function buildSkillMirrorAnnounce(m, platform) {
     if (!m || m.count <= 0)
         return null;
     if (m.skills.length === 0) {
@@ -23,6 +24,21 @@ function buildSkillMirrorAnnounce(m) {
             + 'keep storage mechanics internal unless diagnosing a failure or the user asks how it works. '
             + 'Use `greprag load <skill>` to read skill instructions.]';
     }
+    // The entries this harness does not advertise are exactly the mirrored
+    // skills with no native adapter installed. Name the gap and the one command
+    // that closes it, or it stays invisible until the operator spots it by hand.
+    const installCommand = (0, skill_activation_manifest_1.nativeAdapterInstallCommand)(platform || '', m.skills.map(s => s.skillName));
+    const gapSection = installCommand ? [
+        '### Missing Native Adapters',
+        `${m.skills.length} of these skills are in your GrepRAG mirror but have NO adapter installed in this harness, `
+            + 'so they never appear in the native skill list. Install the adapters once with:',
+        '',
+        `    ${installCommand}`,
+        '',
+        'Offer that command when the user asks why a skill is missing, or when you needed one of them this session. '
+            + 'Until adapters are installed, the trigger rules below are the only way these skills activate.',
+        '',
+    ] : [];
     const header = [
         '## GrepRAG Skills',
         `Slash skills are available through \`greprag load\`; ${m.skills.length} skills need this startup trigger list`
@@ -30,6 +46,7 @@ function buildSkillMirrorAnnounce(m) {
             + '.',
         'When discussing skills with the user, say use/create/update/refresh `/skill`; keep storage mechanics internal unless diagnosing a failure or the user asks how it works.',
         '',
+        ...gapSection,
         '### Trigger Rules',
         'If the user names a skill (with or without `/`) OR the request clearly matches a skill\'s description below, '
             + 'you MUST activate that skill for the current turn. Match meaning, not exact keywords.',
@@ -58,6 +75,6 @@ exports.skillMirrorAnnounceModule = {
     source: 'prompt',
     dependsOn: ['load-primer'], // references `greprag load` — the primer establishes it
     detect: (_env) => ({ tier: 'silent' }), // announce-only
-    announce: (env) => buildSkillMirrorAnnounce(env.mirroredSkills),
+    announce: (env) => buildSkillMirrorAnnounce(env.mirroredSkills, env.platform),
     reminder: () => null,
 };

package/dist/commands/skill.js

@@ -47,6 +47,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readOnlyNames = readOnlyNames;
 exports.runSkill = runSkill;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -59,6 +60,22 @@ const skill_mirror_client_1 = require("../skill-mirror-client");
 const skill_landing_1 = require("../skill-landing");
 const skill_staleness_1 = require("../skill-staleness");
 const CORE_SKILL = 'greprag';
+const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** `--only a,b` / `--only=a,b` / repeated `--only a --only b` → skill names. */
+function readOnlyNames(args) {
+    const raw = [];
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--only' && args[i + 1])
+            raw.push(args[++i]);
+        else if (args[i].startsWith('--only='))
+            raw.push(args[i].slice('--only='.length));
+    }
+    const names = [...new Set(raw.flatMap(value => value.split(',')).map(v => v.trim()).filter(Boolean))];
+    const invalid = names.filter(name => !SKILL_NAME_RE.test(name));
+    if (invalid.length > 0)
+        throw new Error(`--only got invalid skill name(s): ${invalid.join(', ')}`);
+    return names;
+}
 const SKILL_HELP = `greprag skill — manage bundled advisor skills
 
 USAGE
@@ -69,6 +86,8 @@ USAGE
                                       Export/edit/apply helper; opens $EDITOR unless --no-open or Codex
   greprag skill mirror sync [harness] Install native GrepRAG skill adapters
     claude-code --cutover-lifecycle    Cut over commit/deploy/release only
+    claude-code --only <a,b>           Install adapters for named mirrored skills
+                                       (closes the gaps greprag load marks with *)
   greprag skill mirror export <name> --to <dir>
                                       Export canonical skill bytes for editing
   greprag skill mirror apply <dir> --skill <name> --expected-hash <hash>
@@ -631,7 +650,11 @@ async function runSkill(args) {
             }
             const dryRun = args.includes('--dry-run');
             const claudeLifecycleCutover = args.includes('--cutover-lifecycle');
-            const positional = args.slice(2).filter(arg => !arg.startsWith('-'));
+            // `--only a,b` names the mirrored skills to materialize as claude-code
+            // adapters — the one command that closes an adapter gap the catalog and
+            // the SessionStart announce report, without arming a fleet-wide sweep.
+            const onlyNames = readOnlyNames(args.slice(2));
+            const positional = args.slice(2).filter((arg, index, all) => !arg.startsWith('-') && all[index - 1] !== '--only');
             const requested = positional[0] || 'all';
             const platforms = requested === 'all'
                 ? [...native_skill_mirror_1.NATIVE_SKILL_ADAPTER_PLATFORMS]
@@ -645,23 +668,28 @@ async function runSkill(args) {
             if (claudeLifecycleCutover && requested !== 'claude-code') {
                 throw new Error('--cutover-lifecycle requires harness claude-code.');
             }
+            if (onlyNames.length > 0 && requested !== 'claude-code') {
+                throw new Error('--only requires harness claude-code.');
+            }
+            const claudeTargeted = claudeLifecycleCutover || onlyNames.length > 0;
             const apiUrl = process.env.GREPRAG_API_URL || 'https://api.greprag.com';
             const anchor = (0, project_anchor_1.readAnchor)(process.cwd());
             if (requested === 'all') {
                 console.log('claude-code: native skill adapter sync disabled until Claude cutover approval.');
             }
             for (const platform of platforms) {
-                if (platform === 'claude-code' && claudeLifecycleCutover) {
+                if (platform === 'claude-code' && claudeTargeted) {
+                    const names = onlyNames.length > 0 ? onlyNames : [...claude_lifecycle_cutover_1.CLAUDE_LIFECYCLE_SKILLS];
                     if (dryRun) {
-                        console.log(`claude-code: targeted lifecycle cutover would manage only ${claude_lifecycle_cutover_1.CLAUDE_LIFECYCLE_SKILLS.join(', ')}; companion files remain untouched.`);
+                        console.log(`claude-code: targeted cutover would manage only ${names.join(', ')}; companion files remain untouched.`);
                         continue;
                     }
                     const apiKey = process.env.GREPRAG_API_KEY || '';
                     if (!apiKey)
                         throw new Error('GREPRAG_API_KEY not set — run `greprag init` first.');
-                    const result = await (0, claude_lifecycle_cutover_1.syncClaudeLifecycleCutover)({ apiUrl, apiKey });
+                    const result = await (0, claude_lifecycle_cutover_1.syncClaudeLifecycleCutover)({ apiUrl, apiKey, names });
                     const active = result.installed + result.updated + result.current;
-                    console.log(`claude-code: ${active} lifecycle adapter(s) active; all other Claude skills remain unmanaged.`);
+                    console.log(`claude-code: ${active} adapter(s) active (${names.join(', ')}); all other Claude skills remain unmanaged.`);
                     if (result.backupDir)
                         console.log(`claude-code: replaced prompts backed up at ${result.backupDir}`);
                     continue;

package/dist/hook-once.js

@@ -41,6 +41,16 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const TTL_MS = 60_000;
+/** Events that fire once per TOOL CALL, not once per turn.
+ *
+ *  The stamp key is (session, event, subcommand, turn), so it can only dedupe an
+ *  event whose natural rate is one per turn — i.e. a leaked duplicate hook
+ *  registration double-firing `store`/`recap`/`notify`. A per-call event issues
+ *  many invocations under that ONE key, so claiming it lets the first call
+ *  through and silently drops every later one. For a validator such as
+ *  `pre-spawn-check` that is a fail-OPEN: the second chip of a turn is never
+ *  checked. These events are not dedupable by this key and are never claimed. */
+const PER_TOOL_CALL_EVENTS = new Set(['PreToolUse', 'PostToolUse']);
 function stampPath(sessionId, event, sub, turnId) {
     const safe = [sessionId, event, sub, turnId].join('-').replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 180);
     return path.join(os.homedir(), '.greprag', 'hook-once', `${safe}.json`);
@@ -49,6 +59,8 @@ function stampPath(sessionId, event, sub, turnId) {
 function claimHookOnce(sessionId, event, subcommand, turnId) {
     if (!sessionId)
         return true;
+    if (event && PER_TOOL_CALL_EVENTS.has(event))
+        return true;
     const key = turnId || 'noturn';
     const file = stampPath(sessionId, event || 'unknown', subcommand, key);
     try {