greprag 5.83.2 → 5.85.0

package/dist/reminder-injector.js

@@ -195,7 +195,7 @@ async function injectReminders(input, cfg, short, platform = 'claude-code') {
         // Harness scoping comes from each module's own `harnesses:` tag (the whitelist-drift
         // killer), NOT from an ad hoc id filter here. The old hardcoded codex/watcher-arm
         // exclusion made the per-turn surface disagree with the announce surface.
-        const base = (0, app_settings_1.filterEnabledInterrupts)((0, reminder_registry_1.harnessModules)(platform, (0, reminder_registry_1.promptModules)()));
+        const base = (0, app_settings_1.filterEnabledInterrupts)((0, reminder_registry_1.harnessModules)(platform));
         const reg = mechanicKilled() ? base.filter(m => m.id !== 'mechanic-friction') : base;
         const fired = (0, reminder_registry_1.collectReminders)(env, reg);
         if (!fired.length)

package/dist/skill-activation-manifest.js

@@ -45,7 +45,6 @@ exports.readNativeSkillNames = readNativeSkillNames;
 exports.nativeAdapterGap = nativeAdapterGap;
 exports.buildMirroredSkillActivation = buildMirroredSkillActivation;
 exports.nativeAdapterInstallCommand = nativeAdapterInstallCommand;
-exports.localCopyCutoverCommand = localCopyCutoverCommand;
 exports.activationFromApiRows = activationFromApiRows;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -170,30 +169,23 @@ function readNativeSkillNames(params) {
     }
     return names;
 }
