greprag 5.74.3 → 5.74.5

package/dist/inline-atom-worker.js

@@ -67,4 +67,3 @@ async function main() {
 main().catch(() => {
     process.exit(0);
 });
-//# sourceMappingURL=inline-atom-worker.js.map

package/dist/inline-atom.js

@@ -253,4 +253,3 @@ function prepareInlineAtomContext(params) {
 function buildInlineAtomContext(params) {
     return prepareInlineAtomContext(params).text;
 }
-//# sourceMappingURL=inline-atom.js.map

package/dist/mechanic-friction.js

@@ -302,4 +302,3 @@ async function postMechanicReply(apiUrl, apiKey, args, cwd = process.cwd()) {
     return json;
 }
 exports.__test__ = { buildMechanicLiveBody };
-//# sourceMappingURL=mechanic-friction.js.map

package/dist/mechanic-role.js

@@ -104,4 +104,3 @@ function readMechanicRole(cwd) {
     const anchor = (0, project_anchor_1.readAnchor)(cwd);
     return { anchor, isMechanic: isMechanicProject(anchor), mechanicSessionId: readMechanicSessionId(anchor) };
 }
-//# sourceMappingURL=mechanic-role.js.map

package/dist/native-skill-adoption.js

@@ -237,4 +237,3 @@ function installAdoptedNativeSkill(params) {
     writeState(params.root, state);
     return 'installed';
 }
-//# sourceMappingURL=native-skill-adoption.js.map

package/dist/native-skill-mirror.js

@@ -310,6 +310,47 @@ function nativeCreationLocations(platform) {
     }
     return '`~/.claude/skills/<new-name>/SKILL.md` (global) or `<repo>/.claude/skills/<new-name>/SKILL.md` (project)';
 }
+function renderChangeSkillLine(params) {
+    const exportCommand = `greprag skill mirror export ${params.skillName} ${params.identityArg} --to <dir>`;
+    const applyCommand = `greprag skill mirror apply <dir> --skill ${params.skillName} ${params.editArgs} --expected-hash <exported-hash>`;
+    if (params.platform === 'codex') {
+        return `- **Change this skill:** run \`greprag load skill-change\`, then \`${exportCommand}\`; patch the exported Markdown files non-interactively; run \`${applyCommand}\`; then \`${params.syncCommand}\`; then verify with \`${params.loadCommand}\`.`;
+    }
+    return `- **Change this skill:** run \`greprag load skill-change\`, then \`greprag skill edit ${params.skillName} ${params.editArgs}\`, then \`${params.syncCommand}\`, then verify with \`${params.loadCommand}\`.`;
+}
+function renderEditingSection(platform, params) {
+    const exportCommand = `greprag skill mirror export ${params.skillName} ${params.identityArg} --to <dir>`;
+    const applyCommand = `greprag skill mirror apply <dir> --skill ${params.skillName} ${params.editArgs} --expected-hash <exported-hash>`;
+    if (platform === 'codex') {
+        return `## Editing
+
+Codex agents must use the non-interactive mirror path:
+
+\`\`\`bash
+${exportCommand}
+# patch the exported Markdown files with normal file edits
+${applyCommand}
+\`\`\`
+
+Do not launch an interactive editor from Codex. If using \`greprag skill edit\` as an export helper, include \`--no-open\` and run the printed apply command after patching.
+`;
+    }
+    return `## Editing
+
+To edit this skill, run the guarded editor flow:
+
+\`\`\`bash
+greprag skill edit ${params.skillName} ${params.editArgs}
+\`\`\`
+
+Manual path:
+
+\`\`\`bash
+${exportCommand}
+${applyCommand}
+\`\`\`
+`;
+}
 function renderAdapterBody(platform, skill) {
     const skillName = skill.skillName;
     const skillId = canonicalSkillId(skill);
@@ -324,6 +365,16 @@ function renderAdapterBody(platform, skill) {
         : `- **Create another skill:** create a normal native skill at ${creationLocations}; run \`${syncCommand} --dry-run\` and confirm it says \`adopt\`; then run \`${syncCommand}\`. GrepRAG adopts it as canon and replaces the native package with an adapter.`;
     const companions = skill.files.map(file => file.path).filter(relative => relative !== 'SKILL.md').sort();
     const harnessArg = `--harness ${platform}`;
+    const loadCommand = `greprag load ${skillName} ${identityArg} ${harnessArg}`;
+    const changeSkillLine = renderChangeSkillLine({
+        platform,
+        skillName,
+        editArgs,
+        identityArg,
+        syncCommand,
+        loadCommand,
+    });
+    const editingSection = renderEditingSection(platform, { skillName, editArgs, identityArg });
     const companionLines = companions.length
         ? companions.map(relative => `- \`greprag load ${skillName} ${relative} ${identityArg} ${harnessArg}\``).join('\n')
         : '- No companion docs are mirrored into this native adapter.';
@@ -337,8 +388,8 @@ Do not add or maintain project-state/doc pointers here. Current project state be
 
 Required action chains:
 
-- **Use this skill:** run \`greprag load ${skillName} ${identityArg} ${harnessArg}\` before acting.
-- **Change this skill:** run \`greprag load skill-change\`, then \`greprag skill edit ${skillName} ${editArgs}\`, then \`${syncCommand}\`, then verify with \`greprag load ${skillName} ${identityArg} ${harnessArg}\`.
+- **Use this skill:** run \`${loadCommand}\` before acting.
+${changeSkillLine}
 ${creationLine}
 
 Authority: ${skillId}
@@ -346,20 +397,7 @@ Source binding: ${sourceBindingState(skill)}
 Canonical content hash: ${canonicalContentHash(skill)}
 ${typeof skill.revision === 'number' ? `Mirror revision: ${skill.revision}` : 'Mirror revision: unknown'}
 
-## Editing
-
-To edit this skill, run the guarded editor flow:
-
-\`\`\`bash
-greprag skill edit ${skillName} ${editArgs}
-\`\`\`
-
-Manual path:
-
-\`\`\`bash
-greprag skill mirror export ${skillName} ${identityArg} --to <dir>
-greprag skill mirror apply <dir> --skill ${skillName} ${editArgs} --expected-hash <exported-hash>
-\`\`\`
+${editingSection}
 
 Snapshot rollback:
 
@@ -637,4 +675,3 @@ function nativeSkillMirrorSummary(result) {
         + (result.skipped ? `, ${result.skipped} unmanaged collision(s) preserved (GrepRAG canon was not written over the local skill)` : '')
         + (result.blocked ? `, ${result.blocked} diverged managed adapter(s) preserved — canonical skill remains in GrepRAG; inspect the local changes, then remove or relocate them and rerun \`greprag skill mirror sync\`` : '');
 }
-//# sourceMappingURL=native-skill-mirror.js.map

package/dist/native-skill-pending.js

@@ -252,4 +252,3 @@ function capturePendingNativeSkills(params) {
         touchedSkillCount: touched.length,
     };
 }
