greprag 5.74.9 → 5.74.11

package/dist/opencode-plugin.bundle.js

@@ -1752,8 +1752,8 @@ function buildOsPrimer(env) {
     "[grepragOS \u2014 the operating laws. Full doctrine: `greprag load os`.]",
     '\u2022 Doctrine vs state: methods ship in the CLI (`greprag load`); live state lives in the repo. A skill that depends on repo state carries a "STATE \u2014 read these first" block naming exact paths.',
     "\u2022 Discoverability: every durable artifact must be findable next session \u2014 docs auto-register, skills auto-mirror, decisions get a dated ADR/decision-log entry, everything else gets its path named in the owning skill/doc. If nothing points at it, you didn't finish.",
-    "\u2022 Pull before derive: `greprag memory search` / `corpus search` / `load` BEFORE asking the operator or re-deriving what the project already knows. Named person/org/project/repo/customer/handle or unexplained proper noun \u2192 search Memory before guessing, unless fully defined in-turn.",
-    `\u2022 Friction \u21D2 fix NOW: type by durable repair surface (\`harness|doctrine|injection|env|code\`) \u21D2 \`greprag fix spawn --type <type> "<unit>"\`. It PRINTS a fix-chip mission \u2014 YOU then create the visible child task with that mission as its first message (how: \`greprag load ${spawnEntry}\`, or your harness's native task tool). Repo write = isolated worktree; data-only row/diagnosis = no repo write. One unit per chip; the chip fixes, verifies, checkpoints, and hands it to the mission delivery owner. Never queue friction.`,
+    "\u2022 Pull before derive: `greprag memory search` / `corpus search` / `load` BEFORE asking the operator or re-deriving what the project already knows. Friction or an env/toolchain/worktree/secret bootstrap roadblock \u2192 search Memory for the exact error/friction + repo/tool before inventing a workaround. Clear overcome \u2192 apply it and continue. Named person/org/project/repo/customer/handle or unexplained proper noun \u2192 search Memory before guessing, unless fully defined in-turn.",
+    `\u2022 Unresolved friction \u21D2 fix: only when Memory has no answer, the remembered overcome fails, or the same friction repeats. Then type by durable repair surface (\`harness|doctrine|injection|env|code\`) \u21D2 \`greprag fix spawn --type <type> "<unit>"\`. It PRINTS a fix-chip mission \u2014 YOU then create the visible child task with that mission as its first message (how: \`greprag load ${spawnEntry}\`, or your harness's native task tool). Repo write = isolated worktree; data-only row/diagnosis = no repo write. One unresolved unit per chip; the chip fixes, verifies, checkpoints, and hands it to the mission delivery owner.`,
     "\u2022 Teach the system, not the chat: explained twice by the operator \u21D2 it belongs in a skill / load entry / STATE block / ADR, not the conversation."
   ].join("\n");
 }