-/** Mirrored skills this harness does not run from canon. `missing` have no
- *  native package, so they never reach the harness's own skill list.
- *  `localCopies` are listed from a hand-kept package instead of an adapter, so
- *  the harness keeps running that copy after canon moves on. Only Claude Code
- *  reports them: its targeted cutover is the one writer that replaces a global
- *  package GrepRAG does not own, while the Codex/OpenCode sync leaves such
- *  packages in place. An external package is neither: the harness lists it, and
- *  its owner (a link target or another installer) is not GrepRAG. A bundled skill is never a gap; its canon is the bundle
- *  the installer writes as a real body. adr: adr/skill-bundle-shape.md */
+/** Mirrored skills with no native package on this harness, so they never reach
+ *  its own skill list. Codex and OpenCode close that gap with launchers; Claude
+ *  Code has none to install: it reads skills from their git folders, and a
+ *  mirrored skill with no git folder is archived history `greprag load` still
+ *  serves. A bundled skill is never a gap; its canon is the bundle the
+ *  installer writes as a real body. adr: adr/skill-ownership-git.md */
 function nativeAdapterGap(platform, mirrored, native) {
     const missing = [];
-    const localCopies = [];
-    if (!platform)
-        return { missing, localCopies };
-    for (const { skillName, scope } of mirrored) {
+    if (platform !== 'codex' && platform !== 'opencode')
+        return { missing };
+    for (const { skillName } of mirrored) {
         if (!skillName || skill_landing_1.BUNDLED_SKILLS.includes(skillName))
             continue;
-        const kind = native.get(skillName.toLowerCase());
-        if (!kind)
+        if (!native.get(skillName.toLowerCase()))
             missing.push(skillName);
-        else if (kind === 'local' && platform === 'claude-code' && scope !== 'project')
-            localCopies.push(skillName);
     }
-    return { missing, localCopies };
+    return { missing };
 }
 /** Remove native-advertised duplicates while retaining the canonical count. */
 function buildMirroredSkillActivation(entries, native, platform) {
@@ -208,27 +200,12 @@ function buildMirroredSkillActivation(entries, native, platform) {
         ...nativeAdapterGap(platform, valid, native),
     };
 }
-/** The one command that materializes native adapters for the named mirrored
- *  skills on this harness. claude-code is not swept wholesale (adapters there
- *  are opt-in per name); codex/opencode sync their whole roster. Null when
- *  nothing is missing. */
+/** The one command that installs the Codex/OpenCode launchers for mirrored
+ *  skills. Null when nothing is missing or the harness takes no launchers. */
 function nativeAdapterInstallCommand(platform, missingNames) {
     if (missingNames.length === 0)
         return null;
-    if (platform === 'claude-code') {
-        return `greprag skill mirror sync claude-code --only ${[...missingNames].sort().join(',')}`;
-    }
-    if (platform === 'codex' || platform === 'opencode') {
-        return `greprag skill mirror sync ${platform}`;
-    }
-    return null;
-}
-/** The command that replaces one hand-kept copy with its adapter, backing up
- *  the copy's SKILL.md first. Replacing a live copy is a per-skill call, so the
- *  command names one placeholder rather than the whole list. Null when there
- *  are none. */
-function localCopyCutoverCommand(platform, localCopies) {
-    return localCopies.length > 0 ? nativeAdapterInstallCommand(platform, ['<name>']) : null;
+    return platform === 'codex' || platform === 'opencode' ? `greprag skill mirror sync ${platform}` : null;
 }
 /** Convert the mirror API response into a harness-specific activation signal. */
 function activationFromApiRows(params) {

package/dist/skill-git-ingest.js

@@ -0,0 +1,297 @@
+"use strict";
+/** Git-sourced skill mirror ingestion: the only writer of skill canon.
+ *
+ *  A skill's one true copy is its git folder: dotclaude `skills/<name>/` for
+ *  global skills, `<repo>/.claude/skills/<name>/` for project skills. This
+ *  reads COMMITTED bytes (`HEAD`, never the working tree, so an uncommitted
+ *  edit is served nowhere) and uploads a skill only when its committed content
+ *  differs from the mirror. Each upload records `git <hash>: <subject>` as the
+ *  revision reason.
+ *
+ *  Cheap on every session start: one `git ls-tree` per source lists each skill
+ *  folder's tree hash; only folders whose tree changed since the last run are
+ *  read (one `git cat-file --batch` for all their files) and hashed.
+ *
+ *  adr: adr/skill-ownership-git.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.gitSkillPath = gitSkillPath;
+exports.globalSkillSource = globalSkillSource;
+exports.projectSkillSource = projectSkillSource;
+exports.listCommittedSkills = listCommittedSkills;
+exports.readCommittedSkillFiles = readCommittedSkillFiles;
+exports.ingestCommittedSkills = ingestCommittedSkills;
+exports.fetchMirrorHashes = fetchMirrorHashes;
+exports.gitSkillSources = gitSkillSources;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const proc_1 = require("./proc");
+const project_anchor_1 = require("./project-anchor");
+const skill_landing_1 = require("./skill-landing");
+const skill_mirror_files_1 = require("./skill-mirror-files");
+/** The server's caps (SKILL_MIRROR_* in @greprag/core), restated: the CLI is core-free. */
+const MAX_FILES = 20;
+const MAX_FILE_CHARS = 100_000;
+const SKILL_NAME_RE = /^[A-Za-z0-9._-]{1,64}$/;
+const STATE_FILE = path.join(os.homedir(), '.greprag', 'state', 'skill-git-ingest.json');
+function git(repo, args, input) {
+    const r = (0, proc_1.safeSpawnSync)('git', args, { cwd: repo, encoding: 'utf8', timeout: 15_000, input, maxBuffer: 64 << 20 });
+    return r.status === 0 ? String(r.stdout || '') : null;
+}
+function gitTop(dir) {
+    const out = fs.existsSync(dir) ? git(dir, ['rev-parse', '--show-toplevel']) : null;
+    return out ? path.resolve(out.trim()) : null;
+}
+/** Where Claude Code finds a skill, and so where to edit it. */
+function gitSkillPath(scope, name, projectRoot) {
+    return scope === 'project' && projectRoot
+        ? path.join(projectRoot, '.claude', 'skills', name)
+        : path.join(os.homedir(), '.claude', 'skills', name);
+}
+function globalSkillSource(home = os.homedir()) {
+    const dir = path.join(home, '.claude', 'skills');
+    const repo = gitTop(dir);
+    if (!repo)
+        return null;
+    const prefix = path.relative(repo, dir).split(path.sep).join('/');
+    return { scope: 'global', repo, prefix };
+}
+/** The current repo's `.claude/skills`, unless the repo is the dotclaude repo
+ *  itself (its skills are global) or the folder is absent. */
+function projectSkillSource(cwd, home = os.homedir()) {
+    const repo = gitTop(cwd);
+    if (!repo)
+        return null;
+    const dotclaude = gitTop(path.join(home, '.claude'));
+    if (dotclaude && path.resolve(dotclaude) === repo)
+        return null;
+    if (!fs.existsSync(path.join(repo, '.claude', 'skills')))
+        return null;
+    const anchor = (0, project_anchor_1.readAnchor)(repo);
+    if (!anchor.initialized)
+        return null;
+    return { scope: 'project', repo, prefix: '.claude/skills', projectId: anchor.projectId, projectName: anchor.projectName };
+}
+/** Skill folders committed at HEAD under the source prefix, with tree hashes.
+ *  A folder that is a link in the working tree belongs to the repo it points
+ *  at and is ingested from there. */
+function listCommittedSkills(source) {
+    const out = git(source.repo, ['ls-tree', 'HEAD', `${source.prefix}/`]);
+    if (!out)
+        return [];
+    const skills = [];
+    for (const line of out.split('\n')) {
+        const m = line.match(/^\d+ tree ([0-9a-f]+)\t(.+)$/);
+        if (!m)
+            continue;
+        const folder = m[2];
+        const name = folder.split('/').pop() || '';
+        if (!SKILL_NAME_RE.test(name))
+            continue;
+        // A bundled skill's source is packages/cli/skill/<name>/ and the bundle serves it.
+        if (source.scope === 'global' && skill_landing_1.BUNDLED_SKILLS.includes(name))
+            continue;
+        if ((0, skill_mirror_files_1.isLinkedSkillFolder)(path.join(source.repo, ...folder.split('/'))))
+            continue;
+        skills.push({ name, folder, tree: m[1] });
+    }
+    return skills;
+}
+/** Read the committed mirror file set of each skill: SKILL.md plus
+ *  `docs/**\/*.md`, the mirror's file contract. One `git cat-file --batch`. */
+function readCommittedSkillFiles(repo, skills) {
+    const wanted = [];
+    if (!skills.length)
+        return new Map();
+    // One listing for every folder: a spawn per skill costs seconds on Windows.
+    const byFolder = new Map();
+    const listing = git(repo, ['ls-tree', '-r', '--name-only', 'HEAD', '--', ...new Set(skills.map(s => `${s.folder}/`))]) || '';
+    for (const p of listing.split('\n').filter(Boolean)) {
+        const skill = skills.find(s => p.startsWith(`${s.folder}/`));
+        if (skill)
+            byFolder.set(skill.folder, [...(byFolder.get(skill.folder) || []), p]);
+    }
+    for (const skill of skills) {
+        const rels = (byFolder.get(skill.folder) || []).map(p => p.slice(skill.folder.length + 1))
+            .filter(rel => rel === 'SKILL.md' || (rel.startsWith('docs/') && rel.toLowerCase().endsWith('.md')))
+            .sort((a, b) => (a === 'SKILL.md' ? -1 : b === 'SKILL.md' ? 1 : a.localeCompare(b)))
+            .slice(0, MAX_FILES);
+        if (!rels.includes('SKILL.md'))
+            continue;
+        for (const rel of rels)
+            wanted.push({ skill: skill.name, rel, spec: `HEAD:${skill.folder}/${rel}` });
+    }
+    const result = new Map();
+    if (!wanted.length)
+        return result;
+    const r = (0, proc_1.safeSpawnSync)('git', ['cat-file', '--batch'], {
+        cwd: repo, input: wanted.map(w => w.spec).join('\n') + '\n', timeout: 30_000, maxBuffer: 256 << 20,
+    });
+    if (r.status !== 0 || !r.stdout)
+        return result;
+    const buf = r.stdout;
+    let at = 0;
+    for (const w of wanted) {
+        const nl = buf.indexOf(0x0a, at);
+        const header = buf.subarray(at, nl).toString('utf8');
+        at = nl + 1;
+        const m = header.match(/^[0-9a-f]+ blob (\d+)$/);
+        if (!m)
+            continue;
+        const size = Number(m[1]);
+        const content = buf.subarray(at, at + size).toString('utf8');
+        at += size + 1;
+        if (content.length > MAX_FILE_CHARS)
+            continue;
+        const files = result.get(w.skill) || [];
+        files.push({ path: w.rel, content });
+        result.set(w.skill, files);
+    }
+    // A committed launcher is never content (adr/skill-adapter-never-canon.md).
+    for (const [name, files] of result) {
+        const main = files.find(f => f.path === 'SKILL.md');
+        if (!main || (0, skill_mirror_files_1.isGeneratedSkillAdapter)(main.content))
+            result.delete(name);
+    }
+    return result;
+}
+function lastCommit(repo, folder) {
+    const out = (git(repo, ['log', '-1', '--format=%h%x00%s', 'HEAD', '--', folder]) || '').trim();
+    const [hash = 'unknown', subject = ''] = out.split('\0');
+    return { hash, subject };
+}
+function readState() {
+    try {
+        return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writeState(state) {
+    try {
+        fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
+        fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 1));
+    }
+    catch { /* best effort: the next run re-reads every folder */ }
+}
+function stateKey(source, name) {
+    return `${source.scope}:${source.projectId || ''}:${name}`;
+}
+/** Upload every committed skill whose content differs from the mirror.
+ *  `mirrorHashes` maps `<scope>:<name>` to the mirror's contentHash. `force`
+ *  re-reads folders whose tree hash is unchanged since the last run. */
+async function ingestCommittedSkills(params) {
+    const result = { uploaded: [], current: 0, failed: [] };
+    const state = readState();
+    for (const source of params.sources) {
+        const all = listCommittedSkills(source);
+        const changed = params.force ? all : all.filter(s => state[stateKey(source, s.name)] !== s.tree);
+        result.current += all.length - changed.length;
+        const files = readCommittedSkillFiles(source.repo, changed);
+        for (const skill of changed) {
+            const set = files.get(skill.name);
+            if (!set) {
+                state[stateKey(source, skill.name)] = skill.tree;
+                continue;
+            }
+            const contentHash = (0, skill_mirror_files_1.computeSkillFileHash)(set);
+            if (params.mirrorHashes.get(`${source.scope}:${skill.name}`) === contentHash) {
+                state[stateKey(source, skill.name)] = skill.tree;
+                result.current++;
+                continue;
+            }
+            const commit = lastCommit(source.repo, skill.folder);
+            try {
+                const res = await fetch(`${params.apiUrl}/v1/skillmirror/${encodeURIComponent(skill.name)}`, {
+                    method: 'POST',
+                    headers: { 'Authorization': `Bearer ${params.apiKey}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        files: set,
+                        contentHash,
+                        scope: source.scope,
+                        ...(source.scope === 'project'
+                            ? { projectId: source.projectId, projectName: source.projectName, replaces: [`global:${skill.name}`] }
+                            : {}),
+                        reason: `git ${commit.hash}: ${commit.subject}`.slice(0, 500),
+                        author: {
+                            via: 'git-ingest',
+                            commit: commit.hash,
+                            ...(params.harness ? { harness: params.harness } : {}),
+                            ...(params.sessionId ? { sessionId: params.sessionId } : {}),
+                        },
+                    }),
+                    signal: AbortSignal.timeout(15_000),
+                });
+                if (!res.ok) {
+                    const body = await res.json().catch(() => ({}));
+                    throw new Error(`HTTP ${res.status} ${body.detail || body.error || ''}`.trim());
+                }
+                state[stateKey(source, skill.name)] = skill.tree;
+                result.uploaded.push(skill.name);
+            }
+            catch (err) {
+                result.failed.push({ name: skill.name, error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+    }
+    writeState(state);
+    return result;
+}
+/** The mirror's content hashes, keyed `<scope>:<name>`, from the list route. */
+async function fetchMirrorHashes(apiUrl, apiKey, projectId) {
+    // Two plain lists, not `effective`: effective refuses a same-name project
+    // skill that predates `replaces`, and ingestion is what fixes that.
+    const queries = ['?scope=global', ...(projectId ? [`?scope=project&projectId=${encodeURIComponent(projectId)}`] : [])];
+    const out = new Map();
+    for (const q of queries) {
+        const res = await fetch(`${apiUrl}/v1/skillmirror${q}`, {
+            headers: { 'Authorization': `Bearer ${apiKey}` },
+            signal: AbortSignal.timeout(10_000),
+        });
+        if (!res.ok)
+            throw new Error(`skill mirror list failed: HTTP ${res.status}`);
+        const body = await res.json();
+        for (const s of body.skills || [])
+            out.set(`${s.scope}:${s.skillName}`, s.contentHash || '');
+    }
+    return out;
+}
+/** Both sources for a working directory: dotclaude's global skills and, in a
+ *  project repo, its `.claude/skills`. */
+function gitSkillSources(cwd) {
+    return [globalSkillSource(), projectSkillSource(cwd)].filter((s) => !!s);
+}

package/dist/skill-landing.js

@@ -1,35 +1,11 @@
 "use strict";
-/** Skill-gain landing — the Skill Learning Loop's write-back half
- *  (docs/skill-learning-loop.md §fuse shape, operator-ratified 2026-07-01).
+/** Skill-gain artifacts on disk: where a skill's folder is, and the undo for
+ *  gains the Skill Learning Loop landed before 2026-10-13.
  *
- *  THE SHAPE (Tony Stark's briefcase suit): the server-side distiller packaged
- *  each gain as a focused doc + a blind one-liner. This leg — pure code, never
- *  agent voluntarism (the skill-tuning autopsy's law) — lands both files:
- *
- *    docs/learned/<slug>.md   the laser-focused learning doc
- *    SKILL.md (EOF)           one FUSE line: the one-liner + the schematic
- *                             telling the NEXT invocation exactly what to do —
- *                             expand the doc, fold it in where it belongs,
- *                             delete the fuse and the doc.
- *
- *  The fuse is self-applying because it loads WITH the skill: the next agent
- *  to invoke the skill reads it as part of the skill's own instructions, does
- *  the short tune with the whole skill in context (the only actor that ever
- *  legitimately has it), and the skill converges clean. If a run skips the
- *  tune, the fuse persists as ordinary progressive disclosure — the learning
- *  stays live either way (graceful degradation, no failure mode).
- *
- *  Guards: CAP 3 undigested fuses per skill (overflow waits server-side —
- *  a skill drowning in briefcases isn't being used anyway); every artifact
- *  stamped `skillgain:<id>`; `greprag skillgain reject <id>` is the undo
- *  (removes fuse + doc). Landing routes through resolveSkillDir — the ONE
- *  seam that swaps to the greprag-load skill store when skills move into the
- *  CLI (the no-SKILL.md endgame).
- *
- *  Write-target routing (the trap): greprag's bundled skills publish from the
- *  repo source (packages/cli/skill/<name>/) — ~/.claude/skills/<name>/ is an
- *  init-overwritten artifact. Bundled + repo present → repo source; otherwise
- *  the global skills dir; neither → the gain stays pending. */
+ *  GrepRAG no longer lands gains into skill folders or into `greprag load`
+ *  payloads: git owns skills and GrepRAG never edits their content
+ *  (adr/skill-ownership-git.md). `greprag skillgain reject <id>` still removes
+ *  a fuse line and learned doc that an earlier version wrote. */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -64,27 +40,18 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGeneratedAdapter = exports.MAX_FUSES_PER_SKILL = exports.LEARNINGS_RELPATH = exports.LEARNED_DIR_RELPATH = exports.BUNDLED_SKILLS = void 0;
+exports.LEARNINGS_RELPATH = exports.LEARNED_DIR_RELPATH = exports.BUNDLED_SKILLS = void 0;
 exports.resolveSkillDir = resolveSkillDir;
 exports.hasGainStamp = hasGainStamp;
-exports.countFuses = countFuses;
-exports.buildFuseLine = buildFuseLine;
-exports.buildLoadFuseBlock = buildLoadFuseBlock;
-exports.landBriefcase = landBriefcase;
 exports.removeLandedGain = removeLandedGain;
-exports.landPendingGains = landPendingGains;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
-const skill_mirror_files_1 = require("./skill-mirror-files");
 /** Skills that ship FROM the greprag repo — their canonical source is
  *  packages/cli/skill/<name>/; the installed copy is overwritten at init. */
 exports.BUNDLED_SKILLS = ['greprag', 'commander', 'content-advisor', 'mechanic'];
 exports.LEARNED_DIR_RELPATH = path.join('docs', 'learned');
 /** v1 legacy zone — reject still scans it for stamps landed before the recut. */
 exports.LEARNINGS_RELPATH = path.join('docs', 'learnings.md');
-/** Max undigested fuse lines a SKILL.md may carry; past this, new gains wait
- *  server-side. Operator-ratified (2026-07-01). */
-exports.MAX_FUSES_PER_SKILL = 3;
 /** Resolve the canonical directory for a skill. `existsFn` injectable for
  *  tests. Order: bundled repo source (when cwd IS the greprag repo) → global
  *  skills dir → null (defer). THE storage seam — the greprag-load skill-store
@@ -105,115 +72,6 @@ function resolveSkillDir(skill, cwd, homeDir, existsFn = fs.existsSync) {
 function hasGainStamp(content, nodeId) {
     return content.includes(`skillgain:${nodeId}`);
 }
-/** Count undigested fuse lines in a SKILL.md body (digested ones were deleted
- *  by the tune, so the count self-heals as briefcases get absorbed). PURE. */
-function countFuses(skillMdContent) {
-    return (skillMdContent.match(/<!-- skillgain:[0-9a-f]{8}/g) || []).length;
-}
-/** The fuse line — the briefcase's button. One line, blind (the one-liner
- *  names the learning; the mass lives in the doc), carrying the exact
- *  schematic for the next invocation. PURE — unit-tested. */
-function buildFuseLine(gain, docRelPath, projectName, dateISO) {
-    // The anchor is the attribution, shown. A gain claims THIS skill by quoting
-    // this skill's own purpose back; printing that quote turns "is this even
-    // mine?" into a one-glance check instead of a trip through the learned doc.
-    // The 2026-09-03 field audit found 7 of 8 fuses on the wrong skill, and
-    // nothing on the line said why any of them belonged there.
-    // adr: adr/skill-gain-attribution.md
-    const claim = gain.anchor
-        ? `Claims this skill via its purpose: "${gain.anchor}". `
-        : '';
-    return (`⚙ SKILL UPDATE PENDING (${gain.gainType}) — ${gain.oneLiner} `
-        + claim
-        + `→ BEFORE working: read ${docRelPath.replace(/\\/g, '/')}, fold the learning into this `
-        + `skill where it belongs (one small edit, keep it lean), then DELETE this line and the doc. `
-        + `Doesn't belong to this skill, or bogus? \`greprag skillgain reject ${gain.nodeId}\` instead. `
-        + `<!-- skillgain:${gain.nodeId} ${dateISO.slice(0, 10)} project:${projectName} -->`);
-}
-/** Render pending gains for a mirror-managed skill into its `greprag load`
- *  payload — the fuse's replacement for skills whose SKILL.md is a generated
- *  adapter nothing local may write to.
- *
- *  Carries strictly more than the fuse line did: the learning doc is inlined
- *  rather than pointed at, because a managed skill has no local docs/learned/
- *  to read. Empty string when there is nothing pending, so the caller can
- *  append unconditionally. PURE — unit-tested. adr: adr/skill-fuse-delivery.md */
-function buildLoadFuseBlock(skill, gains) {
-    const usable = gains.filter(g => g.oneLiner && g.skill === skill);
-    if (usable.length === 0)
-        return '';
-    const head = usable.length === 1
-        ? `⚙ 1 PENDING SKILL UPDATE for ${skill} — fold it in before acting on this skill.`
-        : `⚙ ${usable.length} PENDING SKILL UPDATES for ${skill} — fold them in before acting on this skill.`;
-    const items = usable.map((g, i) => {
-        const claim = g.anchor
-            ? `\n   Claims this skill via its purpose: "${g.anchor}"`
-            : '';
-        const doc = g.docBody ? `\n\n${g.docBody.trim()}\n` : '';
-        return (`${i + 1}. (${g.gainType}) ${g.oneLiner}${claim}${doc}\n`
-            + `   Digest: make the edit, then \`greprag skillgain done ${g.nodeId}\`.\n`
-            + `   Doesn't belong to this skill, or bogus? \`greprag skillgain reject ${g.nodeId}\`.`);
-    });
-    return `\n---\n\n${head}\n\n${items.join('\n\n')}\n`;
-}
-/** A generated mirror adapter is machine-owned: regenerated from the mirror on
- *  any sync, hash-locked against edits in between. One recogniser for the whole
- *  CLI lives in `skill-mirror-files`. */
-var skill_mirror_files_2 = require("./skill-mirror-files");
-Object.defineProperty(exports, "isGeneratedAdapter", { enumerable: true, get: function () { return skill_mirror_files_2.isGeneratedSkillAdapter; } });
-/** Land ONE briefcase: write the learned doc + append the fuse to SKILL.md.
- *  Deterministic file work only — never throws (failure defers the gain). */
-function landBriefcase(gain, cwd, homeDir, projectName) {
-    try {
-        if (!gain.oneLiner || !gain.docSlug || !gain.docBody)
-            return 'deferred'; // payload-less legacy row
-        const dir = resolveSkillDir(gain.skill, cwd, homeDir);
-        if (!dir)
-            return 'deferred';
-        // A linked skill folder belongs to its target (a tracked repo file, another
-        // installer's store), so the fuse is not GrepRAG's to write there. The gain
-        // stays pending; a mirrored skill still gets it from `greprag load`.
-        // adr: adr/skill-fuse-delivery.md
-        if ((0, skill_mirror_files_1.isSkillFolderOwnedElsewhere)(dir))
-            return 'deferred';
-        const skillMd = path.join(dir, 'SKILL.md');
-        let body;
-        try {
-            body = fs.readFileSync(skillMd, 'utf-8');
-        }
-        catch {
-            return 'deferred';
-        }
-        if (hasGainStamp(body, gain.nodeId))
-            return 'already-landed';
-        // A mirror-managed skill's SKILL.md is a GENERATED adapter: the mirror
-        // regenerates it on every sync and hash-locks it in between. Appending a
-        // fuse there makes two writers own one file — the fuse is wiped by the next
-        // sync, or (worse) the divergence guard refuses the sync and the operator
-        // has to untangle it by hand. Happened twice on 2026-09-04.
-        //
-        // For these skills the fuse is served by `greprag load` instead, which is
-        // the payload the adapter tells the agent to read — same arrival moment,
-        // one writer. The gain stays PENDING so the load path keeps surfacing it
-        // until it is digested. adr: adr/skill-fuse-delivery.md
-        if ((0, skill_mirror_files_1.isGeneratedSkillAdapter)(body))
-            return 'served-by-load';
-        if (countFuses(body) >= exports.MAX_FUSES_PER_SKILL)
-            return 'capped';
-        // Doc first (a fuse pointing at a missing doc is the one broken state).
-        const docRel = path.join(exports.LEARNED_DIR_RELPATH, `${gain.docSlug}.md`);
-        const docAbs = path.join(dir, docRel);
-        fs.mkdirSync(path.dirname(docAbs), { recursive: true });
-        fs.writeFileSync(docAbs, gain.docBody.trimEnd()
-            + `\n\n<!-- skillgain:${gain.nodeId} — auto-landed by the Skill Learning Loop; deleted when digested -->\n`);
-        const fuse = buildFuseLine(gain, docRel, projectName, new Date().toISOString());
-        fs.writeFileSync(skillMd, body + (body.endsWith('\n') ? '' : '\n') + fuse + '\n');
-        return 'landed';
-    }
-    catch {
-        return 'deferred';
-    }
-}
 /** Remove a gain's artifacts wherever they landed — the `skillgain reject`
  *  undo: the fuse line (SKILL.md), the learned doc, and any v1-legacy
  *  learnings.md line. Returns true if anything was removed. Never throws. */
@@ -254,27 +112,3 @@ function removeLandedGain(skill, nodeId, cwd, homeDir) {
         return false;
     }
 }
-/** Bound the file work per session start; overflow waits (still pending). */
-const MAX_LANDS_PER_START = 5;
-/** The full landing pass. Every gain with a payload lands as a briefcase
- *  (capped per skill + per start); payload-less/unroutable gains stay pending.
- *  Returns the report (announce) + the status updates to POST back. */
-function landPendingGains(pending, cwd, homeDir, projectName) {
-    const report = { landed: [] };
-    const statusUpdates = [];
-    for (const gain of pending) {
-        if (report.landed.length >= MAX_LANDS_PER_START)
-            break;
-        const outcome = landBriefcase(gain, cwd, homeDir, projectName);
-        if (outcome === 'landed' || outcome === 'already-landed') {
-            statusUpdates.push({ nodeId: gain.nodeId, status: 'landed' });
-            if (outcome === 'landed') {
-                report.landed.push({
-                    nodeId: gain.nodeId, skill: gain.skill, oneLiner: gain.oneLiner || gain.text,
-                });
-            }
-        }
-        // 'capped' / 'deferred' → stays pending, retried next session start
-    }
-    return { report, statusUpdates };
-}