-//# sourceMappingURL=native-skill-pending.js.map

package/dist/opencode-plugin-crush.js

@@ -275,4 +275,3 @@ function crushMessages(messages, opts) {
     }
     return stats;
 }
-//# sourceMappingURL=opencode-plugin-crush.js.map

package/dist/opencode-plugin-helpers.js

@@ -509,4 +509,3 @@ async function buildRecapBody(apiUrl, apiKey, anchor, now = new Date()) {
     }
     return parts.join('\n');
 }
-//# sourceMappingURL=opencode-plugin-helpers.js.map

package/dist/opencode-plugin-png.js

@@ -272,4 +272,3 @@ function recodeMessagesToPng(messages, opts) {
         : 'threshold crossed but no recodable text parts (all below per-part floor or already marked)';
     return stats;
 }
-//# sourceMappingURL=opencode-plugin-png.js.map

package/dist/opencode-plugin.bundle.js

@@ -2046,7 +2046,7 @@ function buildBootstrapFrictionReminder(env) {
 function buildMechanicAnnounce() {
   return [
     "[Fix reflex \u2014 friction is fixed at the MOMENT it happens, one chip per unit (grepragOS law; full doctrine: `greprag load os`).]",
-    "WHEN friction happens \u2014 repeated yourself, fought a tool, got corrected >=2x on the same thing, rediscovered something already known, or hit a setup/toolchain failure not caused by code you just edited \u2014 spawn its fix chip NOW, then keep working. One unit = one chip; adjacent friction gets its own spawn. Never queue friction for later.",
+    "WHEN friction happens \u2014 repeated yourself, fought a tool, got corrected >=2x on the same thing, rediscovered something already known, or hit a setup/toolchain failure not caused by code you just edited \u2014 spawn its fix chip NOW, then keep working. Ordinary misunderstanding or misreading user intent is not friction unless it repeats or exposes a durable doctrine/harness/injection/env/code failure. One unit = one chip; adjacent friction gets its own spawn. Never queue friction for later.",
     'TYPE = durable repair surface: harness=hooks/watchers/task dispatch; doctrine=greprag load/skills/AGENTS; injection=recap/Capture/doc-pointer/stateful injection; env=bootstrap/deps/scripts/worktree setup; code=product/source behavior. Use: `greprag fix spawn --type <type> "<one unit>"`.',
     "WORKSPACE ROUTING: `fix spawn` detects usable Git history before dispatch \u2014 Git uses an isolated worktree; non-Git, unavailable Git, or no commit uses the project-local task with serialized writes. No fail-then-fallback attempt.",
     "THE CHIP'S CONTRACT (it self-enforces; you just spawn): identify the exact friction \u2192 make the smallest durable root-cause fix \u2192 explain and verify it \u2192 checkpoint \u2192 hand it to the mission delivery owner. With no live parent and a full-goal mission, the chip becomes delivery owner and follows the repo profile. No second lifecycle approval.",
@@ -2230,7 +2230,16 @@ var collisionMatchModule = {
 function buildVersionAnnounce(current, latest) {
   return [
     `[greprag \u2014 a new release is out: v${latest} (you are on v${current}).]`,
-    `Upgrade: \`npm i -g greprag@latest\`. New behavior + fixes land on your next session.`
+    `Upgrade: \`npm i -g greprag@latest\`, then \`greprag status\`. New behavior + fixes land once the active shell shim resolves to the new install.`
+  ].join("\n");
+}
+function buildActiveCommandDriftAnnounce(drift) {
+  const active = drift.activeVersion ? `v${drift.activeVersion}` : "an unknown version";
+  const missing = drift.missingFiles.length ? ` and is missing ${drift.missingFiles.join(", ")}` : "";
+  return [
+    `[greprag \u2014 active command drift detected.]`,
+    `The startup hook is running greprag v${drift.current}, but \`greprag\` on PATH resolves to ${active} at ${drift.shimPath}${missing}.`,
+    `Run \`greprag doctor --inspect\`; if it reports stale shims, run \`greprag doctor --yes\`. If no current shim exists, run \`npm i -g greprag@latest\`.`
   ].join("\n");
 }
 function buildLoadoutUpdateAnnounce(from, needed, current) {
@@ -2248,6 +2257,8 @@ var versionUpgradeModule = {
     const lo = env.loadoutUpdateRequired;
     if (lo && lo.needed && lo.current)
       return buildLoadoutUpdateAnnounce(lo.from, lo.needed, lo.current);
+    if (env.activeCommandDrift)
+      return buildActiveCommandDriftAnnounce(env.activeCommandDrift);
     const u = env.updateAvailable;
     if (!u || !u.current || !u.latest)
       return null;
@@ -2407,7 +2418,7 @@ var loadoutRegistrarModule = {
 // src/commands/delivery-reminder.ts
 function coordinationLine(platform) {
   if (platform === "codex") {
-    return "Codex coordination: discover local peers with list_threads; inspect/message them with native thread tools, and use GrepRAG for cross-harness peers.";
+    return "Codex coordination: call list_threads unfiltered, filter to this repo/worktree, inspect matching tasks, then send_message_to_thread with your branch/commit/status before merge/push/deploy. Use GrepRAG only for cross-harness peers.";
   }
   if (platform === "claude-code") {
     return "Claude Code coordination: discover peers with `greprag inbox watchers --json`, send to the exact session, and keep the Monitor armed for replies.";

package/dist/opencode-plugin.js

@@ -1148,4 +1148,3 @@ module.exports = {
     id: 'greprag-memory',
     server: GrepRAGMemoryPlugin,
 };
-//# sourceMappingURL=opencode-plugin.js.map

package/dist/proc.js

@@ -42,4 +42,3 @@ function safeSpawnSync(command, args = [], options) {
 function safeExecFileSync(file, args = [], options) {
     return (0, child_process_1.execFileSync)(file, args, { windowsHide: true, ...options });
 }
-//# sourceMappingURL=proc.js.map

package/dist/procedure-run.js

@@ -183,4 +183,3 @@ function currentReviewEvidence(run, fingerprint, strategy) {
     });
     return found ?? null;
 }
-//# sourceMappingURL=procedure-run.js.map

package/dist/procedure-runtime.js

@@ -147,4 +147,3 @@ function runProcedurePromptCheck(params) {
         return { mode: 'none' };
     }
 }
-//# sourceMappingURL=procedure-runtime.js.map

package/dist/procedure-shadow.js

@@ -119,4 +119,3 @@ function recordProcedureShadowOutcome(params) {
         candidate: params.candidate,
     });
 }
-//# sourceMappingURL=procedure-shadow.js.map

package/dist/procedure-watch.js

@@ -352,4 +352,3 @@ function openWatchIfIdle(projectId, verb, phase, shadowRunId) {
     writeProcedureWatch(projectId, openWatch(verb, phase, undefined, shadowRunId));
     return true;
 }
-//# sourceMappingURL=procedure-watch.js.map

package/dist/procedure.js

@@ -421,4 +421,3 @@ function activeProcedureAnnounces(store) {
     }
     return lines;
 }
-//# sourceMappingURL=procedure.js.map

package/dist/project-anchor.js

@@ -458,4 +458,3 @@ function setProjectRole(cwd, role) {
     fs.writeFileSync(targetPath, JSON.stringify(raw, null, 2) + '\n');
     return { anchor: readAnchor(cwd), anchorPath: targetPath };
 }
-//# sourceMappingURL=project-anchor.js.map

package/dist/reminder-injector.js

@@ -209,4 +209,3 @@ async function injectReminders(input, cfg, short, platform = 'claude-code') {
         return null;
     }
 }
-//# sourceMappingURL=reminder-injector.js.map

package/dist/secret-scrubber.js

@@ -365,4 +365,3 @@ function scrubObject(obj, valueMap) {
     }
     return obj;
 }
-//# sourceMappingURL=secret-scrubber.js.map

package/dist/session-id.js

@@ -210,4 +210,3 @@ function handleSessionIdHook(input) {
     };
     process.stdout.write(JSON.stringify(payload) + '\n');
 }
-//# sourceMappingURL=session-id.js.map

package/dist/skill-activation-manifest.js

@@ -151,4 +151,3 @@ function activationFromApiRows(params) {
     }));
     return buildMirroredSkillActivation(entries, readNativeSkillNames(params));
 }
