greprag 5.83.2 → 5.85.0

package/dist/skill-mirror-client.js

@@ -1,15 +1,8 @@
 "use strict";
-/** Skill-mirror client — the Tier-3 mirror's upload half
- *  (docs/load-system.md §Tier 3). Runs inside the Stop hook: a skill-load turn
- *  triggers `maybeMirrorSkill`, which content-hashes the skill's markdown and
- *  uploads ONLY on change. Follower semantics — files canonical, the mirror
- *  shadows "last used state." Best-effort end to end: a mirror failure never
- *  touches the turn.
- *
- *  Local freshness state (`~/.greprag/state/skill-mirror.json`) remembers the
- *  last-mirrored hash per skill so an unchanged skill costs one hash pass and
- *  ZERO network. Markdown only, v1 — SKILL.md + docs/**\/*.md; script-bearing
- *  assets stay file-bound (see the spec's named gaps). */
+/** Skill package reader: the markdown a mirrored skill carries (SKILL.md +
+ *  docs/**\/*.md) and its content hash. Used to verify an export and to send a
+ *  loadout. The mirror itself is written only by git ingestion
+ *  (skill-git-ingest.ts, 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);
@@ -46,16 +39,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectSkillFiles = collectSkillFiles;
 exports.computeMirrorHash = computeMirrorHash;
-exports.dryRunNativeSkillAdoption = dryRunNativeSkillAdoption;
-exports.syncNativeSkillAdoptions = syncNativeSkillAdoptions;
-exports.readMirrorState = readMirrorState;
-exports.writeMirrorState = writeMirrorState;
-exports.maybeMirrorSkill = maybeMirrorSkill;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const skill_landing_1 = require("./skill-landing");
-const native_skill_adoption_1 = require("./native-skill-adoption");
-const native_skill_mirror_1 = require("./native-skill-mirror");
 const skill_mirror_files_1 = require("./skill-mirror-files");
 /** Mirrors the server's caps (SKILL_MIRROR_* in @greprag/core — the CLI is
  *  core-free, so the numbers are restated; the server re-validates anyway). */