@@ -1827,7 +1827,7 @@ var OPENCODE_CHIP_SPAWN_POINTER = [
   "\u2022 Delegating a component of a plan to an isolated chip session, or `greprag fix spawn` just printed a FIX-chip mission? \u2192 run `greprag load chip-bootloader` FIRST for the method: OpenCode chips spawn natively via `greprag opencode chip goal create` + `greprag opencode chip spawn` (HTTP child session; manual paste only when the API is down). \u22652 chips at one objective \u2192 `greprag load chip-leader-opencode` BEFORE the first spawn."
 ].join("\n");
 var CODEX_CHIP_SPAWN_POINTER = [
-  "[greprag Codex delegation \u2014 internal subagent, 1\u20132-chip quick path with the initiator as LEAD, or a separate LEAD for larger/seamed missions.]",
+  "[greprag Codex delegation \u2014 1\u20132-chip quick path with the initiator as LEAD, or a separate LEAD for larger/seamed missions.]",
   "\u2022 About to delegate a Codex task? \u2192 run `greprag load codex-chip-spawn` FIRST. Use exact first-line titles `LEAD: <Mission>`, `Chip A/B/C: <Specific Purview>`, and `FIX: [type] <one friction unit>`. Chips are ordinary writable native tasks; completion is a native Codex task reply to the LEAD after committing. A `FIX:` task loads `greprag load mechanic` first."
 ].join("\n");
 var loadPrimerModule = {
@@ -2022,15 +2022,16 @@ function frictionReminderTier(stress) {
   return "silent";
 }
 var FIX_SPAWN = 'greprag fix spawn --type <harness|doctrine|injection|env|code> "<one unit>"';
+var MEMORY_SEARCH = 'greprag memory search "<exact error/friction + repo/tool>"';
 function buildMechanicLiveNotice(_env) {
-  return `GrepRAG Mechanic is live. Friction reflex: \`${FIX_SPAWN}\` \u2014 one fix chip per unit, spawned at the moment; then keep working. Check role only when needed: \`greprag mechanic role\`.`;
+  return `GrepRAG Mechanic is live. Friction order: \`${MEMORY_SEARCH}\` first; apply a clear overcome and continue. No answer, failed overcome, or repeated friction \u2192 \`${FIX_SPAWN}\`. Check role only when needed: \`greprag mechanic role\`.`;
 }
 function buildFrictionReminder(tier, env) {
   switch (tier) {
     case "nag":
-      return `\u26A0 FRICTION HIGH (live signal: repetition / errors / churn) \u2014 STOP pushing through. Name the ONE unit, choose type by repair surface, and spawn now: \`${FIX_SPAWN}\` (chip fixes, verifies, checkpoints, and hands it to the mission delivery owner). No friction? say "clear" + continue.`;
+      return `\u26A0 FRICTION HIGH (live signal: repetition / errors / churn) \u2014 STOP pushing through. MEMORY FIRST: \`${MEMORY_SEARCH}\`. Clear overcome \u2192 apply + continue. No answer, remembered overcome fails, or same friction repeats \u2192 \`${FIX_SPAWN}\`. No friction? say "clear" + continue.`;
     case "nudge":
-      return `\u26A0 Friction detected (live signal) \u2014 repeated yourself, fought a tool, or hit a wall? Choose type by repair surface and spawn: \`${FIX_SPAWN}\`, then keep working. Otherwise say "clear" + continue.`;
+      return `\u26A0 Friction detected (live signal) \u2014 repeated yourself, fought a tool, or hit a wall? Search first: \`${MEMORY_SEARCH}\`. Apply a clear overcome + continue; no answer, failed overcome, or repeat \u2192 \`${FIX_SPAWN}\`. Otherwise say "clear" + continue.`;
     default:
       return null;
   }
@@ -2041,22 +2042,11 @@ function buildBootstrapFrictionReminder(env) {
     return null;
   const repeats = b.repeats && b.repeats > 1 ? ` repeated ${b.repeats}x` : "";
   const error = b.error ? ` Last error: ${b.error}` : "";
-  return `\u26A0 BOOTSTRAP FRICTION detected${repeats}: setup/toolchain failure (${b.signal || "setup"}) around \`${b.command || "unknown command"}\`.${error} If this is not caused by the code you just edited, spawn a fix chip now: \`greprag fix spawn --type env "${bootstrapSummary(env)}"\`. The chip owns the root-cause repair, verifies it, and hands it to the mission delivery owner so future sessions stop hitting it.`;
-}
-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. 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.",
-    "Every repair is ROOT-CAUSE \u2014 fix the pattern that makes the friction class possible, never a guard on today's trigger.",
-    'A per-turn reminder fires ONLY when live friction is DETECTED (the stress signal \u2014 repetition / errors / churn), never on a timer \u2014 act on it, or say "clear" and continue.'
-  ].join("\n");
+  const summary = bootstrapSummary(env);
+  return `\u26A0 BOOTSTRAP FRICTION detected${repeats}: setup/toolchain failure (${b.signal || "setup"}) around \`${b.command || "unknown command"}\`.${error} MEMORY FIRST: \`greprag memory search "${summary}"\`. Apply a clear overcome + continue. No answer, remembered overcome fails, or the same failure repeats \u2192 \`greprag fix spawn --type env "${summary}"\`.`;
 }
 var mechanicFrictionModule = {
   id: "mechanic-friction",
-  dependsOn: ["chip-spawn-pointer"],
   // Stress fires the real friction reminder. A designated Mechanic also creates a
   // one-shot ambient route notice per source session/role epoch (hook-stamped).
   detect: (env) => {
@@ -2069,14 +2059,7 @@ var mechanicFrictionModule = {
       return { tier: "ambient" };
     return { tier: "silent" };
   },
-  announce: (env = {}) => {
-    const base = buildMechanicAnnounce();
-    if (env.mechanicLive && !env.mechanic)
-      return `${base}
-
-${buildMechanicLiveNotice(env)}`;
-    return base;
-  },
+  announce: () => null,
   reminder: (d, env) => {
     if (d.detail?.kind === "bootstrap-friction")
       return buildBootstrapFrictionReminder(env);
@@ -2558,9 +2541,9 @@ function buildOpenCodeEnv(params) {
     // No opencode-native friction detector is wired yet: Claude Code's stress /
     // bootstrap-friction signals come from state-trigger.ts reading the
     // transcript in hook.ts, and opencode has no equivalent source plumbed.
-    // 0 = calm keeps the mechanic-friction REMINDER silent while its ANNOUNCE
-    // (the fix-spawn doctrine) still lands every session. Detector design is
-    // parked with scored options in the chip report
+    // 0 = calm keeps the reminder-only mechanic-friction module silent. The
+    // os-primer still lands the memory-first escalation doctrine every session.
+    // Detector design is parked with scored options in the chip report
     // (chip/opencode-fix-chip-system-parity).
     stress: 0,
     armed: params.armed ?? false,

package/dist/windows-shims.js

@@ -10,7 +10,9 @@
  *  silently emitted no loadout announce and the report looked like a server
  *  bug. The CLI must catch that split itself: `greprag status` names every
  *  shim + the version it actually executes; `greprag doctor` rewrites stale
- *  shims to forward to a current one.
+ *  shims to forward to a current one. Durable shims must not forward into
+ *  fnm_multishells: those are per-shell temp directories and can disappear
+ *  while the stable PATH entry remains.
  *
  *  Pure helpers (parse/version/plan) are exported for unit tests; only
  *  `auditWindowsShims`/`repairStaleShims` touch PATH + disk.
@@ -55,6 +57,7 @@ exports.missingRequiredShimFiles = missingRequiredShimFiles;
 exports.auditWindowsShims = auditWindowsShims;
 exports.shimNeedsRepair = shimNeedsRepair;
 exports.planShimRepairs = planShimRepairs;
+exports.shimInstallCommand = shimInstallCommand;
 exports.repairStaleShims = repairStaleShims;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -111,6 +114,9 @@ function missingRequiredShimFiles(scriptPath, name) {
         return [];
     return requiredFilesForShim(name).filter(file => !fs.existsSync(path.join(info.root, file)));
 }
+function isFnmMultishellPath(p) {
+    return !!p && /[\\/]fnm_multishells[\\/]/i.test(path.normalize(p));
+}
 /** Resolve one shim: follow up to 3 .cmd forwarding hops, then read the
  *  owning package version. */
 function resolveShim(name, shimPath, active, installed) {
@@ -134,6 +140,7 @@ function resolveShim(name, shimPath, active, installed) {
     }
     const info = target ? shimPackageInfo(target) : null;
     const missingFiles = info ? requiredFilesForShim(name).filter(file => !fs.existsSync(path.join(info.root, file))) : [];
+    const volatileForward = !isFnmMultishellPath(shimPath) && isFnmMultishellPath(target);
     return {
         name,
         extension: path.extname(shimPath).toLowerCase() === '.ps1' ? '.ps1' : '.cmd',
@@ -143,6 +150,7 @@ function resolveShim(name, shimPath, active, installed) {
         version: info?.version ?? null,
         stale: info !== null && info.version !== installed,
         incomplete: missingFiles.length > 0,
+        volatileForward,
         missingFiles,
         unresolvable: target === null || info === null,
     };
@@ -199,7 +207,7 @@ function auditWindowsShims(installedVersion) {
     return out;
 }
 function shimNeedsRepair(shim) {
-    return shim.stale || shim.incomplete;
+    return shim.stale || shim.incomplete || shim.volatileForward;
 }
 function canForward(from, to) {
     if (from.extension === '.ps1')
@@ -214,6 +222,7 @@ function planShimRepairs(audits) {
             && !shimNeedsRepair(a)
             && !a.unresolvable
             && a.shimPath !== shim.shimPath
+            && (isFnmMultishellPath(shim.shimPath) || !isFnmMultishellPath(a.shimPath))
             && canForward(shim, a));
         return { shim, forwardTo: healthy ? healthy.shimPath : null };
     });
@@ -224,8 +233,15 @@ function describeProblem(shim) {
         parts.push(`v${shim.version}`);
     if (shim.incomplete)
         parts.push(`missing ${shim.missingFiles.join(', ')}`);
+    if (shim.volatileForward)
+        parts.push('fnm temp forward');
     return parts.length ? parts.join(', ') : 'unhealthy';
 }
+function shimInstallCommand() {
+    return process.platform === 'win32'
+        ? 'npm i -g greprag@latest --prefix "%APPDATA%\\npm"'
+        : 'npm i -g greprag@latest';
+}
 function writeForwarder(shim, forwardTo) {
     if (shim.extension === '.ps1') {
         fs.writeFileSync(shim.shimPath, [
@@ -250,7 +266,7 @@ function repairStaleShims(repairs) {
     const lines = [];
     for (const r of repairs) {
         if (!r.forwardTo) {
-            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.`);
+            lines.push(`✗ ${r.shim.shimPath} is unhealthy (${describeProblem(r.shim)}) and no durable current ${r.shim.name} shim exists on PATH to forward to — run \`${shimInstallCommand()}\`, then re-run doctor.`);
             continue;
         }
         try {

package/package.json

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

package/skill/greprag/SKILL.md

@@ -148,6 +148,8 @@ Aliases (silent back-compat): `greprag memory briefing` → `recap` (renamed v5.
 
 **Codex/Windows: ABOUT TO VALIDATE WITH NONTRIVIAL `node -e` JAVASCRIPT? STOP — write the code to a temporary `.cjs` file and run `node <file>`.** PowerShell parses the command before Node sees it; regex lookarounds, `$1`, pipes, nested quotes, and semicolons can be split or expanded before Node runs. Keep `node -e` only for tiny quote-free probes.
 
+**Codex/Windows: ABOUT TO CLEAN A GENERATED `dist` DIRECTORY? STOP — run `greprag codex clean-generated <path-to-dist>` instead of inline `Remove-Item -Recurse`.** Codex's native command launcher can reject free-form recursive delete text before PowerShell executes your path checks; the GrepRAG command resolves the `dist` path, requires a Git-root or explicit `--under` bound, rejects symlink/repo-metadata targets, and removes only that checked generated directory.
+
 **Codex messaging has one simple contract.** Discover Codex tasks with `codex_app.list_threads` unfiltered first, scope by cwd, then coordinate Codex-to-Codex with `codex_app.send_message_to_thread`; `query` may narrow only after cwd scoping. `greprag send` is the durable cross-harness inbox rail and fallback queue; it does not by itself prove that an idle Codex task woke or acted. Public installs use `greprag init --codex --tenant-id <handle>` and Codex hooks surface queued inbox rows at SessionStart/UserPromptSubmit boundaries. There is no Codex startup watcher to install. A stored row, completed user-only turn, app-server `turn/start` / `turn/steer`, or `codex exec resume` is not proof of agent action. Only the recipient's actual peer response proves delivery.
 
 **ABOUT TO `greprag send` TO A `@gmail.com` / `@anthropic.com` / REAL EMAIL ADDRESS? STOP — for `inbox`/`send` (internal cross-session messaging), `users.email` IS NEVER A ROUTING ADDRESS.** Use the numeric handle (`1834729@greprag.com`) or claimed vanity alias (`travis@greprag.com`). If you don't know the recipient's handle, ASK — don't guess from their email. adr: adr/numeric-handles.md. Full grammar: `docs/inbox.md § address`.
@@ -158,7 +160,7 @@ Aliases (silent back-compat): `greprag memory briefing` → `recap` (renamed v5.
 
 - `docs/setup.md` — codex · claude-code · opencode · auth · hooks · conventions · permissions · channels · anchor · bulk-register
 - `docs/platforms.md` — exact platform paths for Claude Code · Codex · OpenCode
-- `docs/codex-chip.md` — Codex subagent, quick-chip, Leader, reporting, and cleanup shape
+- `docs/codex-chip.md` — Codex quick-chip, Leader, reporting, and cleanup shape
 - `docs/per-project-flags.md` — flip `memory_capture` / `session_start_recap` / `inbox_notify`
 - `docs/inbox.md` — `greprag send`, `greprag inbox`, address grammar, retract (internal messaging)
 - `docs/email.md` — `greprag email send`/`pending`/`pull`/`boxes`/`domain` — REAL SMTP: send-as custom domains, segregated mailboxes (distinct from `send`)

package/skill/greprag/docs/codex-chip.md

@@ -2,14 +2,18 @@
 
 Use `greprag load codex-chip-spawn` for the Codex block recipe:
 
-- internal same-session subagent (`max_threads=6`, `max_depth=1`; no separate
-  worktree, manifest, inbox, or goal) uses `greprag load codex-subagent-spawn`;
 - quick mode: rename the current task `LEAD: <Mission>` and directly spawn
   1–2 visible `Chip A/B: <Specific Purview>` worktree tasks;
 - Leader mode: rename the current task `PLANNER: <Mission>`, then create a
   separate `LEAD: <Mission>` task before that LEAD spawns
   `Chip A/B/C: <Specific Purview>` children for seams or larger orchestration.
 
+Same-session subagents are native Codex behavior, not GrepRAG chip doctrine.
+Create visible chips with native `codex_app__create_thread`: `target.type =
+project`, the current `projectId`, a Codex `worktree` environment with
+`startingState: { type: "branch", branchName: "<prepared chip branch>" }`,
+plus top-level `model` and `thinking` from `greprag codex models show`.
+
 Normal chips are writable and own discovery, design, implementation, tests, and
 commit. Preserve the Codex-provided worktree, committed result artifact, and
 parent cleanup. The child opening prompt starts with the exact visible title
@@ -28,6 +32,10 @@ means the child archives its own Codex task; `Archive: no` leaves it open. The
 lead remains responsible for integration and post-merge branch bookkeeping,
 not routine child-task archival.
 Review is a separate explicit review chip/session when the lead asks for it.
+If the repo ships `scripts/codex-run.cjs`, children use
+`node scripts/codex-run.cjs -- <command ...>` for build/test/env-driven
+commands so ignored `.env`, `.env.local`, `.dev.vars`, and package-level env
+files are read from the main checkout without copying or printing secrets.
 FIX landing (adr/codex-landing-doctrine.md): a mission whose first line
 begins `FIX:` (from `greprag fix spawn`) uses the handoff's detected
 `workspaceMode`. Usable Git history selects an isolated worktree; non-Git,

package/skill/mechanic/SKILL.md

@@ -2,7 +2,7 @@
 name: mechanic
 description: |
   The Mechanic — keep the harness healthy. The loop is friction → fix → repair:
-  spawn one fix chip per live friction unit, then repair so it can't recur.
+  recall known overcomes first; spawn one fix chip per unresolved friction unit.
   Digest the existing fix queue and audit/design notes, audit fixes for drift,
   mine episodic memory, promote project-agnostic repairs to global. One-at-a-time
   conversational review — never bulk.
@@ -19,10 +19,13 @@ license: MIT
 
 # Mechanic
 
-> **Fix-spawn reflex (ratified 2026-07-12, grepragOS law 4 — supersedes the
-> routing/queueing reflex below wherever they conflict).** Friction is fixed at
-> the MOMENT it happens: `greprag fix spawn --type <type> "<one unit>"` emits a
-> FIX chip for exactly that unit (never absorb adjacent friction). The chip's
+> **Memory-first friction reflex (refined 2026-07-28, grepragOS laws 3–4 —
+> supersedes the routing/queueing reflex below wherever they conflict).** 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
+> `greprag fix spawn --type <type> "<one unit>"` emit a FIX chip for that
+> unresolved unit. The chip's
 > contract: identify the exact friction → make the smallest durable root-cause
 > fix → explain the friction and fix in human terms → checkpoint → hand it to
 > the mission delivery owner. A full-goal chip with no live parent becomes that
@@ -46,7 +49,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. 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.
+- **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. Search Memory first; a clear overcome is applied inline, while unresolved friction becomes one `greprag fix spawn --type <type> "<unit>"` chip.
 - **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.
 
@@ -97,8 +100,8 @@ the Codex-provided checkout: bundled load entries, skill templates, docs, hook
 context, CLI messages, and tests that teach agents how to use the harness.
 Inspect Codex behavior only far enough to correct those GrepRAG surfaces or to
 report a precise external blocker. Codex owns native task creation, worktrees,
-permissions, Git, and task lifecycle. Do not create another child or use an
-internal subagent unless the parent explicitly changes that assignment.
+permissions, Git, and task lifecycle. Do not create another child unless the
+parent explicitly changes that assignment.
 Landing (adr/codex-landing-doctrine.md): a `MECHANIC: <Mission>` or
 `FIX: <friction>` chip replies to its LEAD with the commit, exact friction,
 change, reason, checks, and cleanup parameters. The LEAD is the delivery owner
@@ -113,8 +116,7 @@ project worktree or local target. For 1–2 children the current
 task is the implicit LEAD; for more than two children or shared seams, load
 `chip-leader` and create a separate `LEAD: <Mission>` that dispatches exact
 `Chip A/B/C: <Specific Purview>` tasks.
-`multi_agent_v1__spawn_agent` is only an ephemeral same-session subagent and
-never satisfies a visible-chip requirement.
+Native same-session helpers never satisfy a visible-chip requirement.
 
 ABOUT TO answer a Mechanic peer who offers to coordinate, integrate, rework, or
 take over a harness repair? STOP — hand off the repair state: commit/branch,
@@ -293,11 +295,11 @@ greprag mechanic off / on             PANIC SWITCH — local file, no network; s
 
 **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. New friction is
-always Law 4: `greprag fix spawn --type <type> "<one unit>"`, one FIX chip per
-unit, at the moment it happens. `greprag mechanic set` only fans out a notice
-that teaches this fix-spawn reflex and preserves the reply rail for old mechanic
-threads. The Mechanic replies with `greprag mechanic reply --to <source-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

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

@@ -6,7 +6,7 @@
 
 The skill-tuning reflex injects a directive when a skill under break-in loads. The old directive said "watch your execution, emit a SELF-TUNING block, propose a fix" — vague (it pointed at the *run*, not the *skill*) and propose-only (no edit ever landed). This doc replaces that with **six locatable skill defects**, each mapped to one concrete edit. The reflex's loop is: **detect a defined friction → locate it in the skill's SKILL.md → apply the fix per the matching recipe → show the diff for one accept/revert.**
 
-A friction that doesn't match one of the six below is **not auto-fixable inline** — spawn a doctrine fix chip for the one unit (`greprag fix spawn --type doctrine "<skill friction unit>"`) and keep working. Use `greprag fix log` only for deliberate audit/design notes, not as the live-friction reflex. Do not invent edits outside these recipes.
+A friction that doesn't match one of the six below is **not auto-fixable inline**. Search Memory for the exact skill/friction first; apply a clear overcome and continue. If Memory has no answer, the overcome fails, or the friction repeats, spawn one doctrine fix chip (`greprag fix spawn --type doctrine "<skill friction unit>"`). Use `greprag fix log` only for deliberate audit/design notes. Do not invent edits outside these recipes.
 
 ## The two edit primitives (skill-optimize vocabulary)