-//# sourceMappingURL=skill-activation-manifest.js.map

package/dist/skill-landing.js

@@ -217,4 +217,3 @@ function landPendingGains(pending, cwd, homeDir, projectName) {
     }
     return { report, statusUpdates };
 }
-//# sourceMappingURL=skill-landing.js.map

package/dist/skill-mirror-client.js

@@ -334,4 +334,3 @@ async function maybeMirrorSkill(params) {
         return 'skipped';
     }
 }
-//# sourceMappingURL=skill-mirror-client.js.map

package/dist/skill-mirror-files.js

@@ -48,4 +48,3 @@ function isSafeMirroredSkillFile(file) {
         return true;
     return /^docs\/(?!.*(?:^|\/)\.\.(?:\/|$))[A-Za-z0-9._\/-]+\.md$/.test(file.path);
 }
-//# sourceMappingURL=skill-mirror-files.js.map

package/dist/skill-staleness.js

@@ -374,7 +374,8 @@ function formatSkillNoSourceBinding(skillName) {
         `/${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.',
-        `Safe edit path: \`greprag skill edit ${skillName}\` (wraps export -> editor -> hash-checked apply). Manual path: \`greprag skill mirror export ${skillName} --to <dir>\`, edit, then apply with the exported hash.`,
+        `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>\`.`,
     ].join('\n') + '\n';
 }
