greprag 5.82.1 → 5.83.0

package/dist/opencode-plugin.js

@@ -102,6 +102,7 @@ const procedure_1 = require("./procedure");
 const procedure_runtime_1 = require("./procedure-runtime");
 const opencode_plugin_png_1 = require("./opencode-plugin-png");
 const skill_activation_manifest_1 = require("./skill-activation-manifest");
+const native_adapter_refresh_1 = require("./native-adapter-refresh");
 // ============================================================================
 // File-based debug log. opencode's plugin loader (Bun) does NOT route plugin
 // stderr into the opencode log file at ~/.local/share/opencode/log/*.log —
@@ -587,6 +588,11 @@ async function fetchSkillActivation(apiKey, cwd) {
         const data = await response.json();
         const rows = data.skills || [];
         cachedSkillRows = { projectId: anchor.projectId, rows, fetchedAt: now };
+        // Installed adapters follow canon, checked against this same roster.
+        // adr: adr/skill-bundle-shape.md
+        await (0, native_adapter_refresh_1.refreshNativeAdapters)({
+            platform: 'opencode', rows, apiUrl: API_URL, apiKey, homeDir: os.homedir(), projectDir: cwd,
+        }).catch(() => undefined);
         return (0, skill_activation_manifest_1.activationFromApiRows)({
             rows,
             platform: 'opencode',

package/dist/skill-activation-manifest.js

@@ -42,11 +42,15 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 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"));
+const skill_landing_1 = require("./skill-landing");
+const skill_mirror_files_1 = require("./skill-mirror-files");
 const MAX_NATIVE_SKILL_FILES = 1_500;
 const MAX_SCAN_DEPTH = 7;
 function homeRoots(homeDir, platform) {
@@ -89,11 +93,42 @@ function frontmatterName(content) {
     const name = fm && /(?:^|\r?\n)name:\s*["']?([^\r\n"']+)/.exec(fm[1]);
     return name?.[1]?.trim() || '';
 }
-/** Bounded native-skill census. A directory basename is always accepted; a
- *  frontmatter name is added when present. Missing/unreadable roots are silent. */
+/** Bounded native-skill census: every name the harness lists, and whether the
+ *  package under it is a generated adapter. A directory basename is always
+ *  accepted; a frontmatter name is added when present. A folder holding a
+ *  SKILL.md is one package: folders below it are its own files (docs, a
+ *  published copy), never skills the harness lists. A linked folder is read
+ *  through its link and recorded 'external', never descended; so is a package
+ *  another installer owns (isSkillFolderOwnedElsewhere). Roots are read in
+ *  the harness's precedence order (Claude Code runs a personal skill over a
+ *  project one of the same name), and the first root that lists a name decides
+ *  its kind. Within one root a name stays 'local' once any local package claims
+ *  it, and 'external' outranks 'adapter'. Missing/unreadable roots are silent. */
 function readNativeSkillNames(params) {
-    const names = new Set();
+    const names = new Map();
+    let rootNames = new Map();
+    const rank = { adapter: 0, external: 1, local: 2 };
+    const note = (name, kind) => {
+        const held = rootNames.get(name);
+        if (!held || rank[kind] > rank[held])
+            rootNames.set(name, kind);
+    };
     let visited = 0;
+    const readPackage = (dir, fileName, linked) => {
+        visited++;
+        let content = '';
+        try {
+            content = fs.readFileSync(path.join(dir, fileName), 'utf8');
+        }
+        catch { /* directory name still gives a useful identity */ }
+        const kind = linked || (0, skill_mirror_files_1.isSkillFolderOwnedElsewhere)(dir)
+            ? 'external'
+            : (0, skill_mirror_files_1.isGeneratedSkillAdapter)(content) ? 'adapter' : 'local';
+        note(path.basename(dir).toLowerCase(), kind);
+        const declared = frontmatterName(content);
+        if (declared)
+            note(declared.toLowerCase(), kind);
+    };
     const walk = (dir, depth) => {
         if (depth > MAX_SCAN_DEPTH || visited >= MAX_NATIVE_SKILL_FILES)
             return;
@@ -104,41 +139,74 @@ function readNativeSkillNames(params) {
         catch {
             return;
         }
+        const skillMd = depth > 0
+            ? entries.find(entry => entry.isFile() && entry.name.toLowerCase() === 'skill.md')
+            : undefined;
+        if (skillMd) {
+            readPackage(dir, skillMd.name, false);
+            return;
+        }
         for (const entry of entries) {
             if (visited >= MAX_NATIVE_SKILL_FILES)
                 return;
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(full, depth + 1);
-                continue;
+            const child = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(child, depth + 1);
+            else if ((0, skill_mirror_files_1.isLinkedSkillFolder)(child) && fs.existsSync(path.join(child, 'SKILL.md'))) {
+                readPackage(child, 'SKILL.md', true);
             }
-            if (!entry.isFile() || entry.name.toLowerCase() !== 'skill.md')
-                continue;
-            visited++;
-            names.add(path.basename(path.dirname(full)).toLowerCase());
-            try {
-                const declared = frontmatterName(fs.readFileSync(full, 'utf8'));
-                if (declared)
-                    names.add(declared.toLowerCase());
-            }
-            catch { /* directory name still gives a useful identity */ }
         }
     };
     const roots = [
         ...homeRoots(params.homeDir, params.platform),
         ...repoRoots(params.cwd, params.platform),
     ];
-    for (const root of roots)
+    for (const root of roots) {
+        rootNames = new Map();
         walk(root, 0);
+        for (const [name, kind] of rootNames)
+            if (!names.has(name))
+                names.set(name, kind);
+    }
     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 */
+function nativeAdapterGap(platform, mirrored, native) {
+    const missing = [];
+    const localCopies = [];
+    if (!platform)
+        return { missing, localCopies };
+    for (const { skillName, scope } of mirrored) {
+        if (!skillName || skill_landing_1.BUNDLED_SKILLS.includes(skillName))
+            continue;
+        const kind = native.get(skillName.toLowerCase());
+        if (!kind)
+            missing.push(skillName);
+        else if (kind === 'local' && platform === 'claude-code' && scope !== 'project')
+            localCopies.push(skillName);
+    }
+    return { missing, localCopies };
+}
 /** Remove native-advertised duplicates while retaining the canonical count. */
-function buildMirroredSkillActivation(entries, nativeNames) {
+function buildMirroredSkillActivation(entries, native, platform) {
     const valid = entries.filter(entry => entry.skillName && entry.triggerDescription);
     if (valid.length === 0)
         return undefined;
-    const skills = valid.filter(entry => !nativeNames.has(entry.skillName.toLowerCase()));
-    return { count: valid.length, skills, nativeCount: valid.length - skills.length };
+    const skills = valid.filter(entry => !native.has(entry.skillName.toLowerCase()));
+    return {
+        count: valid.length,
+        skills,
+        nativeCount: valid.length - skills.length,
+        ...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
@@ -155,6 +223,13 @@ function nativeAdapterInstallCommand(platform, missingNames) {
     }
     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;
+}
 /** Convert the mirror API response into a harness-specific activation signal. */
 function activationFromApiRows(params) {
     const entries = params.rows
@@ -164,6 +239,7 @@ function activationFromApiRows(params) {
         skillName: row.skillName,
         description: typeof row.description === 'string' ? row.description : '',
         triggerDescription: row.triggerDescription,
+        scope: typeof row.scope === 'string' ? row.scope : undefined,
     }));
-    return buildMirroredSkillActivation(entries, readNativeSkillNames(params));
+    return buildMirroredSkillActivation(entries, readNativeSkillNames(params), params.platform);
 }

package/dist/skill-landing.js

@@ -170,6 +170,12 @@ function landBriefcase(gain, cwd, homeDir, projectName) {
         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 {

package/dist/skill-mirror-files.js

@@ -35,8 +35,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeSkillFileHash = computeSkillFileHash;
 exports.isGeneratedSkillAdapter = isGeneratedSkillAdapter;
+exports.isLinkedSkillFolder = isLinkedSkillFolder;
+exports.isSkillFolderOwnedElsewhere = isSkillFolderOwnedElsewhere;
 exports.isSafeMirroredSkillFile = isSafeMirroredSkillFile;
 const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
 function computeSkillFileHash(files) {
     const hash = crypto.createHash('sha256');
     for (const file of [...files].sort((a, b) => a.path.localeCompare(b.path))) {
@@ -61,6 +65,61 @@ function isGeneratedSkillAdapter(skillMdBody) {
     const body = skillMdBody.replace(/^?---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
     return body.slice(0, 400).includes(GENERATED_ADAPTER_MARKER);
 }
+/** Harness folders whose `skills` folder holds installed copies. */
+const INSTALLED_SKILL_HARNESS_DIRS = ['.claude', '.agents', '.codex', '.opencode', 'opencode'];
+/** True when a skill folder is a link (symlink or Windows junction), live or
+ *  broken. A linked folder belongs to whatever it points at, often a tracked
+ *  repo file or another installer's store.
+ *
+ *  adr: adr/skill-bundle-shape.md */
+function isLinkedSkillFolder(dir) {
+    try {
+        return fs.lstatSync(dir).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+/** True when another owner holds a skill folder: it is a link, its SKILL.md
+ *  names the repository that publishes it, or `npx skills` installed it. A
+ *  published package (OpenWriter's `openwriter setup`, GrepRAG's own bundle)
+ *  is copied in by its product's installer from a release, and that installer
+ *  rewrites it on upgrade. `npx skills` records every package it installs in
+ *  `~/.agents/.skill-lock.json` and copies it into `~/.agents/skills` and
+ *  `~/.claude/skills`. Both rules read only installed copies, in a harness's
+ *  `skills` folder: a product's own source tree (GrepRAG's
+ *  `packages/cli/skill/<name>`) names its repository too and is its author's
+ *  to edit. The census reads such a folder as external, and no GrepRAG writer
+ *  writes, replaces or prunes it. A generated adapter is always GrepRAG's own.
+ *
+ *  adr: adr/skill-bundle-shape.md */
+function isSkillFolderOwnedElsewhere(dir) {
+    if (isLinkedSkillFolder(dir))
+        return true;
+    const root = path.dirname(path.resolve(dir));
+    const harnessDir = path.basename(path.dirname(root));
+    if (path.basename(root) !== 'skills' || !INSTALLED_SKILL_HARNESS_DIRS.includes(harnessDir))
+        return false;
+    let skillMd = '';
+    try {
+        skillMd = fs.readFileSync(path.join(dir, 'SKILL.md'), 'utf8');
+    }
+    catch { /* no package yet */ }
+    if (isGeneratedSkillAdapter(skillMd))
+        return false;
+    const frontmatter = /^?---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd)?.[1] || '';
+    if (/^\s*repository:\s*\S/m.test(frontmatter))
+        return true;
+    if (harnessDir !== '.claude' && harnessDir !== '.agents')
+        return false;
+    try {
+        const lock = JSON.parse(fs.readFileSync(path.join(path.dirname(path.dirname(root)), '.agents', '.skill-lock.json'), 'utf8'));
+        return Boolean(lock?.skills && Object.prototype.hasOwnProperty.call(lock.skills, path.basename(dir)));
+    }
+    catch {
+        return false;
+    }
+}
 function isSafeMirroredSkillFile(file) {
     if (file.path === 'SKILL.md')
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greprag",
-  "version": "5.82.1",
+  "version": "5.83.0",
   "description": "Private GrepRAG client for existing Claude Code, Codex, OpenCode, and Grok Build tenants.",
   "main": "dist/index.js",
   "bin": {

package/scripts/postinstall.js

@@ -7,7 +7,10 @@
 //     immediately after installing the npm package.
 //   * Other bundled skills — refresh-only. If the operator opted in earlier,
 //     keep them current; otherwise leave their skill registry alone.
-//   * Claude chip-spawn doc — refresh-only, because it is Claude-specific.
+//
+// The installed Claude chip-spawn doc (~/.claude/docs/chip-spawn.md) is retired:
+// `greprag load chip-spawn` serves that doctrine from the package and cannot
+// drift. Refreshing a leftover copy here kept a retired surface alive.
 //
 // OpenCode has no slash-skill directory in this package; `greprag init
 // --opencode` installs the plugin.
@@ -24,15 +27,11 @@ const platformTargets = [
     name: 'Claude Code',
     agentDir: path.join(home, '.claude'),
     skillsTarget: path.join(home, '.claude', 'skills'),
-    docsTarget: path.join(home, '.claude', 'docs'),
-    refreshClaudeDocs: true,
   },
   {
     name: 'Codex',
     agentDir: path.join(home, '.codex'),
     skillsTarget: path.join(home, '.codex', 'skills'),
-    docsTarget: path.join(home, '.codex', 'docs'),
-    refreshClaudeDocs: false,
   },
 ];
 
@@ -76,20 +75,6 @@ try {
   console.error('  greprag postinstall: skill sync skipped (' + err.message + ')');
 }
 
-const chipSpawnSrc = path.join(skillRoot, 'templates', 'chip-spawn.md');
-try {
-  for (const target of platformTargets) {
-    if (!target.refreshClaudeDocs) continue;
-    const chipSpawnDest = path.join(target.docsTarget, 'chip-spawn.md');
-    if (fs.existsSync(chipSpawnSrc) && fs.existsSync(chipSpawnDest)) {
-      fs.copyFileSync(chipSpawnSrc, chipSpawnDest);
-      refreshed.push(`${target.name} docs/chip-spawn.md`);
-    }
-  }
-} catch (err) {
-  console.error('  greprag postinstall: chip-spawn refresh skipped (' + err.message + ')');
-}
-
 // The Codex startup watcher was retired in v5.x, but upgrades left its login
 // files in place. On Windows the leftover script loops every 5s, reruns the
 // retired command, and appends its error to codex-watch.log forever (600 MB

package/skill/greprag/docs/corpus.md

@@ -96,10 +96,10 @@ Omit `storeIds` (or use `--all`) to search every store under the calling tenant.
 ## Walk
 
 ```bash
-greprag corpus walk "<store>" <nodeId> [--before 2 --after 2]
+greprag corpus walk "<store>" <nodeId> [--before 2 --after 2] [--max-chars N]
 ```
 
-Surrounding-context fetch. ~50ms, no LLM.
+Surrounding-context fetch. ~50ms, no LLM. `walk` and `section` print each node's full text (search snippets stay short); `--max-chars N` is the opt-in cut.
 
 ## List / delete / status
 

package/skill/greprag/docs/setup.md

@@ -145,7 +145,7 @@ Append missing entries to the existing arrays in `~/.claude/settings.json` (crea
   ```json
   { "matcher": "mcp__ccd_session__spawn_task", "hooks": [{ "type": "command", "command": "greprag-hook pre-spawn-check", "timeout": 3000 }] }
   ```
-  Fires before every `spawn_task` chip dispatch. Validates against `~/.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 on failure; the agent re-composes.
+  Fires before every `spawn_task` chip dispatch. Validates against `greprag load chip-spawn`: title prefix `Chip: ` and the current Block 1 (its `git branch -m` step that keeps the app-provided worktree and its `git worktree add` local-start step). Returns `permissionDecision: "deny"` with remediation on failure; the agent re-composes.
 
 The legacy `user_prompt_submit_notify` hook was removed in v5.6.1 — live inbox delivery is now the Monitor watcher's job. Do not install it.
 

package/skill/mechanic/SKILL.md

@@ -19,8 +19,7 @@ license: MIT
 
 # Mechanic
 
-> **Memory-first friction reflex (refined 2026-07-28, grepragOS laws 3–4 —
-> supersedes the routing/queueing reflex below wherever they conflict).** Search
+> **Memory-first friction reflex (grepragOS laws 3–4).** Search
 > Memory for the exact error/friction plus repo/tool first. Apply a clear
 > remembered overcome and continue. Only when Memory has no answer, the overcome
 > fails, or the same friction repeats does
@@ -30,12 +29,9 @@ license: MIT
 > fix → explain the friction and fix in human terms → commit useful work → hand it to
 > the mission owner. A full-goal chip with no live parent follows
 > `.greprag/delivery.json` as mission owner; no second lifecycle approval is
-> introduced. `greprag mechanic friction` (routing to
-> a live Mechanic) and `greprag fix log` (queueing) are RETIRED as reflexes —
-> `fix log` survives for audit/design-input notes; this skill's queue-digestion
-> method still applies to the EXISTING backlog and to audit notes. A chip titled
-> `FIX: <friction>` follows this contract; legacy `MECHANIC: <Mission>` chips
-> read the same way.
+> introduced. `greprag fix log` is for audit/design-input notes only; this
+> skill's queue-digestion method applies to the existing backlog and to audit
+> notes. A chip titled `FIX: <friction>` follows this contract.
 
 **FIX type router.** Type means durable repair surface, not symptom:
 `harness` = hooks/watchers/task dispatch/harness behavior; `doctrine` =
@@ -69,7 +65,7 @@ The seam: **author freely (shadow), arm deliberately (operator).** Full doctrine
 - **Phase 0 — Fix digestion.** Census the queue tenant-wide FIRST (queues silo per project), then drain the chosen one: per fix, repair the broken mechanism (hooks first, code second) and/or record the durable gotcha, then retire. Deliberate + auto signals outrank mined ones, so this runs first.
 - **Phase A — Drift check.** Audit standing fixes for rot: stale paths, dead conventions (derived live), misfiled static knowledge, age.
 - **Phase B — Episodic mining.** Mine episodic prose summaries for friction worth a fix.
-- **Phase C — Global promotion.** Promote project-agnostic repairs to `~/.claude/docs/chip-spawn.md`.
+- **Phase C — Global promotion.** Promote project-agnostic repairs into the chip-spawn template (`packages/cli/skill/templates/chip-spawn.md`), the one copy `greprag load chip-spawn` serves.
 
 ## The "worth repairing?" gate (core discipline)
 
@@ -86,7 +82,7 @@ Same gate the hourly compactor applies at write-time — Mechanic and compactor
 - **Tier-2 actions need explicit confirm** (arm/graduate, deny/transform, secrets·money·external communication, deleting claimed user work). Ordinary profile-declared repo delivery does not. Tier 0/1 just do + report.
 - **Removal-first repair.** Remove the offending text, gate, control, duplicated doctrine, or wrong boundary before adding new guidance. Add prose or controls only when no removal action can solve the friction; never wrap bad doctrine in explanatory caveats when deleting the bad boundary fixes it.
 - **Bulk is fine for Tier-0 when the set is named aloud** (clearing verified-stale / noise fixes); never bulk a Tier-2 action.
-- **Never edit `~/.claude/docs/chip-spawn.md` without confirm.** Global rules are sticky.
+- **Never promote into the chip-spawn template without confirm.** Global rules are sticky.
 - **Cross-project carve-out.** Default to the current project (resolved via `greprag fix list`). The Phase 0 census MAY read sibling queues to show where fixes piled up; *draining* one requires the operator to name it, and every `add`/`delete` against it MUST carry `--project <that-project>`. Never touch a sibling silently.
 - **Harness scope is mandatory.** Friction carries its source harness (`claude-code`, `codex`, `opencode`). Repairs to hooks/skills/watchers must target that harness with `greprag mechanic install ... --harness <name>`. In a Codex session, default to `--harness codex`; use `--harness all` only for deliberately portable mechanisms.
 - **Delivery is committed-state convergence.** Before merging, pushing, deploying, publishing, tagging, or cutting a release, send one fire-and-forget notice to same-repo peers and continue immediately. Recipients reply only for a concrete conflict; silence is approval. Never poll, wait, inspect peer status, or follow up. Sweep every ready same-repo commit and ignore all uncommitted and untracked work. Resolve Git conflicts directly; no deploy lease or peer ownership ceremony exists.
@@ -157,7 +153,7 @@ mechanism and/or **record** the durable gotcha — and runs FIRST.
 
    - **Is there a broken MECHANISM?** Repair it on the lowest rung that holds:
      1. **Hooks first.** A PreToolUse guard, a UserPromptSubmit injection, a notification — same machinery as fix-triggers, ships as DATA, no deploy. Most mechanism fixes repair here.
-     2. **Code second.** Only when a hook can't express it: server logic, a bounce, a schema/CLI change. Don't implement code-tier inline — spawn a chip (`spawn_task`, `~/.claude/docs/chip-spawn.md`) or hand to the operator.
+     2. **Code second.** Only when a hook can't express it: server logic, a bounce, a schema/CLI change. Don't implement code-tier inline — spawn a chip (`spawn_task`, method from `greprag load chip-spawn`) or hand to the operator.
      3. **Lock it (regression rung).** A code/mechanism repair MUST also mint a regression test from the REAL failure signal (the smell's evidence / a repro from the trace), so the *behavior* is locked, not just the lore. The queue's product is **fix + lore + locked test** — an ADR locks the *why* in prose; this locks the *what* in an executable. Don't retire the fix until the test exists (fails without the repair, passes with it).
 
      Recurring failure class → route through `/root-cause`: repair the pattern, never guard today's trigger.
@@ -217,38 +213,29 @@ mechanism and/or **record** the durable gotcha — and runs FIRST.
 
 Episodic memory is prose-only (the claim layer was dropped, 2026-06-08) — mine the daily/hourly **prose summaries** for friction worth recording. ~90% of raw learnings fail the gate; that's expected.
 
-1. `greprag project-id` → `projectId`.
-2. Pull the last 30 days of daily summaries:
-   ```bash
-   FROM=$(date -u -d '30 days ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-30d +%Y-%m-%dT%H:%M:%SZ)
-   TO=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-   curl -sf "https://api.greprag.com/v1/memory/by-period?projectId=<projectId>&type=daily&from=$FROM&to=$TO&limit=30" \
-     -H "Authorization: Bearer $GREPRAG_API_KEY"
-   ```
-   Parse `rows[]` (`created_at`, `body`).
-3. Scan the prose for durable-property sentences. Markers: `learned that`, `the gotcha is`, `won't work because`, `turns out`, `requires`, `only … if`, `caps at`, `blocks`. Skip < 30 or > 300 chars.
-4. **Gate every candidate.** Surface only passers, one at a time:
+1. Pull the last 30 daily summaries: `greprag memory daily --last 30 --format json` (add `--project <name>` for a sibling). Parse `rows[]` (`content`).
+2. Read each summary and pull sentences that state a durable property (a cause, a limit, a gotcha).
+3. **Gate every candidate.** Surface only passers, one at a time:
    ```
    Candidate (durable · reusable · non-obvious):
      "<sentence>"
    Record as a fix? (rec)ord / (e)dit / (s)kip
    ```
    record → ask scope (`general`; `env` for creds/vars; `<subsystem>-touch`) → `greprag fix log "<sentence>" --repaired --scope <scope>`. edit → polish to a clean rule first.
-5. Summary: `Phase B: scanned N summaries, M passed the gate. Recorded A. Skipped S.`
+4. Summary: `Phase B: scanned N summaries, M passed the gate. Recorded A. Skipped S.`
 
 ## Phase C — Global promotion
 
 1. Re-pull `greprag fix list --repaired --format json`.
 2. Classify each: **project-specific** (skip — mentions `packages/`, a table, an internal service) vs **project-agnostic** (universal only — `worktree`, `npm`, `git`, `Claude Code`, `hook`, `~/.claude/`, generic env vars).
-3. Before showing an agnostic candidate, verify `~/.claude/docs/chip-spawn.md` and `packages/cli/skill/templates/chip-spawn.md` are in sync (`diff`); if they differ, STOP Phase C and tell the operator to resolve manually.
-4. Present each:
+3. Present each:
    ```
    [<nodeId>] universal-only:
      "<text>"
    Promote to global chip-spawn rule? (y)es / (n)o / (e)dit
    ```
-   yes → append to BOTH chip-spawn files (under the numbered "Every chip prompt:" list, HARD-RULE styling when apt) → `greprag fix delete <nodeId>` → confirm `Promoted [<nodeId>] → global.`
-5. Summary: `Phase C: evaluated N. Promoted P. Skipped S.`
+   yes → add it to `packages/cli/skill/templates/chip-spawn.md` in the greprag repo (HARD-RULE styling when apt) → `greprag fix delete <nodeId>` → confirm `Promoted [<nodeId>] → global.`
+4. Summary: `Phase C: evaluated N. Promoted P. Skipped S.`
 
 ## Report
 
@@ -278,9 +265,6 @@ Repairs (D3 rows attached to fixes) are managed with `greprag mechanic`, not by
 greprag mechanic set                  legacy role marker for mechanic follow-up rails;
                                       fan out `mechanic_live` to open sessions
 greprag mechanic role                 show whether this project is the live Mechanic
-greprag mechanic friction "obs"       RETIRED as the reflex (2026-07-12): spawn a fix chip
-                                      instead — `greprag fix spawn --type <type> "<unit>"`. The CLI refuses
-                                      new working-session use.
 greprag mechanic reply --to <8hex>    typed follow-up from Mechanic to source session;
   "msg" [--friction-id <id>]          do not use generic send for mechanic workflow
 greprag mechanic status               inventory: live (shadow|active) repairs grouped by status,
@@ -293,15 +277,6 @@ greprag mechanic why <nodeId>         provenance: the friction → fix → repai
 greprag mechanic off / on             PANIC SWITCH — local file, no network; suspends ALL repairs
 ```
 
-**Legacy Mechanic role.** A `--mechanic` inbox watcher can still receive
-legacy `mechanic_friction` / `mechanic_reply` rows in addition to its own session
-lane, but live working sessions no longer route friction there. Laws 3–4 search
-Memory first, then route each unresolved unit through
-`greprag fix spawn --type <type> "<one unit>"`. `greprag mechanic set` only
-fans out a notice that teaches this reflex and preserves the reply rail for old
-mechanic threads. The Mechanic replies with `greprag mechanic reply --to <source-session>
-"..."` only for legacy follow-up coordination.
-
 **Born shadow → graduate.** Every repair is born `shadow`: it matches and logs would-have-fired
 evidence but injects nothing. Graduation is evidence-first — when `status` flags a row `⚑`, review
 its fire history (`why`) and `enable` it. Nothing goes live without the operator; the gates are

package/skill/mechanic/docs/skill-fix-conventions.md

@@ -22,7 +22,7 @@ Each: **signature** (how it shows up in the run) · **location** (where it lives
 ### 1. mis-route
 - **Signature:** the skill fired for a task outside its lane, OR you reached for it by an obvious phrase and it didn't trigger.
 - **Location:** the `description` / `Use when:` trigger list, or the `NOT for:` boundary.
-- **Fix:** add the missing trigger phrase to `Use when:` (verbatim, the phrase you'd actually type), OR add/sharpen a `NOT for:` line naming the lane it wrongly claimed. One phrase per defect — don't pad the list.
+- **Fix:** broaden or add the intent category the description names (a verbatim phrase only when no category can express it; fold near-synonyms into one category), OR add/sharpen a `NOT for:` line naming the lane it wrongly claimed.
 
 ### 2. wrong-altitude
 - **Signature:** the skill did work it should have delegated (implemented inline when it should hand to a chip; drafted when it should route to a leaf), or the reverse.
@@ -53,6 +53,6 @@ Each: **signature** (how it shows up in the run) · **location** (where it lives
 
 - **One friction, one edit.** If a run surfaced two defects, make two separate edits, each shown for its own accept/revert. Never batch.
 - **Apply + show diff.** Make the edit, then show the unified diff and stop for one accept/revert. (This is the operator-chosen gate; the Mechanic "always confirm" rule still holds.)
-- **Bundled skills:** if the target is a greprag bundled skill, author the edit at `packages/cli/skill/<name>/` — never the `~/.claude/skills/<name>/` install artifact (it's overwritten on the next `init`). See greprag `CLAUDE.md`.
+- **Edit the canonical source.** Managed skills: `greprag skill edit <name> --skill-id <id>`; greprag-bundled skills: `packages/cli/skill/<name>/`. Never edit a generated `~/.claude/skills/<name>/SKILL.md` adapter or install artifact.
 - **Line budget:** a fix must not grow SKILL.md without adding a real proactive-fire rule or per-task step. Converting wallpaper → Convention B is net-neutral or smaller; mis-route adds at most one line.
 - **Out of taxonomy → spawn, don't improvise.** Anything not matching the six becomes one `greprag fix spawn --type doctrine "<unit>"` chip. `greprag fix log` is only for deliberate audit/design notes.