@@ -116,235 +101,3 @@ function collectSkillFiles(skillDir) {
 function computeMirrorHash(files) {
     return (0, skill_mirror_files_1.computeSkillFileHash)(files);
 }
-function dryRunNativeSkillAdoption(params) {
-    return (0, native_skill_adoption_1.planNativeSkillAdoption)({ ...params, collectFiles: collectSkillFiles });
-}
-function adoptedSkillId(candidate) {
-    return candidate.scope === 'project'
-        ? `project:${candidate.projectId}:${candidate.skillName}`
-        : `global:${candidate.skillName}`;
-}
-async function responseJson(response) {
-    try {
-        return await response.json();
-    }
-    catch {
-        return {};
-    }
-}
-async function ensureNativeAdoptionOriginalSnapshot(params) {
-    const skillId = adoptedSkillId(params.candidate);
-    const snapshotPath = `/v1/skillmirror/${encodeURIComponent(params.candidate.skillName)}/snapshots/original`;
-    const body = {
-        scope: params.candidate.scope,
-        projectId: params.candidate.projectId,
-        skillId,
-        source: 'disk',
-        sourceRef: path.join(params.candidate.root, params.candidate.skillName),
-        reason: 'captured native skill package before GrepRAG adapter adoption',
-    };
-    const created = await fetch(`${params.apiUrl}${snapshotPath}`, {
-        method: 'POST',
-        headers: { 'Authorization': `Bearer ${params.apiKey}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-    });
-    if (created.ok)
-        return true;
-    if (created.status !== 409)
-        return false;
-    const query = new URLSearchParams({
-        scope: params.candidate.scope,
-        skillId,
-        ...(params.candidate.projectId ? { projectId: params.candidate.projectId } : {}),
-    });
-    const existing = await fetch(`${params.apiUrl}${snapshotPath}?${query.toString()}`, {
-        method: 'GET',
-        headers: { 'Authorization': `Bearer ${params.apiKey}` },
-    });
-    if (!existing.ok)
-        return false;
-    const data = await responseJson(existing);
-    const snapshot = data.snapshot;
-    return snapshot?.contentHash === params.candidate.sourceHash;
-}
-async function syncNativeSkillAdoptions(params) {
-    const plan = dryRunNativeSkillAdoption(params);
-    const result = {
-        plan,
-        adopted: 0,
-        blocked: plan.blocked.length,
-        skipped: plan.skipped.length,
-    };
-    if (params.dryRun)
-        return result;
-    for (const candidate of plan.candidates) {
-        const body = {
-            files: candidate.files,
-            contentHash: candidate.sourceHash,
-            scope: candidate.scope,
-            projectId: candidate.projectId,
-            projectName: candidate.projectName,
-        };
-        const response = await fetch(`${params.apiUrl}/v1/skillmirror/${encodeURIComponent(candidate.skillName)}`, {
-            method: 'POST',
-            headers: { 'Authorization': `Bearer ${params.apiKey}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            result.blocked++;
-            continue;
-        }
-        const snapshotted = await ensureNativeAdoptionOriginalSnapshot({
-            apiUrl: params.apiUrl,
-            apiKey: params.apiKey,
-            candidate,
-        });
-        if (!snapshotted) {
-            result.blocked++;
-            continue;
-        }
-        const installed = (0, native_skill_adoption_1.installAdoptedNativeSkill)({
-            platform: params.platform,
-            root: candidate.root,
-            expectedSourceHash: candidate.sourceHash,
-            collectFiles: collectSkillFiles,
-            skill: {
-                skillName: candidate.skillName,
-                skillId: adoptedSkillId(candidate),
-                scope: candidate.scope,
-                projectId: candidate.projectId,
-                projectName: candidate.projectName,
-                files: candidate.files,
-            },
-        });
-        if (installed === 'installed')
-            result.adopted++;
-        else if (installed === 'blocked')
-            result.blocked++;
-        else
-            result.skipped++;
-    }
-    return result;
-}
-function materializeLocally(skillName, files, cwd) {
-    for (const platform of native_skill_mirror_1.NATIVE_SKILL_ADAPTER_PLATFORMS) {
-        try {
-            (0, native_skill_mirror_1.applyNativeSkillMirror)({
-                platform,
-                skills: [{
-                        skillName,
-                        skillId: `global:${skillName}`,
-                        scope: 'global',
-                        contentHash: computeMirrorHash(files),
-                        files,
-                    }],
-                projectDir: cwd,
-                prune: false,
-            });
-        }
-        catch { /* local adapter failure never breaks turn capture */ }
-    }
-}
-function statePath() {
-    const home = process.env.HOME || process.env.USERPROFILE || '';
-    return path.join(home, '.greprag', 'state', 'skill-mirror.json');
-}
-function readMirrorState() {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(statePath(), 'utf-8'));
-        if (parsed && typeof parsed.skills === 'object' && parsed.skills) {
-            return { skills: parsed.skills };
-        }
-    }
-    catch { /* missing/unreadable → empty */ }
-    return { skills: {} };
-}
-function writeMirrorState(state) {
-    try {
-        const file = statePath();
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        fs.writeFileSync(file, JSON.stringify(state, null, 2) + '\n');
-    }
-    catch { /* best-effort — worst case is one redundant upload next use */ }
-}
-async function fetchRemoteSkillHash(params) {
-    try {
-        const res = await fetch(`${params.apiUrl}/v1/skillmirror/${encodeURIComponent(params.skill)}?scope=global`, {
-            headers: { 'Authorization': `Bearer ${params.apiKey}` },
-        });
-        if (res.status === 404)
-            return null;
-        if (!res.ok)
-            return null;
-        const data = await responseJson(res);
-        return typeof data.contentHash === 'string' ? data.contentHash : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Mirror one skill if its content changed since the last mirror. Never throws. */
-async function maybeMirrorSkill(params) {
-    try {
-        if (!/^[A-Za-z0-9._-]{1,64}$/.test(params.skill))
-            return 'skipped';
-        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-        const dir = (0, skill_landing_1.resolveSkillDir)(params.skill, params.cwd, homeDir);
-        if (!dir)
-            return 'skipped';
-        const files = collectSkillFiles(dir);
-        if (!files)
-            return 'skipped';
-        // The disk copy of an already-mirrored skill is the generated ADAPTER that
-        // `materializeLocally` wrote below — a launcher whose whole body says "run
-        // `greprag load <name>`". Uploading it makes it canon, and `greprag load`
-        // then serves the launcher back to the agent that was told to run it: the
-        // skill's real instructions are gone and nothing errors. That loop closed
-        // here, one turn after every first mirror, and had already eaten the
-        // canonical body of skills including anti-ai, chrome, gmail and root-cause.
-        //
-        // An adapter is never a mirror source. Canon changes through the guarded
-        // edit path (`greprag skill edit` / `skill mirror apply`), never by
-        // shadowing a file greprag itself generated. adr: adr/skill-adapter-never-canon.md
-        const main = files.find(file => file.path === 'SKILL.md');
-        if (main && (0, skill_mirror_files_1.isGeneratedSkillAdapter)(main.content))
-            return 'skipped';
-        const hash = computeMirrorHash(files);
-        const state = readMirrorState();
-        const localLease = state.skills[params.skill]?.hash;
-        if (localLease === hash) {
-            materializeLocally(params.skill, files, params.cwd);
-            return 'fresh';
-        }
-        if (!localLease) {
-            const remoteHash = await fetchRemoteSkillHash(params);
-            if (remoteHash === hash) {
-                state.skills[params.skill] = { hash, mirroredAt: new Date().toISOString() };
-                writeMirrorState(state);
-                materializeLocally(params.skill, files, params.cwd);
-                return 'fresh';
-            }
-            if (remoteHash)
-                return 'skipped';
-        }
-        const res = await fetch(`${params.apiUrl}/v1/skillmirror/${encodeURIComponent(params.skill)}`, {
-            method: 'POST',
-            headers: { 'Authorization': `Bearer ${params.apiKey}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                files,
-                contentHash: hash,
-                scope: 'global',
-                expectedHash: localLease,
-            }),
-        });
-        if (!res.ok)
-            return 'skipped';
-        state.skills[params.skill] = { hash, mirroredAt: new Date().toISOString() };
-        writeMirrorState(state);
-        materializeLocally(params.skill, files, params.cwd);
-        return 'mirrored';
-    }
-    catch {
-        return 'skipped';
-    }
-}

package/dist/skill-staleness.js

@@ -358,7 +358,7 @@ function formatSkillStaleness(report, options = {}) {
         lines.push('1. Pause trusting this skill; read the changed watched source files/diffs first.');
         lines.push('2. Classify relevance: low relevance or small delta -> use repo source as truth; no chip.');
         lines.push('3. If this task depends on the stale area and the delta is material, spawn a skill-refresh chip.');
-        lines.push('4. The refresh chip must run `greprag load skill-change`, edit canonical GrepRAG skill source, and never edit local generated adapters.');
+        lines.push('4. The refresh chip edits the skill\'s git folder (~/.claude/skills/<name>/ in dotclaude, or <repo>/.claude/skills/<name>/) and commits; the mirror follows.');
     }
     if (report.projects.some(p => p.dirtyPaths.length > 0)) {
         lines.push('Baseline rule: do not stamp a new baseline while watched local edits are dirty.');
@@ -372,11 +372,8 @@ function formatSkillNoSourceBinding(skillName) {
     return [
         '[greprag skill-staleness - no source binding]',
         `/${skillName} has no source bindings.`,
-        'Authority: canonical mirrored payload exists in GrepRAG; local Codex/Claude/OpenCode SKILL.md files are generated adapter-only mirrors.',
-        'Do not edit a local native adapter as skill content.',
-        `Agent-safe edit path: \`greprag skill mirror export ${skillName} --to <dir>\`, patch the exported Markdown files non-interactively, then \`greprag skill mirror apply <dir> --skill ${skillName} --expected-hash <exported-hash>\`.`,
-        `Human editor shortcut: \`greprag skill edit ${skillName}\`; Codex auto-skips the editor, and agents may pass \`--no-open\` explicitly.`,
-        `After binding a real source repo, stamp it with \`greprag skill source stamp ${skillName} --project <p> --path <rel>\`.`,
+        `Authority: git. Edit ~/.claude/skills/${skillName}/ (dotclaude) or <repo>/.claude/skills/${skillName}/ and commit; GrepRAG mirrors the committed files read only. Codex/OpenCode SKILL.md files are generated launchers, never content.`,
+        `To watch a source repo, stamp a binding into the git SKILL.md with \`greprag skill source stamp ${skillName} --project <p> --path <rel>\`, then commit.`,
     ].join('\n') + '\n';
 }
 function stampSourceBinding(params) {

package/package.json

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

package/skill/commander/SKILL.md

@@ -1,11 +1,10 @@
 ---
 name: commander
 description: |
-  DEPRECATED 2026-06-07 — superseded by the Front Desk Switchboard
-  (docs/front-desk-switchboard.md). Discord DMs now route through the
-  per-tenant receptionist brain (menu / connect / ring), the same as SMS;
-  the handoff-pin + emergency-router model this skill wrapped has been
-  retired. Pairing still works; "handoff" is a no-op. Kept for reference.
+  DEPRECATED 2026-06-07, retired 2026-10-06 — the handoff-pin +
+  emergency-router model this skill wrapped is gone, and so is the Front
+  Desk that replaced it. Nothing reads DMs sent to the bot any more.
+  Pairing still works, so sessions can DM the operator. Kept for reference.
 
   Field-commander interface over greprag's Discord DM bridge. Pair your
   Discord account once, then DM the bot to put any open Claude session
@@ -28,13 +27,12 @@ metadata:
 license: MIT
 ---
 
-> **⚠ DEPRECATED (2026-06-07).** Superseded by the **Front Desk Switchboard**
-> (`docs/front-desk-switchboard.md`). Discord DMs now go through the same
-> per-tenant receptionist brain as SMS — text `MENU` to the bot for the
-> deterministic menu (live sessions, connect, settings), or just talk to the
-> receptionist. The **handoff pin + emergency router this skill describes are
-> retired** (`/handoff` is a no-op). Pairing is unchanged. This file is kept for
-> historical reference only; do not build on it.
+> **⚠ RETIRED (2026-10-06).** The **handoff pin + emergency router this skill
+> describes are gone**, and so is the Front Desk that replaced them on
+> 2026-06-07 (`adr/front-desk-retirement.md`). Nothing reads DMs sent to the
+> bot; it answers each with a fixed line. Pairing is unchanged, so sessions can
+> still DM the operator with `greprag send --to discord:<snowflake>`. This file
+> is kept for historical reference only; do not build on it.
 
 # Commander — Discord DM bridge
 

package/skill/greprag/SKILL.md

@@ -237,7 +237,7 @@ Child watch events may appear on the parent TUI — resume the child to act. Do
 - `docs/inbox-watch.md` — SSE watcher patterns, liveness model, parent-side / post-send patterns
 - `docs/doctor.md` — `greprag doctor` (identity drift, orphan consolidation)
 - `docs/corpus.md` — upload + search arbitrary text (books, codebases, voice samples)
-- `docs/discord-handoff.md` — Commander DM bridge (`greprag discord pair/handoff`)
+- `docs/discord-handoff.md` — Discord DM bridge (`greprag discord pair`, `send --to discord:`; the handoff is retired)
 - `docs/memory-advanced.md` — raw curl, `/v1/memory/by-period` `--type` values, naming note
 - `docs/fix.md` — log + query project-specific fixes (the Mechanic's queue)
 - `docs/discover.md` — cross-project advisor lookup (`greprag discover`)

package/skill/greprag/docs/discord-handoff.md

@@ -1,8 +1,6 @@
-# Discord Handoff (Commander)
+# Discord DM bridge
 
-Discord DM bridge — user steps away from desk, conversation continues on phone. Orchestrator-side summary; operator-facing flow lives at `~/.claude/skills/commander/SKILL.md`.
-
-Two surfaces: one-time pairing (identity) + per-session handoff (active routing). Emergency-router fallback: if the user DMs the bot with no handoff active, the bot auto-links to the most-recently-attached session watcher under their tenant. Tag `references.discord.emergency_route` on the inbox row flags the auto-link; reply with self-identification on first response.
+The operator pairs their Discord account once. After that, any session can DM them. The bot does not read DMs sent to it: the Front Desk that used to answer them was retired 2026-10-06, so the bot replies to each with a fixed line. The handoff pin, `/switch` and the CLI's handoff commands were retired the same day.
 
 ## Pairing (one-time per tenant)
 
@@ -10,38 +8,16 @@ Two surfaces: one-time pairing (identity) + per-session handoff (active routing)
 greprag discord pair
 ```
 
-Generates a 6-char code. User DMs `@greprag` on Discord with `/pair <code>`. After that, the user's snowflake is bound to their greprag tenant. DMs from that snowflake land as inbox messages on `default_project_id` (the project they paired from).
+Generates a 6-char code. User DMs `@greprag` on Discord with `/pair <code>`. After that, the user's snowflake is bound to their greprag tenant.
 
 You don't run this — one-time setup the user does themselves. Detect "I'm paired" via `greprag discord me`: returns `paired: true` and the pairing's project_name.
 
-## Handoff (per-session routing pin)
-
-The pattern the user almost always means by "let's continue on Discord":
-
-```bash
-greprag discord handoff --ttl 60 --json
-```
-
-Run under `Monitor` (persistent: true). The command pins DMs from the user's snowflake to (this project, this session) for 60 min, fires a confirmation DM, then **blocks** streaming the session's inbox to stdout as JSON. Each line that prints is one Discord DM — Monitor delivers them as notifications back into your turn. Pin slides forward 30+ min on every inbound; an active thread stays anchored.
-
-Replies go out via:
+## Messaging the operator
 
 ```bash
 greprag send --to discord:<snowflake> "your message body"
 ```
 
-CLI handles UTF-8, Discord's 2000-char limit, optional `--ref-json '{"discord":{"reply_to_message_id":"..."}}'` for threading. **Do not use curl for this** — bash on Windows mangles em-dashes / curly quotes / emoji into Win-1252 bytes that render as `?` on Discord. Node fetch (which the CLI uses) is UTF-8 native.
-
-For long agent turns where auto-typing's 10-second window expires, call `greprag discord typing` between work steps to refresh the indicator. Silent on success.
-
-`greprag discord unhandoff` releases the pin early (DMs revert to default project). Pin also expires naturally via TTL.
-
-## Canonical handoff flow
-
-User says "let's keep going on Discord" / "DM me" / "I'm stepping out":
+It arrives as a DM from the bot. CLI handles UTF-8 and Discord's 2000-char limit. **Do not use curl for this** — bash on Windows mangles em-dashes / curly quotes / emoji into Win-1252 bytes that render as `?` on Discord. Node fetch (which the CLI uses) is UTF-8 native.
 
-1. Confirm pairing with `greprag discord me`. If unpaired, tell the user to run `greprag discord pair` and DM `/pair <code>` first.
-2. Resolve current session_id (`CLAUDE_SESSION_ID` env, or the 8-hex from SessionStart context).
-3. Arm: `Monitor` with command `greprag discord handoff --session <8-hex> --project <name> --ttl 60 --json`, persistent.
-4. Tell the user the pin is live; the bot already DMed them. Each reply from Discord fires as a Monitor notification.
-5. On each notification, parse the JSON body (`body` field = user's message text). Draft your reply. Send via `greprag send --to discord:<snowflake> "..."`. Snowflake is in `references.discord.snowflake`.
+During long agent turns, call `greprag discord typing` between work steps to show the typing indicator (it lasts about 10 seconds). Silent on success.

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

@@ -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.)
-- **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.
+- **Edit the git source and commit.** Global skills: `~/.claude/skills/<name>/` (dotclaude repo); project skills: `<repo>/.claude/skills/<name>/`; greprag-bundled skills: `packages/cli/skill/<name>/`. The commit message names the friction this fixes. Never edit a generated Codex/OpenCode launcher or the installed copy of a bundled skill.
 - **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.

package/skill/templates/chip-spawn.md

@@ -78,7 +78,7 @@ Your parent session is named `<parent-name>`. When you finish, report to it with
 greprag session retitle <your-own-8hex> "Chip <Label> — <workstream>"
 ```
 
-The leader dictates the exact string (e.g. `Chip A — Converter format coverage`); substitute your own 8-hex from SessionStart. This force-sets the registry title so the watcher list + Discord `/switch` line up with the leader's labels. Single chips skip this.
+The leader dictates the exact string (e.g. `Chip A — Converter format coverage`); substitute your own 8-hex from SessionStart. This force-sets the registry title so the watcher list lines up with the leader's labels. Single chips skip this.
 
 ## Report back — native `SendMessage`
 
@@ -87,7 +87,9 @@ Close the task body with this (substitute `<slug>` + `<parent-name>`):
 ````
 ---
 
-**Report back:** when the work is committed, send your result to the parent with native `SendMessage`, then end your turn:
+**Rebase before you report:** when the work is committed, rebase this branch onto the current tip of your merge target (the default branch, or the integration branch on a multi-chip mission), resolve any conflicts here, and rerun the affected checks. Only you can edit this worktree, so the parent lands your branch by fast-forward alone and sends it back if the tip has moved again.
+
+**Report back:** then send your result to the parent with native `SendMessage`, then end your turn:
 
 - `to`: `"<parent-name>"`
 - `message`: status, commit hash, branch `chip/<slug>`, and a one-line summary.
@@ -116,6 +118,8 @@ Chips never `npm run deploy` (or Wrangler / another provider deploy) from the wo
 
 ## Parent merge discipline — prune at the merge (HARD RULE)
 
+Land a chip branch with `git merge --ff-only chip/<slug>` under the merge lock, nothing more: the chip rebased and retested it before reporting. Never rebase inside the chip's worktree; you cannot edit there, so a conflict strands a half-finished rebase. A refused fast-forward goes back to the chip over `SendMessage` (free the lock first).
+
 When you (the parent) merge a chip branch — through the canonical commit path or a profile-declared merge — prune in the same breath: find the worktree holding `chip/<slug>` in `git worktree list` (the app's own worktree when the chip reused it, `.claude/worktrees/<slug>` on a local start), junction guard it (`~/.claude/skills/commit/guard-junctions.sh <worktree>`), `git worktree remove <worktree>`, and `git branch -d chip/<slug>` once merged. A chip that closed itself has already removed its own worktree, so no worktree holds the branch — delete the branch and move on, don't go hunting for it. Deferred cleanup = stale worktrees piling up (field state 2026-06-10: 3 leftovers). Multi-chip missions: worktree dies at the integration-branch merge; the branch lives until the configured default-branch merge (chip-leader Phase 4).
 
 **FIX chips report to the mission owner.** A `greprag fix spawn` mission is the source of truth for FIX behavior. `fix spawn` detects usable Git history and emits `workspaceMode`: Git uses an isolated worktree; non-Git, unavailable Git, or no commit uses the project-local task with serialized writes. Dispatch honors that mode without trying a worktree first. The FIX chip identifies the exact friction, makes the smallest durable root-cause fix, verifies and commits useful work, then reports the commit/result and cleanup parameters to the parent mission owner. It creates no human landing gate. If no live parent exists and the chip carries the full-goal mission, it follows the repo profile as mission owner.

package/skill/templates/delivery.md

@@ -96,6 +96,22 @@ again. Never rebase a shared default branch. A busy merge lock means retry
 after its holder finishes — never bypass it, and never take over someone
 else's in-progress merge.
 
+### Another session's branch is rebased by that session
+
+Step 2 happens in the checkout of whoever owns the branch, because only that
+session can edit there and so only it can resolve a conflict. A chip rebases
+onto its merge target's tip and retests before it reports, so its parent lands
+it with steps 3 to 5 alone. Never run `git -C <their worktree> rebase`: the
+write guard refuses your edits there, so the first conflict leaves you
+aborting, or leaves a half-finished rebase in someone else's checkout. If the
+fast-forward is refused because the tip moved, free the lock and send the
+branch back to its owner to rebase and retest. A chip that already closed left
+no worktree behind, so rebase its branch in a checkout you can edit.
+
+Field trigger (2026-10-06): a parent landing chip branches with
+`git -C <chip-worktree> rebase main` hit the same ADR conflict twice and could
+not resolve it either time.
+
 This lock is a short Git critical section. It is not a delivery lease, and it
 is not peer-acknowledgement polling.
 

package/skill/templates/os.md

@@ -31,7 +31,7 @@ conversation. The registration is part of the work, not an extra:
 
 - **Docs** mirror through `greprag doc mirror sync` and can still auto-register
   pointers when edited in a live session. Search/read them through the CLI.
-- **Skills** auto-mirror on use (`greprag load` serves them cross-machine).
+- **Skills** live in git (`~/.claude/skills/<name>/` or `<repo>/.claude/skills/<name>/`); commit them and the mirror follows (`greprag load` serves them cross-machine).
 - **Decisions** get a dated entry in the owning ADR / decision log, in the
   same commit as the code.
 - **Everything else** (state files, artifacts, conventions) gets its path

package/skill/templates/prompt-audit.md

@@ -1,4 +1,4 @@
-# Prompt Audit — dated-model cruft in canonical instructions
+# Prompt Audit — dated-model cruft in agent instructions
 
 <!-- adr: adr/prompt-audit-canon.md -->
 
@@ -14,56 +14,35 @@ local skill adapters may not override it.
 
 ## The one invariant
 
-**AUDIT FINDINGS LAND IN CANON, NEVER IN A FOLLOWER.** Global and repo
-instructions are served by `greprag load instructions`; `~/.claude/CLAUDE.md`,
-`~/.codex/AGENTS.md`, `<repo>/CLAUDE.md`, `<repo>/AGENTS.md` are one-way
-rendered followers. Editing a follower directly produces drift: the next
-`greprag instructions push` blocks with `local-change`, and the parity guard
-routes the repair back to `instructions pull`. So an accepted audit edit is
-applied to a **proposed revision file** in scratch and promoted with
-`greprag instructions pull <file> --scope <scope> --harness <harness> --push`.
-That single command advances canon (optimistic concurrency, `expectedRevision`)
-and materializes every follower for the scope. Nothing else writes a follower.
+**AUDIT FINDINGS LAND IN THE GIT SOURCE, NEVER IN A RENDERED FILE.**
+`~/.claude/CLAUDE.md` in the dotclaude repo is the global source; a repo's
+`CLAUDE.md` and `AGENTS.md` are ordinary files in that repo.
+`~/.codex/AGENTS.md` and `~/.config/opencode/AGENTS.md` are rendered from
+`~/.claude/CLAUDE.md` plus `~/.claude/instructions/<codex|opencode>.md` by
+`greprag instructions render` (session start runs it), so an edit there is
+overwritten. GrepRAG's copy (`greprag load instructions`) is read only and
+follows the last commit.
 
 ## Procedure
 
-1. **Scope and target model.** `--scope global` audits the tenant-global
-   revision; `--scope repo` audits the current repo's root revision. Target
+1. **Scope and target model.** Global audits `~/.claude/CLAUDE.md`; repo
+   audits the current repo's `CLAUDE.md`/`AGENTS.md`. Target
    model is the one Claude Code sessions run today (Claude Fable 5.1 as of
    2026-09). State both at the top of the report; do not ask.
-2. **Render canon, not disk.**
-   `greprag load instructions --scope global --harness claude-code > <scratch>/canon-global.md`
-   (repo: `--scope repo`). Confirm followers are fresh first with
-   `greprag instructions status --scope <scope>`; if any follower is
-   `local-change`, stop and have the operator `instructions pull` it before
-   auditing, or the audit will grade a stale canon.
-   Overlays: `instructions` canon is `shared` + per-harness raw suffixes. When
-   a suffix is non-empty, audit each harness render separately and land
-   suffix edits with `instructions overlay set|derive`, never by pulling a
-   rendered file as `shared`. When all suffixes are empty (check the document
-   via the API or `overlay` history), the Claude render **is** `shared` and
-   `pull` of the revised Claude render is exact.
-3. **Provenance.** The Claude follower is usually Git-tracked
-   (`~/.claude` dotclaude repo; repo files in the repo). `git log`/`git blame`
+2. **Read the source.** Global: `~/.claude/CLAUDE.md` plus any
+   `~/.claude/instructions/<harness>.md` addition; audit each addition
+   separately. Repo: that repo's `CLAUDE.md` and `AGENTS.md`. Confirm the
+   rendered files are current with `greprag instructions status`.
+3. **Provenance.** Every source file is in git. `git log`/`git blame`
    each emphatic or prohibitive line: which failure, on which model, did it
    prevent, and does it still reproduce on the target model?
 4. **Classify every line** with the rubric below. Produce the report and the
    proposed diff, both, always.
-5. **Land.** Copy the canon render to `<scratch>/proposed-<scope>.md`, apply
-   ONLY high-confidence hunks, then:
-   ```text
-   greprag instructions snapshot create --name pre-prompt-audit-<YYYY-MM-DD> --scope <scope>
-   greprag instructions pull <scratch>/proposed-<scope>.md --scope <scope> --harness claude-code --push
-   greprag instructions status --scope <scope>      # every follower fresh
-   ```
-   Medium findings and flags stay in the report for the operator; they are
-   applied by a later `pull` of an operator-approved revision, the same way.
-   If the follower lives in a Git repo, the push dirties it; the operator
-   commits that repo (the audit never runs git there).
-6. **Write the report** to `tasks/prompt-audit-<scope>-<date>.md` in the
-   repo you are working in (or scratch if the repo has no `tasks/`), in the
-   shape under "Report shape". Persona (`greprag persona show`) is a separate
-   system: note Persona findings in the report; never edit it from here.
+5. **Land.** Apply ONLY high-confidence hunks to the source file, show the
+   diff, and leave the commit to the operator (the audit never runs git in
+   their repos). After the commit, `greprag instructions render` rewrites the
+   AGENTS.md files and refreshes GrepRAG's copy. Medium findings and flags
+   stay in the report for the operator.
 
 ## Rubric (shipped copy — Anthropic prompt-audit, condensed, binding)
 
@@ -166,12 +145,12 @@ returns 400; prefill is replaced by structured outputs.
 ## Report shape
 
 Top: Assumptions (scope, target model), Inventory (what was audited and its
-canon revision), Summary (counts per group; two or three highest-impact
+source commit), Summary (counts per group; two or three highest-impact
 findings in prose). Then one entry per finding, ordered by confidence:
 
 | Field | Content |
 |---|---|
-| Location | `file:line` in the canon render |
+| Location | `file:line` in the source file |
 | Evidence | exact quoted text |
 | Pattern | the group/row above |
 | Why obsolete | one or two sentences tied to the target model's documented behavior |
@@ -185,12 +164,10 @@ only when tests, docs, and references to the removed text go too).
 
 ## Guardrails
 
-- Never edit `~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md`,
-  `~/.config/opencode/AGENTS.md`, or a repo `CLAUDE.md`/`AGENTS.md` by hand.
-  The only follower writer is `instructions push` (or `pull --push`).
+- Never edit `~/.codex/AGENTS.md` or `~/.config/opencode/AGENTS.md` by
+  hand: they are rendered. Edit `~/.claude/CLAUDE.md` or the harness addition.
 - Apply high-confidence hunks only. Medium and flag items wait for the
   operator.
-- Snapshot before pulling. Rollback is `greprag instructions restore
-  --snapshot <name> --scope <scope>` followed by `pull` of the restored file.
+- Rollback is `git revert` on the source file.
 - Persona is out of scope for edits; note findings only.
 - Out of taxonomy friction: `greprag fix spawn "<one unit>"`.