@@ -401,4 +402,3 @@ function stampSourceBinding(params) {
     const others = parseSkillSourceBindings(params.skillMd).filter(b => b.project !== params.project);
     return { content: upsertSkillSourceBindings(params.skillMd, [...others, binding]), binding };
 }
-//# sourceMappingURL=skill-staleness.js.map

package/dist/turn-provenance.js

@@ -53,4 +53,3 @@ function provenanceElisionMarker(p, hint) {
     const tail = hint ? ` (${hint})` : '';
     return `[greprag: harness-injected ${label}${tail} elided from episodic capture]`;
 }
-//# sourceMappingURL=turn-provenance.js.map

package/dist/windows-shims.js

@@ -1,7 +1,6 @@
 "use strict";
-/** Windows shim audit — detect (and let doctor repair) stale `greprag.cmd` /
- *  `greprag-hook.cmd` shims that resolve to a DIFFERENT install than the
- *  current CLI.
+/** Windows shim audit — detect (and let doctor repair) stale PowerShell/CMD
+ *  `greprag*` shims that resolve to a DIFFERENT install than the current CLI.
  *
  *  WHY: `npm i -g greprag@latest` upgrades the npm-global shim, but any
  *  hand-rolled `~/bin` shim (or an old bundled-folder copy referenced by a
@@ -52,38 +51,44 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseShimTarget = parseShimTarget;
 exports.shimPackageVersion = shimPackageVersion;
+exports.missingRequiredShimFiles = missingRequiredShimFiles;
 exports.auditWindowsShims = auditWindowsShims;
+exports.shimNeedsRepair = shimNeedsRepair;
 exports.planShimRepairs = planShimRepairs;
 exports.repairStaleShims = repairStaleShims;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 /** Extract the script a .cmd shim executes. Handles the npm shim shape
- *  (`"%dp0%\node_modules\greprag\dist\hook.js"`), absolute .js paths, and
- *  one-line `call "<other>.cmd"` forwarders. Pure. */
+ *  (`"%dp0%\node_modules\greprag\dist\hook.js"`), the npm PowerShell shim
+ *  shape (`"$basedir/node_modules/greprag/dist/index.js"`), absolute .js
+ *  paths, and one-line shim forwarders. Pure. */
 function parseShimTarget(cmdText, cmdDir) {
-    // Strip REM comment lines — a forwarder's provenance comment may name paths.
-    const text = cmdText.split(/\r?\n/).filter(l => !/^\s*(REM|::)\s/i.test(l)).join('\n');
-    // Quoted or bare tokens ending .js or .cmd that mention greprag.
-    const tokens = [...text.matchAll(/"([^"]+\.(?:js|cmd))"|(\S+\.(?:js|cmd))\b/gi)]
+    // Strip comments — a forwarder's provenance comment may name paths.
+    const text = cmdText.split(/\r?\n/).filter(l => !/^\s*(REM|::|#)\s/i.test(l)).join('\n');
+    // Quoted or bare tokens ending .js/.cmd/.ps1 that mention greprag.
+    const tokens = [...text.matchAll(/"([^"]+\.(?:js|cmd|ps1))"|(\S+\.(?:js|cmd|ps1))\b/gi)]
         .map(m => (m[1] || m[2] || '').trim())
         .filter(t => /greprag/i.test(t));
     if (tokens.length === 0)
         return null;
-    // Prefer a .js entrypoint over a forwarded .cmd; first match otherwise.
+    // Prefer a .js entrypoint over a forwarded shim; first match otherwise.
     const pick = tokens.find(t => /\.js$/i.test(t)) || tokens[0];
-    const expanded = pick.replace(/%~?dp0%?\\?/gi, cmdDir + path.sep);
+    const expanded = pick
+        .replace(/%~?dp0%?\\?/gi, cmdDir + path.sep)
+        .replace(/\$\{?basedir\}?/gi, cmdDir);
     return path.normalize(expanded);
 }
-/** Version of the greprag package that owns `scriptPath` — nearest
- *  package.json named `greprag` walking up (max 6 levels). Pure I/O read. */
-function shimPackageVersion(scriptPath) {
+/** GrepRAG package that owns `scriptPath` — nearest package.json named
+ *  `greprag` walking up (max 6 levels). Pure I/O read. */
+function shimPackageInfo(scriptPath) {
     let dir = path.dirname(scriptPath);
     for (let i = 0; i < 6; i++) {
         try {
             const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
-            if (pkg?.name === 'greprag' && typeof pkg.version === 'string')
-                return pkg.version;
+            if (pkg?.name === 'greprag' && typeof pkg.version === 'string') {
+                return { root: dir, version: pkg.version };
+            }
         }
         catch { /* keep walking */ }
         const up = path.dirname(dir);
@@ -93,6 +98,19 @@ function shimPackageVersion(scriptPath) {
     }
     return null;
 }
+/** Version of the greprag package that owns `scriptPath`. Pure I/O read. */
+function shimPackageVersion(scriptPath) {
+    return shimPackageInfo(scriptPath)?.version ?? null;
+}
+function requiredFilesForShim(name) {
+    return name === 'greprag' ? ['dist/commands/delivery.js'] : [];
+}
+function missingRequiredShimFiles(scriptPath, name) {
+    const info = shimPackageInfo(scriptPath);
+    if (!info)
+        return [];
+    return requiredFilesForShim(name).filter(file => !fs.existsSync(path.join(info.root, file)));
+}
 /** Resolve one shim: follow up to 3 .cmd forwarding hops, then read the
  *  owning package version. */
 function resolveShim(name, shimPath, active, installed) {
@@ -110,59 +128,134 @@ function resolveShim(name, shimPath, active, installed) {
         if (!t)
             break;
         target = t;
-        if (!/\.cmd$/i.test(t))
+        if (!/\.(cmd|ps1)$/i.test(t))
             break; // reached a .js entrypoint
-        current = t; // forwarded to another .cmd — follow
+        current = t; // forwarded to another shim — follow
     }
-    const version = target ? shimPackageVersion(target) : null;
+    const info = target ? shimPackageInfo(target) : null;
+    const missingFiles = info ? requiredFilesForShim(name).filter(file => !fs.existsSync(path.join(info.root, file))) : [];
     return {
-        name, shimPath, active, target, version,
-        stale: version !== null && version !== installed,
-        unresolvable: target === null || version === null,
+        name,
+        extension: path.extname(shimPath).toLowerCase() === '.ps1' ? '.ps1' : '.cmd',
+        shimPath,
+        active,
+        target,
+        version: info?.version ?? null,
+        stale: info !== null && info.version !== installed,
+        incomplete: missingFiles.length > 0,
+        missingFiles,
+        unresolvable: target === null || info === null,
     };
 }
-/** Every `greprag` / `greprag-hook` .cmd on PATH, in PATH order, with the
- *  version each actually executes. Empty off-Windows. */
+const SHIM_NAMES = ['greprag', 'greprag-hook', 'greprag-codex-hook'];
+const SHIM_EXTENSIONS = ['.ps1', '.cmd'];
+function pathDirs() {
+    const seen = new Set();
+    const out = [];
+    for (const raw of (process.env.PATH || '').split(path.delimiter)) {
+        const dir = raw.trim().replace(/^"|"$/g, '');
+        if (!dir)
+            continue;
+        const key = dir.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(dir);
+    }
+    return out;
+}
+function shimHits(name) {
+    const out = [];
+    for (const dir of pathDirs()) {
+        for (const ext of SHIM_EXTENSIONS) {
+            const candidate = path.join(dir, `${name}${ext}`);
+            try {
+                if (fs.existsSync(candidate))
+                    out.push(candidate);
+            }
+            catch { /* ignore unreadable PATH entries */ }
+        }
+    }
+    return out;
+}
+/** Every `greprag*` PowerShell/CMD shim on PATH, in PowerShell resolution order,
+ *  with the version each actually executes. Empty off-Windows. */
 function auditWindowsShims(installedVersion) {
     if (process.platform !== 'win32')
         return [];
     const out = [];
-    for (const name of ['greprag', 'greprag-hook']) {
-        let hits = [];
-        try {
-            hits = (0, child_process_1.execFileSync)('where.exe', [`${name}.cmd`], { encoding: 'utf-8' })
-                .split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+    for (const name of SHIM_NAMES) {
+        let hits = shimHits(name);
+        // Fallback for unusual PATHEXT/path behavior; keeps the old where.exe path.
+        if (hits.length === 0) {
+            try {
+                hits = (0, child_process_1.execFileSync)('where.exe', [`${name}.cmd`], { encoding: 'utf-8' })
+                    .split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+            }
+            catch { /* not found on PATH at all — nothing to audit */ }
         }
-        catch { /* not found on PATH at all — nothing to audit */ }
         hits.forEach((p, i) => out.push(resolveShim(name, p, i === 0, installedVersion)));
     }
     return out;
 }
-/** Repair plan: each stale shim forwards to the first same-name shim on PATH
+function shimNeedsRepair(shim) {
+    return shim.stale || shim.incomplete;
+}
+function canForward(from, to) {
+    if (from.extension === '.ps1')
+        return to.extension === '.ps1' || to.extension === '.cmd';
+    return to.extension === '.cmd';
+}
+/** Repair plan: each stale/incomplete shim forwards to the first same-name shim on PATH
  *  that already resolves to the installed version. Pure over the audit. */
 function planShimRepairs(audits) {
-    return audits.filter(a => a.stale).map(shim => {
-        const healthy = audits.find(a => a.name === shim.name && !a.stale && !a.unresolvable && a.shimPath !== shim.shimPath);
+    return audits.filter(shimNeedsRepair).map(shim => {
+        const healthy = audits.find(a => a.name === shim.name
+            && !shimNeedsRepair(a)
+            && !a.unresolvable
+            && a.shimPath !== shim.shimPath
+            && canForward(shim, a));
         return { shim, forwardTo: healthy ? healthy.shimPath : null };
     });
 }
+function describeProblem(shim) {
+    const parts = [];
+    if (shim.stale)
+        parts.push(`v${shim.version}`);
+    if (shim.incomplete)
+        parts.push(`missing ${shim.missingFiles.join(', ')}`);
+    return parts.length ? parts.join(', ') : 'unhealthy';
+}
+function writeForwarder(shim, forwardTo) {
+    if (shim.extension === '.ps1') {
+        fs.writeFileSync(shim.shimPath, [
+            '#!/usr/bin/env pwsh',
+            `# greprag doctor ${new Date().toISOString().slice(0, 10)}: was ${describeProblem(shim)}; forwarded to the current install.`,
+            `& "${forwardTo}" @args`,
+            'exit $LASTEXITCODE',
+            '',
+        ].join('\r\n'));
+        return;
+    }
+    fs.writeFileSync(shim.shimPath, [
+        '@ECHO off',
+        `REM greprag doctor ${new Date().toISOString().slice(0, 10)}: was ${describeProblem(shim)}; forwarded to the current install.`,
+        `call "${forwardTo}" %*`,
+        '',
+    ].join('\r\n'));
+}
 /** Rewrite each repairable stale shim as a one-line forwarder to its healthy
  *  sibling. Returns human-readable result lines. */
 function repairStaleShims(repairs) {
     const lines = [];
     for (const r of repairs) {
         if (!r.forwardTo) {
-            lines.push(`✗ ${r.shim.shimPath} is stale (v${r.shim.version}) and no current-version ${r.shim.name}.cmd exists on PATH to forward to — run \`npm i -g greprag@latest\`, then re-run doctor.`);
+            lines.push(`✗ ${r.shim.shimPath} is unhealthy (${describeProblem(r.shim)}) and no current ${r.shim.name} shim exists on PATH to forward to — run \`npm i -g greprag@latest\`, then re-run doctor.`);
             continue;
         }
         try {
-            fs.writeFileSync(r.shim.shimPath, [
-                '@ECHO off',
-                `REM greprag doctor ${new Date().toISOString().slice(0, 10)}: was a stale v${r.shim.version} shim; forwarded to the current install.`,
-                `call "${r.forwardTo}" %*`,
-                '',
-            ].join('\r\n'));
-            lines.push(`✓ ${r.shim.shimPath} (was v${r.shim.version}) now forwards to ${r.forwardTo}`);
+            writeForwarder(r.shim, r.forwardTo);
+            lines.push(`✓ ${r.shim.shimPath} (was ${describeProblem(r.shim)}) now forwards to ${r.forwardTo}`);
         }
         catch (e) {
             lines.push(`✗ could not rewrite ${r.shim.shimPath}: ${e.message}`);
@@ -170,4 +263,3 @@ function repairStaleShims(repairs) {
     }
     return lines;
 }
-//# sourceMappingURL=windows-shims.js.map

package/dist/worktree-state.js

@@ -58,4 +58,3 @@ function countMergedUnsweptWorktrees(cwd) {
         return 0; // missing git / non-repo / timeout / parse error — never fire
     }
 }
-//# sourceMappingURL=worktree-state.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greprag",
-  "version": "5.74.3",
+  "version": "5.74.5",
   "description": "GrepRAG — agent memory for Claude Code, Codex, and OpenCode.",
   "main": "dist/index.js",
   "bin": {

package/skill/mechanic/SKILL.md

@@ -46,7 +46,7 @@ task.
 
 The Mechanic keeps the harness healthy. The loop is **friction → fix → repair**:
 
-- **friction** — a rough spot the agent or operator hit: a gotcha, a rediscovery, a repeated correction, churn, rework. Live friction becomes one `greprag fix spawn --type <type> "<unit>"` chip at the moment it happens.
+- **friction** — a rough spot the agent or operator hit: a gotcha, a rediscovery, a repeated correction, churn, rework. Ordinary misunderstanding or misreading user intent is not friction unless it repeats or exposes a durable doctrine/harness/injection/env/code failure. Live friction becomes one `greprag fix spawn --type <type> "<unit>"` chip at the moment it happens.
 - **fix** — the repair mission or audit note. Live fixes are owned by spawned FIX chips; the queue remains for existing backlog and deliberate design-input notes.
 - **repair** — the fix wired in so it can't recur: a hook, a code change, or *surfacing it* (a doc line / a fact-seed / an injection). A repaired fix is done.
 

package/skill/templates/skill-change.md

@@ -17,6 +17,7 @@ This is an internal bundled GrepRAG schema, not tenant-controlled skill content.
 - Bundled GrepRAG skill: edit `packages/cli/skill/<name>/`, never the installed artifact.
 - Mirrored/local skill: edit its canonical source, not the generated Codex/Claude/OpenCode adapter.
 - Unknown source: stop and identify the canonical source before editing.
+- Codex/non-interactive harness: do not launch an editor. Use `greprag skill mirror export <skill> --to <dir>`, patch the exported Markdown files with file edits, then `greprag skill mirror apply <dir> --skill <skill> --expected-hash <exported-hash>`. If using `greprag skill edit` as the export helper, pass `--no-open`.
 
 ## Skill-Refresh Chips
 

package/dist/archive/glyph-font.d.ts

@@ -1,22 +0,0 @@
-/** 8x8 monochrome bitmap font for the PNG archive renderer — printable
- *  ASCII 32..126 (95 glyphs), one row byte per pixel row, LSB = leftmost.
- *
- *  Data: font8x8_basic by Daniel Hepper (public domain), itself based on
- *  Marcel Sondaar / IBM public-domain VGA fonts.
- *  https://github.com/dhepper/font8x8 — embedded as hex so the renderer
- *  has ZERO runtime deps (Node's built-in zlib does PNG compression).
- *
- *  All 95 glyph bitmaps are pairwise distinct (verified at generation,
- *  re-verified by tests/test-governed-compact.cjs), so pixel-level decode
- *  back to text is unambiguous — the basis of the round-trip self-test.
- *
- *  GENERATED from font8x8_basic.h — regenerate rather than hand-edit.
- */
-export declare const GLYPH_W = 8;
-export declare const GLYPH_H = 8;
-export declare const FIRST_CODE = 32;
-export declare const LAST_CODE = 126;
-/** Glyph rows (8 bytes) for a char code; null when outside 32..126. */
-export declare function glyphRows(code: number): number[] | null;
-export declare function codeForSignature(sigHex: string): number | null;
-export declare function signatureForRows(bytes: number[]): string;