greprag 5.82.1 → 5.83.1

package/dist/claude-lifecycle-cutover.js

@@ -42,20 +42,6 @@ const path = __importStar(require("path"));
 const native_skill_mirror_1 = require("./native-skill-mirror");
 const skill_mirror_files_1 = require("./skill-mirror-files");
 exports.CLAUDE_LIFECYCLE_SKILLS = ['commit', 'deploy', 'release'];
-const STATE_FILE = '.greprag-mirror.json';
-function readState(root) {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(path.join(root, STATE_FILE), 'utf8'));
-        if (parsed?.version === 1 && parsed.skills && typeof parsed.skills === 'object')
-            return parsed;
-    }
-    catch { /* first targeted cutover */ }
-    return { version: 1, skills: {} };
-}
-function writeState(root, state) {
-    fs.mkdirSync(root, { recursive: true });
-    fs.writeFileSync(path.join(root, STATE_FILE), JSON.stringify(state, null, 2) + '\n', 'utf8');
-}
 function adapterFor(skill) {
     const files = (0, native_skill_mirror_1.buildNativeSkillAdapter)('claude-code', skill, { allowClaudeCode: true });
     if (!files || files.length !== 1 || files[0].path !== 'SKILL.md') {
@@ -88,10 +74,13 @@ function requiredSkills(skills, names) {
 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 state = (0, native_skill_mirror_1.readState)(root);
     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);
+        if ((0, skill_mirror_files_1.isSkillFolderOwnedElsewhere)(target)) {
+            throw new Error(`Claude skill folder is owned elsewhere (a link or another installer's package): ${skill.skillName}; not written.`);
+        }
         const skillMd = path.join(target, 'SKILL.md');
         const adapterFiles = adapterFor(skill);
         const nextHash = (0, skill_mirror_files_1.computeSkillFileHash)(adapterFiles);
@@ -138,7 +127,7 @@ function applyClaudeLifecycleCutover(params) {
         else
             result.installed++;
     }
-    writeState(root, state);
+    (0, native_skill_mirror_1.writeState)(root, state);
     return result;
 }
 async function syncClaudeLifecycleCutover(params) {

package/dist/commands/codex.js

@@ -472,6 +472,10 @@ function printCodexWatcherRetired() {
 async function runCodex(args) {
     const sub = args[0];
     if (!sub || sub === '--help' || sub === '-h' || sub === 'help') {
+        if (args[1] === 'chip')
+            return (0, command_1.runCodexChip)(['--help', ...args.slice(2)]);
+        if (args[1] === 'app-server')
+            return (0, codex_app_server_1.runCodexAppServer)(['--help', ...args.slice(2)]);
         console.log(HELP);
         return;
     }

package/dist/commands/collision-check.js

@@ -114,22 +114,25 @@ function dedupePeers(peers, announced) {
     const union = Array.from(new Set([...announced, ...peers.map(p => p.short)]));
     return { fresh, union };
 }
+// adr: adr/delivery-announce-pilot.md
 /** The LOUD directive — same `additionalContext` shape as the arm directive,
- *  naming each peer + instructing message-then-worktree. PURE. */
+ *  naming each peer + instructing message-then-worktree. PURE.
+ *  It asks no heads-up of Claude Code peers: Claude Code holds a message to a
+ *  session in another permission mode for that session's user and may let it
+ *  expire, and the sender cannot see modes, so silence there is not approval.
+ *  Delivery is the per-harness Delivery announce's alone, so step 3 defers. */
 function buildCollisionDirective(peers, myShort, alias) {
     const handle = alias || '<handle>';
     const lines = peers.map(p => `  · ${p.short}${p.title ? ` — "${p.title}"` : ''}`);
     const plural = peers.length === 1 ? '' : 's';
     return (`COLLISION DETECTED — ${peers.length} other live session${plural} working in this same repo right now:\n`
         + lines.join('\n') + '\n'
-        + `Coordinate BEFORE touching shared files: (1) message each peer now with a contextual heads-up — `
+        + `Coordinate BEFORE touching shared files: (1) message each peer above now with a contextual heads-up — `
         + `Codex peers: use \`codex_app.list_threads\` to find the task and its repo/workspace, then \`codex_app.send_message_to_thread\` to send the heads-up; `
-        + `Claude Code peers: use your harness's own session list + send tools — the 8-hex ids above are GREPRAG addresses and are not accepted by them; `
         + `peers OUTSIDE this harness (opencode / Grok / another tenant): \`greprag send "…what you're about to touch…" --to ${handle}@greprag.com/<their-8hex> --from-session ${myShort}\` `
         + `(YOU compose and send it — this is a notice, not an auto-send; recipients reply only for a concrete conflict, silence is approval, and you never poll or wait; watcher rows are not the Codex peer source of truth); `
-        + `(2) do your code work in a worktree on its own branch (\`git worktree add .claude/worktrees/<slug> -b <branch>\`); `
-        + `(3) at completion resolve \`.greprag/delivery.json\`, send one fire-and-forget delivery notice to PEER sessions only — never to a chip (title \`Chip: \` / \`Chip <Label>: \`), which reports to its own parent and has no business with merge, deploy or master — then continue immediately without polling, waiting, status reads, or follow-ups; `
-        + `sweep every ready same-repo commit, ignore all uncommitted and untracked work, resolve conflicts directly, and finish the declared push/deploy/release path. Never edit the shared default checkout concurrently.`);
+        + `(2) do your code work in a worktree on its own branch (\`git worktree add .claude/worktrees/<slug> -b <branch>\`), never in the shared default checkout; `
+        + `(3) at delivery, notify peers only as this harness's Delivery announce says.`);
 }
 /** Reduce the watcher list to OTHER live sessions that are NOT in my repo
  *  (cross-repo). Excludes self, same-repo collisions (those get the LOUD

package/dist/commands/corpus/client.js

@@ -47,6 +47,8 @@ exports.abortNotConfigured = abortNotConfigured;
 exports.apiCall = apiCall;
 exports.apiGet = apiGet;
 exports.apiDelete = apiDelete;
+exports.formatPassage = formatPassage;
+exports.getMaxChars = getMaxChars;
 exports.getFlag = getFlag;
 exports.getFlags = getFlags;
 exports.extractPositionals = extractPositionals;
@@ -143,6 +145,20 @@ async function apiDelete(url, apiKey, body) {
  *  Listing and search now answer from the same classification.
  *  adr: adr/searchable-store-kinds.md, adr: adr/corpus-tags.md */
 exports.INTERNAL_KINDS = ['inbox', 'fix', 'docptr', 'skillgain', 'parity', 'doctrine'];
+/** Body of one node for `walk` / `section`, indented under its header line.
+ *  Full text by default — these commands exist to read the whole passage around
+ *  a hit (search snippets stay short). `maxChars` is the explicit opt-in cut. */
+function formatPassage(content, maxChars) {
+    const text = maxChars && maxChars > 0 && content.length > maxChars
+        ? content.slice(0, maxChars) + `... [+${content.length - maxChars} chars]`
+        : content;
+    return text.split('\n').map((line) => `    ${line}`).join('\n');
+}
+/** `--max-chars N` → N, or undefined (full text). */
+function getMaxChars(args) {
+    const raw = getFlag(args, '--max-chars');
+    return raw ? parseInt(raw, 10) : undefined;
+}
 // -- Arg helpers -----------------------------------------------------------
 function getFlag(args, flag) {
     const idx = args.indexOf(flag);

package/dist/commands/corpus/index.js

@@ -57,10 +57,13 @@ Subcommands:
                                             --all = every store under the tenant;
                                             --store repeatable; --kind filters to
                                             one kind. Hits are labeled by store.
-  section <store> "<heading>"               Every node under a heading (forgiving
+  section <store> "<heading>" [--max-chars N]
+                                            Every node under a heading (forgiving
                                             match: any depth, dash/case-insensitive).
-  walk   <store> <nodeId> [--before 2 --after 2]
+  walk   <store> <nodeId> [--before 2 --after 2] [--max-chars N]
                                             Show a node and its neighbors.
+                                            section/walk print full node text;
+                                            --max-chars N cuts each node.
   status <store>                            Show write-side enrichment progress
                                             (per-node vocabulary bridge).
   refresh <store>                           Manually re-check a tracked source —

package/dist/commands/corpus/section.js

@@ -13,9 +13,10 @@ async function sectionCmd(args) {
     const storeRef = args[0];
     const headingPath = args[1];
     if (!storeRef || !headingPath) {
-        console.error('Usage: greprag corpus section <storeIdOrName> "<heading>"\n  e.g. greprag corpus section "Scientific Advertising" "Chapter 7"\n  Forgiving match: any depth, case-/dash-insensitive, leaf prefix.');
+        console.error('Usage: greprag corpus section <storeIdOrName> "<heading>" [--max-chars N]\n  e.g. greprag corpus section "Scientific Advertising" "Chapter 7"\n  Forgiving match: any depth, case-/dash-insensitive, leaf prefix.');
         process.exit(1);
     }
+    const maxChars = (0, client_1.getMaxChars)(args);
     const store = await (0, client_1.resolveStore)(storeRef, cfg.apiUrl, cfg.apiKey);
     const url = `${cfg.apiUrl}/v1/stores/${store.id}/section?path=${encodeURIComponent(headingPath)}`;
     const res = await (0, client_1.apiGet)(url, cfg.apiKey);
@@ -24,9 +25,8 @@ async function sectionCmd(args) {
     console.log(`\n${store.name} · section "${headingPath}" — ${res.nodes.length} node${res.nodes.length === 1 ? '' : 's'}\n`);
     for (const n of res.nodes) {
         const heading = n.headingPath?.length ? ` · ${n.headingPath.join(' / ')}` : '';
-        const snippet = n.content.length > 200 ? n.content.slice(0, 197) + '...' : n.content;
         console.log(`  [${n.nodeId}] pos=${n.position}${heading}`);
-        console.log(`    ${snippet.replace(/\n/g, ' ')}\n`);
+        console.log(`${(0, client_1.formatPassage)(n.content, maxChars)}\n`);
     }
     if (res.nodes.length === 0) {
         console.log('No nodes under that heading. Check a hit\'s headingPath from `corpus search`, or broaden the heading.');

package/dist/commands/corpus/walk.js

@@ -13,11 +13,12 @@ async function walkCmd(args) {
     const storeRef = args[0];
     const nodeId = args[1];
     if (!storeRef || !nodeId) {
-        console.error('Usage: greprag corpus walk <storeIdOrName> <nodeId> [--before 2 --after 2]');
+        console.error('Usage: greprag corpus walk <storeIdOrName> <nodeId> [--before 2 --after 2] [--max-chars N]');
         process.exit(1);
     }
     const before = parseInt((0, client_1.getFlag)(args, '--before') || '2', 10);
     const after = parseInt((0, client_1.getFlag)(args, '--after') || '2', 10);
+    const maxChars = (0, client_1.getMaxChars)(args);
     const store = await (0, client_1.resolveStore)(storeRef, cfg.apiUrl, cfg.apiKey);
     // Step 1: fetch the anchor node to learn its position.
     const anchorRes = await (0, client_1.apiGet)(`${cfg.apiUrl}/v1/stores/${store.id}/by-node-id/${nodeId}`, cfg.apiKey);
@@ -33,8 +34,7 @@ async function walkCmd(args) {
         const isAnchor = n.nodeId === nodeId;
         const marker = isAnchor ? '★' : ' ';
         const heading = n.headingPath?.length ? ` · ${n.headingPath.join(' / ')}` : '';
-        const snippet = n.content.length > 320 ? n.content.slice(0, 317) + '...' : n.content;
         console.log(`  ${marker} [${n.nodeId}] pos=${n.position}${heading}`);
-        console.log(`    ${snippet.replace(/\n/g, ' ')}\n`);
+        console.log(`${(0, client_1.formatPassage)(n.content, maxChars)}\n`);
     }
 }

package/dist/commands/delivery-reminder.js

@@ -18,18 +18,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deliveryControlModule = void 0;
 exports.buildDeliveryAnnounce = buildDeliveryAnnounce;
 // adr: adr/delivery-announce-pilot.md
-/** How THIS harness finds same-repo peers — the one line that legitimately
- *  differs per platform. Everything else about notifying (once, fire-and-forget,
- *  chips excluded, why greprag is not the address book) is shared prose that
- *  belongs in `greprag load delivery`, not in nine duplicated sentences here. */
+/** How THIS harness treats same-repo peers at delivery — the one line that
+ *  legitimately differs per platform. Everything else about notifying (once,
+ *  fire-and-forget, chips excluded, why Claude Code sends nothing) is shared
+ *  prose that belongs in `greprag load delivery`, not duplicated here. */
 function coordinationLine(platform) {
+    // Claude Code holds a message to a session in another permission mode for that
+    // session's user and may let it expire, and the sender cannot see the mode. A
+    // notice there can silently not arrive, so its silence was never approval.
+    if (platform === 'claude-code') {
+        return 'Send same-repo peers no delivery notice: Git is the coordination. Never poll, wait on, or ask peer sessions for status.';
+    }
     const how = platform === 'codex'
         ? 'codex_app.list_threads + codex_app.send_message_to_thread'
-        : platform === 'claude-code'
-            ? "this harness's own session-list + send tools (never a greprag id)"
-            : platform === 'opencode'
-                ? 'the GrepRAG registry'
-                : 'your harness\'s own peer tools';
+        : platform === 'opencode'
+            ? 'the GrepRAG registry'
+            : 'your harness\'s own peer tools';
     // Codex keeps its one extra word: `wait_threads` is the specific tool a Codex
     // session reaches for when it decides to wait for a reply it was told not to
     // wait for. A named tool is a rule; "do not wait" alone was not enough.

package/dist/commands/delivery.js

@@ -1,12 +1,49 @@
 "use strict";
+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.runDelivery = runDelivery;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const delivery_config_1 = require("../delivery-config");
 const HELP = `greprag delivery — resolve the current repo's delivery authority
 
 Usage:
   greprag delivery resolve [--json]
   greprag delivery status [--json]
+  greprag delivery init [--write]   draft this repo's profile (report only unless --write;
+                                    never overwrites an existing profile)
 
 Reads .greprag/delivery.json when present. During migration only, falls back to
 docs/deploy.md, docs/releases.md, then CLAUDE.md. Provider commands remain in
@@ -17,6 +54,8 @@ function runDelivery(args) {
         return;
     }
     const sub = args[0] || 'resolve';
+    if (sub === 'init')
+        return runInit(args.includes('--write'));
     if (sub !== 'resolve' && sub !== 'status') {
         console.error(`Unknown delivery command: ${sub}\n\n${HELP}`);
         process.exitCode = 1;
@@ -56,3 +95,28 @@ function runDelivery(args) {
     if (result.mode === 'missing' || result.mode === 'invalid')
         process.exitCode = 1;
 }
+function runInit(write) {
+    const draft = (0, delivery_config_1.draftDeliveryProfile)(process.cwd());
+    if (!draft) {
+        console.error('Not inside a Git repository.');
+        process.exitCode = 1;
+        return;
+    }
+    const target = (0, delivery_config_1.deliveryProfilePath)(draft.root);
+    if (fs.existsSync(target)) {
+        console.log(`Profile already exists: ${target}\nEdit it by hand; init never overwrites.`);
+        return;
+    }
+    const body = JSON.stringify(draft.profile, null, 2) + '\n';
+    console.log(`Draft profile for ${draft.root}:\n${body}`);
+    console.log(`Deploy signals: ${draft.providerSignals.join(', ') || 'none (commit-and-merge only)'}`);
+    for (const item of draft.todo)
+        console.log(`  todo: ${item}`);
+    if (!write) {
+        console.log('\nReport only. Rerun with --write to save it.');
+        return;
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, body);
+    console.log(`\nWrote ${target}. Commit it.`);
+}

package/dist/commands/docptr.js

@@ -51,9 +51,11 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runDocPtr = runDocPtr;
 const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 const proc_1 = require("../proc");
 const project_anchor_1 = require("../project-anchor");
 const docptr_refs_1 = require("../docptr-refs");
+const doc_mirror_client_1 = require("../doc-mirror-client");
 function getConfig() {
     return {
         apiUrl: process.env.GREPRAG_API_URL || 'https://api.greprag.com',
@@ -67,25 +69,6 @@ USAGE
         Judge every tracked, eligible .md and register the core ones — the
         one-time catch-up for docs that predate the system or are never edited.
         Idempotent. --missing-only skips already-registered docs.`;
-/** Mirror of hook.ts isDocPathEligible — the deterministic pre-filter (non-.md,
- *  dot-dirs, build trees, harness-owned CLAUDE.md/MEMORY.md). Duplicated because
- *  the CLI command files are self-contained (zero cross-file coupling). */
-function isDocPathEligible(relPath) {
-    const p = relPath.replace(/\\/g, '/');
-    if (!p.toLowerCase().endsWith('.md'))
-        return false;
-    const segments = p.split('/');
-    const base = segments[segments.length - 1];
-    if (base === 'CLAUDE.md' || base === 'MEMORY.md')
-        return false;
-    for (const seg of segments.slice(0, -1)) {
-        if (seg.startsWith('.'))
-            return false;
-        if (seg === 'node_modules' || seg === 'dist' || seg === 'build' || seg === 'vendor')
-            return false;
-    }
-    return true;
-}
 const SNIPPET_CHARS = 2_000;
 const EVENTS_PER_POST = 8;
 /** Judging runs server-side in waitUntil (async, after the POST returns), so a
@@ -109,13 +92,16 @@ async function runDocPtr(args) {
     const missingOnly = args.includes('--missing-only');
     const cwd = process.cwd();
     const anchor = (0, project_anchor_1.readAnchor)(cwd);
+    // Paths are relative to the checkout root, so a backfill run from a subfolder
+    // registers the same paths the hook and the doc mirror use.
+    const root = (0, doc_mirror_client_1.docPathRoot)(cwd);
     // Enumerate tracked, eligible docs.
     let tracked;
     try {
         const out = (0, proc_1.safeExecFileSync)('git', ['ls-files', '--', '*.md'], {
-            cwd, encoding: 'utf-8',
+            cwd: root, encoding: 'utf-8',
         });
-        tracked = out.split('\n').map(s => s.trim()).filter(s => s && isDocPathEligible(s));
+        tracked = out.split('\n').map(s => s.trim()).filter(s => s && (0, doc_mirror_client_1.isDocMirrorEligible)(s));
     }
     catch {
         console.error('Not a git repo (or git unavailable) — backfill needs `git ls-files`.');
@@ -158,7 +144,7 @@ async function runDocPtr(args) {
     // manifest. Best-effort: an empty set yields empty manifests (docs read fresh).
     let present = new Set();
     try {
-        const all = (0, proc_1.safeExecFileSync)('git', ['ls-files'], { cwd, encoding: 'utf-8' });
+        const all = (0, proc_1.safeExecFileSync)('git', ['ls-files'], { cwd: root, encoding: 'utf-8' });
         present = new Set(all.split('\n').map(s => s.trim().replace(/\\/g, '/')).filter(Boolean));
     }
     catch { /* not a git repo — manifests stay empty */ }
@@ -166,11 +152,11 @@ async function runDocPtr(args) {
     const events = [];
     for (const rel of targets) {
         try {
-            const snippet = fs.readFileSync(rel, 'utf-8').slice(0, SNIPPET_CHARS);
+            const snippet = fs.readFileSync(path.join(root, rel), 'utf-8').slice(0, SNIPPET_CHARS);
             if (!snippet.trim())
                 continue;
             const p = rel.replace(/\\/g, '/');
-            events.push({ path: p, snippet, refs: present.size ? (0, docptr_refs_1.extractDocRefs)(snippet, p, cwd, present) : [] });
+            events.push({ path: p, snippet, refs: present.size ? (0, docptr_refs_1.extractDocRefs)(snippet, p, root, present) : [] });
         }
         catch { /* skip */ }
     }

package/dist/commands/init.js

@@ -1629,11 +1629,10 @@ function applySettings(settings, apiKey) {
         }
     }
     // PreToolUse (pre-spawn-check) — fires BEFORE every `mcp__ccd_session__spawn_task`
-    // call. Validates the call against three machine-checkable rules from the inline
-    // chip-spawning convention in ~/.claude/CLAUDE.md § Chip Spawning: title prefix
-    // `Chip: `, Block 1 (`git worktree add` in prompt), Block 2 (`greprag send` in
-    // prompt). Returns permissionDecision: "deny" with remediation when any rule
-    // fails; the agent re-composes the call.
+    // call. Validates the call against two machine-checkable rules from
+    // `greprag load chip-spawn`: title prefix `Chip: ` and Block 1 (`git branch -m`
+    // and `git worktree add` in prompt). Returns permissionDecision: "deny" with remediation when
+    // either rule fails; the agent re-composes the call.
     const preSpawnCheckHook = {
         matcher: 'mcp__ccd_session__spawn_task',
         hooks: [{ type: 'command', command: 'greprag-hook pre-spawn-check', timeout: 3000 }],

package/dist/commands/load-primer-reminder.js

@@ -29,10 +29,10 @@ exports.LOAD_PRIMER = [
     '• Pointers (below) name a trigger + the entry to load at that moment. Or browse the catalog yourself any time you suspect a method exists.',
 ].join('\n');
 /** POINTER — the one standing chip pointer. Thin: trigger + load command. The
- *  method (Block 1/Block 2) and the multi-chip upgrade both live in the payload. */
+ *  method (Block 1 + report-back) and the multi-chip upgrade both live in the payload. */
 exports.CHIP_SPAWN_POINTER = [
     '[greprag chips — agent coordination is built in (messaging plumbing in the inbox primer).]',
-    '• About to spawn a chip (`spawn_task`)? → run `greprag load chip-spawn` FIRST for the method (Block 1 worktree + Block 2 report-back); it carries the multi-chip upgrade path inline. Non-negotiable — the spawn validator rejects an unstructured chip.',
+    '• About to spawn a chip (`spawn_task`)? → run `greprag load chip-spawn` FIRST for the method (Block 1 worktree + report-back); it carries the multi-chip upgrade path inline. Non-negotiable — the spawn validator rejects an unstructured chip.',
 ].join('\n');
 /** POINTER — OpenCode's native chip path (the fix-chip era vehicle: `greprag
  *  opencode chip` HTTP spawn, goals, native child sessions). Supersedes the

package/dist/commands/load.js

@@ -51,6 +51,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleOwnsSkill = bundleOwnsSkill;
 exports.runLoad = runLoad;
 exports.normalizeLoadName = normalizeLoadName;
 const fs = __importStar(require("fs"));
@@ -72,7 +73,7 @@ const LIBRARY = {
     },
     'chip-spawn': {
         files: ['skill/templates/chip-spawn.md'],
-        purpose: 'How to spawn one chip correctly (Block 1 worktree + Block 2 report-back). Carries the multi-chip upgrade path inline.',
+        purpose: 'How to spawn one chip correctly (Block 1 worktree + report-back). Carries the multi-chip upgrade path inline.',
     },
     'codex-chip-spawn': {
         files: ['skill/templates/codex-chip-spawn.md'],
@@ -118,6 +119,13 @@ const LIBRARY = {
 function payloadPath(file) {
     return path.join(__dirname, '..', '..', file);
 }
+/** True when the CLI ships `name` as its own skill bundle (`skill/<name>/`) and
+ *  serves it from this library. The bundle is that skill's canon, so its global
+ *  id means the bundle; a mirror row under the same name can only be a copy of
+ *  an installed bundle, frozen when it was captured. adr: adr/skill-adapter-never-canon.md */
+function bundleOwnsSkill(name) {
+    return LIBRARY[name]?.files[0] === `skill/${name}/SKILL.md`;
+}
 // ---------- Tier 3 — the skill mirror (docs/load-system.md) -------------------
 const API_URL_DEFAULT = 'https://api.greprag.com';
 const MIRROR_TIMEOUT_MS = 4_000;
@@ -185,25 +193,28 @@ async function printCatalog() {
     console.log(`  ${'agents'.padEnd(width)}  Deprecated alias for instructions.`);
     // Tier-3 section: the operator's own skills, auto-mirrored from use.
     const data = await mirrorGet('/v1/skillmirror');
-    const skills = data?.skills || [];
+    // A mirror row under a bundled skill's name is a stale copy; the bundled
+    // entry above is that skill.
+    const skills = (data?.skills || [])
+        .filter((s) => !bundleOwnsSkill(s.skillName || ''));
     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.
+        // A hand-kept copy does reach that list, but the harness runs the copy and
+        // never sees canon move on, so it is marked too (with `~`).
         const platform = (0, harness_1.inferCurrentHarness)() || '';
-        const installed = platform
+        const native = 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()))
-            : [];
+            : new Map();
+        const { missing, localCopies } = (0, skill_activation_manifest_1.nativeAdapterGap)(platform, skills, native);
         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)}]` : '';
-            const gap = missing.includes(s.skillName) ? ' *' : '';
+            const gap = missing.includes(s.skillName) ? ' *' : localCopies.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);
@@ -212,6 +223,13 @@ async function printCatalog() {
             console.log('    in this harness\'s own skill list. Install the adapters with:\n');
             console.log(`      ${installCommand}\n`);
         }
+        const cutoverCommand = (0, skill_activation_manifest_1.localCopyCutoverCommand)(platform, localCopies);
+        if (cutoverCommand) {
+            console.log(`\n  ~ ${localCopies.length} skill(s) run from a hand-kept copy in ${platform}, not an adapter — the harness`);
+            console.log('    keeps running that copy when the mirrored skill changes. Replacing a copy is a per-skill');
+            console.log('    call; its SKILL.md is backed up first:\n');
+            console.log(`      ${cutoverCommand}\n`);
+        }
     }
     console.log('\n  greprag load <name>            print the full entry / mirrored skill');
     console.log('  greprag load /<name>           print a user-named slash skill');
@@ -375,8 +393,13 @@ async function printStateDocHints(name, skillBody) {
     const data = await mirrorPost(`/v1/doc/${projectId}/search`, { query, limit: 5 });
     if (!data)
         return;
+    // This block calls what it lists authoritative, so it lists only what the
+    // mirror would accept today. Skill files mirrored before skill trees were
+    // excluded, or by an older CLI, stay until a full `greprag doc update` prunes
+    // them.
+    // adr: adr/doc-mirror-state-only.md
     const docs = (data.docs || [])
-        .filter((d) => typeof d.path === 'string' && d.path.trim().length > 0)
+        .filter((d) => typeof d.path === 'string' && (0, doc_mirror_client_1.isDocMirrorEligible)(d.path))
         .slice(0, 5);
     if (docs.length > 0) {
         process.stdout.write('\n[STATE DOCS — relevant project state from the current repo mirror]\n');
@@ -484,12 +507,22 @@ async function runLoad(args) {
         console.error('No canonical GrepRAG Instructions found. Seed them with `greprag instructions adopt <CLAUDE.md|AGENTS.md>`.');
         process.exit(1);
     }
-    const entry = LIBRARY[name];
+    // An explicit --skill-id names one mirrored skill, so it outranks a bundled
+    // entry that merely shares the name, and a miss is an error rather than a
+    // quiet fallback to the bundled payload. A skill the CLI ships as its own
+    // bundle is the exception: its global id is the bundle, so every harness's
+    // launcher reaches the same canon. adr: adr/skill-adapter-never-canon.md
+    const mirroredArgs = parseMirroredLoadArgs(args.slice(1));
+    const bundleCanon = mirroredArgs.skillId === `global:${name}` && bundleOwnsSkill(name);
+    const entry = mirroredArgs.skillId && !bundleCanon ? undefined : LIBRARY[name];
     if (!entry) {
-        // Not bundled → try the Tier-3 skill mirror before giving up.
-        const mirroredArgs = parseMirroredLoadArgs(args.slice(1));
         if (await printMirroredSkill(name, mirroredArgs))
             return;
+        if (mirroredArgs.skillId) {
+            console.error(`No mirrored skill "${name}" with id ${mirroredArgs.skillId}.`);
+            process.exitCode = 1;
+            return;
+        }
         console.error(`Unknown load entry: ${name}\n`);
         await printCatalog();
         process.exitCode = 1;