wkappbot-code 0.3.22 → 0.3.25

package/README.md

@@ -12,7 +12,7 @@ The plugin `plugin/wisdom-kernel.js` maps OpenCode plugin events onto the harnes
 |---|---|---|
 | `tool.execute.before` | `pre` | Claude-shaped PreToolUse JSON (`tool_name`, `tool_input`, `session_id`, `cwd`). Exit 2 throws, which refuses the tool call with the guard's own message as the reason. |
 | `tool.execute.after` | `post` | fail-open |
-| `chat.message` | `prompt` | UserPromptSubmit: the intent lock owes a skill search (`wkskill search ...`) before real work |
+| `chat.message` | `prompt` | UserPromptSubmit: the intent lock owes a skill search (`wkappbot skill search ...`) before real work |
 | `event` `session.created` | `session` | SessionStart |
 | `event` `session.idle` | `stop-archive` | archive only, fail-open |
 | `experimental.chat.system.transform` | (none) | appends the reflex rules to the system prompt of EVERY model request, whatever the model (pinned to OpenCode 1.19.5; the e2e asserts every request carried them) |
@@ -57,7 +57,7 @@ The generated `opencode.json` holds the minimum: `$schema` and the plugin entry
 
 ## Uninstall
 
-`install` records, once, the machine state it changes: the global `core.hooksPath`, whether `~/.claude/settings.json`, `~/.wk-harness` and `~/.wk-harness-hooks` existed, and which shims it created (`wkappbot` beside the CLI, `wkskill` and `wk-verify` in `~/.local/bin`). `wkappbot-code uninstall` gives exactly that back: the recorded `core.hooksPath` (only when the current value is a hook folder the install wrote), the harness hook entries leave `settings.json` while yours stay (a file the install created is removed when nothing else is left), the recorded shims go, `~/.wk-harness` and `~/.wk-harness-hooks` go when the install created them, and the plugin entry leaves `opencode.json` (backed up first). It keeps `opencode-ai`, the core and its skills; `npm rm -g wkappbot-code` removes the CLI.
+`install` records, once, the machine state it changes: the global `core.hooksPath`, whether `~/.claude/settings.json`, `~/.wk-harness` and `~/.wk-harness-hooks` existed, and which shims it created (`wkappbot` beside the CLI and `wk-verify` in `~/.local/bin`; no `wkskill` command exists, the skill command is `wkappbot skill`). `wkappbot-code uninstall` gives exactly that back: the recorded `core.hooksPath` (only when the current value is a hook folder the install wrote), the harness hook entries leave `settings.json` while yours stay (a file the install created is removed when nothing else is left), the recorded shims go, `~/.wk-harness` and `~/.wk-harness-hooks` go when the install created them, and the plugin entry leaves `opencode.json` (backed up first). It keeps `opencode-ai`, the core and its skills; `npm rm -g wkappbot-code` removes the CLI.
 
 ## Model swap
 

package/bin/postinstall.js

@@ -7,7 +7,7 @@
 // CONTRACT: (a) ALWAYS exits 0 and returns within a moment -- the real work runs DETACHED and logs to
 // ~/.wkappbot-code/postinstall.log; (b) the worker runs `wkappbot-code install` (lays the web harness, wires
 // ~/.claude/settings.json through the lite harness -- PreToolUse, Stop, UserPromptSubmit, SessionStart -- the global git
-// hooks, the wkskill/wk-verify shims and the public skills, keeping every user setting), then `wkappbot-code doctor`,
+// hooks, the wk-verify shim and the public skills, keeping every user setting), then `wkappbot-code doctor`,
 // then a short self-test (lib/setup-run.js: core --version, skill read on-load, one hook allow, one hook refuse), and
 // writes ~/.wkappbot-code/postinstall.done {version, installRc, doctor:{pass,warn,fail,skip}, selftest:{n,m}, ...};
 // postinstall.running exists while the worker lives; (c) the first `wkappbot-code` run afterwards prints ONE summary

package/bin/wkappbot-code.js

@@ -40,7 +40,7 @@ import {
 import { homedir, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { quietCheck, runUpdate, updateRow } from "../lib/update.js"; import { rmTreeHard } from "../lib/rmtree.js"; import { plainFileUrl } from "../lib/fileurl.js";
+import { quietCheck, runUpdate, updateRow } from "../lib/update.js"; import { rmTreeHard } from "../lib/rmtree.js"; import { plainFileUrl } from "../lib/fileurl.js"; import { removeStaleWkskill } from "../lib/stale-wkskill.js"; import { checkPath, installBothLinks, removeCreatedLinks } from "../lib/doctor-path.js";
 import { applySets, askEach, buildConfig, configRow, detect, lineDiff, printDetected } from "../lib/config.js";
 import { aiCliRows, installAiClis, removeAiClis } from "../lib/ai-clis.js";
 import { hooksRow, wireClaudeHooks } from "../lib/hook-wire.js";
@@ -400,7 +400,7 @@ function installPlugin(o, kih, kihSource) {
 // The machine state an uninstall must give back, recorded ONCE (a re-install never overwrites the first record, or
 // it would record our own dispatcher as the "prior" hooksPath). Shim paths are those install may create.
 function shimCandidates() {
-  return [join(linkDir(), "wkappbot"), join(HARNESS_LINKS(), "wkskill"), join(HARNESS_LINKS(), "wk-verify"), join(HARNESS_LINKS(), "wkskill.cmd"), join(HARNESS_LINKS(), "wk-verify.cmd")];   // Windows (Git Bash) .cmd twins from harness-install.sh: recorded like the rest, so uninstall removes them, never a user file
+  return [join(linkDir(), "wkappbot"), join(HARNESS_LINKS(), "wk-verify"), join(HARNESS_LINKS(), "wk-verify.cmd")];   // Windows (Git Bash) .cmd twins from harness-install.sh: recorded like the rest, so uninstall removes them, never a user file
 }
 const PRE_SETTINGS = () => join(STATE_HOME(), "settings.pre-install.json");
 function recordPrior(prev) {
@@ -455,9 +455,8 @@ function install(o) {
     : ((prev.aiClis && (prev.aiClis.installed || []).length) ? prev.aiClis : { skipped: true });  // a skip still owns what an earlier install added
   const dest = binDest(o);
   st.bin = o.bin ? installBin(o) : { skipped: true, dest };
-  // 0.3.13 (owner 2026-11-09: "check that a missing core is handled as a failure"): NO core is a failed part on every
-  // road, an unreachable release host included. The hooks and the lite harness still install, so the risky classes are
-  // refused, but the install exits 1 and the banner says so until a rerun fetches the core.
+  if (o.bin) st.bin.links = installBothLinks({ dest, home: homedir(), env: process.env, log }).created;  // both bare names, recorded for uninstall
+  // 0.3.13: NO core is a failed part on every road (exit 1 until a rerun fetches it); the hooks and lite harness still install.
   if (o.bin && !st.bin.ok) { bad++; log("bin: FAILED -- no wkappbot core installed: " + st.bin.note); }
   st.harness = o.harness ? installHarness(o) : { skipped: true };
   if (o.harness && !st.harness.ok) { bad++; log("harness: FAILED -- " + st.harness.note); }
@@ -562,7 +561,7 @@ function uninstall(o) {
   }
   // 3b. the ~/.local/bin/wkappbot link: removed ONLY when it points at the core this install placed (the core file stays)
   const core = (st.bin && st.bin.dest) || binDest(o);
-  removeStarterMd(st.starterMd, log);
+  removeStarterMd(st.starterMd, log); removeStaleWkskill(HARNESS_LINKS(), log);  // an older harness install's counterfeit wkskill link (SDK e2e: local-bin=wkskill)
   let linkRemoved = "";
   for (const p of new Set(shimCandidates().concat([join(homedir(), ".local", "bin", "wkappbot")]))) {
     if (!isSymlink(p) || (st.shims || []).includes(p)) continue;
@@ -578,6 +577,7 @@ function uninstall(o) {
     if (body.includes(core)) { rmSync(cmdShim, { force: true }); linkRemoved = cmdShim; log("shim: removed " + cmdShim + " (it called the core this install placed)"); }
     else log("shim: kept " + cmdShim + " (it no longer calls " + core + ")");
   }
+  removeCreatedLinks(st.bin?.links || []).forEach((p) => log("links: removed " + p));  // only the links install recorded
   // Undo only our npm license marker; do not alter a marker owned by another installer.
   if (IS_WIN && st.bin?.ok) {
     const marker = join(dirname(core), ".wkappbot-code-install");
@@ -657,8 +657,8 @@ function doctor(o) {
     core = r.status === 0 ? (r.stdout || "").trim().split("\n")[0] : "";
     add("bin", !!core, core ? dest + "  " + core + (st.bin && st.bin.link ? "  (PATH link " + st.bin.link + ")" : "") : dest + " does not run", !!(st.bin && !st.bin.skipped));
   }
-  // kih-hook: the harness the plugin calls, and the verdict road it takes. No pwsh and no lite = NO verdict at all:
-  // that is a FAIL whatever the install mode, since the plugin then only refuses its own risky classes.
+  const pr = checkPath({ home: homedir(), env: process.env, platform: process.platform }); add("path", pr.ok, pr.text, true);
+  // kih-hook: the harness the plugin calls and its verdict road; no pwsh and no lite = NO verdict = FAIL whatever the install mode.
   const k = (entry && Array.isArray(entry) && entry[1] && entry[1].kihDir) || kihDir(o);
   const hk = hasHook(k);
   const ps = pwshPath();

package/lib/allow-compact.js

@@ -9,7 +9,6 @@ import { dirname } from "node:path";
 import { readSettings } from "./hook-wire.js";
 
 export const COMPACT_ALLOWS = [
-  "Bash(wkskill *)",               // skill read / search / like (the user's own store)
   "Bash(wkappbot skill *)",        // the same through the core
   "Bash(wkappbot file read *)",    // read-only file view
   "Bash(wk-verify)",               // live hook check, no arguments

package/lib/doctor-path.js

@@ -0,0 +1,279 @@
+// doctor-path.js -- the REQUIRED doctor row "path": are `wkappbot` AND `wkappbot-core` found by their BARE names
+// in a FRESH shell? Proto for wkappbot-code/lib/doctor-path.js. ES module, node built-ins only.
+// Linux/macOS: a login bash (bash -lc) with HOME as given and the OS persistent PATH.
+// Windows: a new cmd.exe whose PATH is machine PATH + user PATH read from the registry.
+// PASS only when each bare-name run prints "wkappbot v". Any other outcome is FAIL for that name.
+import { execFileSync } from "node:child_process";
+import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+const OK_MARK = "wkappbot v";
+const BINS = ["wkappbot", "wkappbot-core"];
+
+// One REG_SZ/REG_EXPAND_SZ Path value from the registry; "" when absent or reg is unavailable.
+function winRegPath(key) {
+  try {
+    const out = execFileSync("reg", ["query", key, "/v", "Path"], {
+      encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15000,
+    });
+    const m = out.match(/^\s*Path\s+REG_(?:EXPAND_)?SZ\s+(.*?)\s*$/m);
+    return m ? m[1] : "";
+  } catch {
+    return "";
+  }
+}
+
+// %VAR% expansion for registry values such as %USERPROFILE%\bin; unknown names are kept as written.
+function expandVars(s, env) {
+  return s.replace(/%([^%]+)%/g, (all, name) => (env[name] !== undefined ? env[name] : all));
+}
+
+// The real POSIX road: a login bash, as a user's new terminal starts. /etc/profile may reset PATH.
+export function loginShell(h, env, bin) {
+  try {
+    return execFileSync("bash", ["-lc", `command -v ${bin} && ${bin} --version`], {
+      encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 60000,
+      env: { HOME: h, PATH: env.PATH || "/usr/local/bin:/usr/bin:/bin" },
+    });
+  } catch (e) {
+    return typeof e.stdout === "string" ? e.stdout : "";
+  }
+}
+
+// checkPath({home, env, platform, readRegPath, runShell}) -> {ok, text}
+//   home        HOME (or USERPROFILE on Windows) the fresh shell starts in
+//   env         carries the OS persistent PATH (PATH key; default process.env)
+//   platform    process.platform by default; "win32" selects the registry road
+//   readRegPath injectable registry reader (tests pass a stub)
+//   runShell    injectable POSIX fresh-shell runner (default loginShell; the selftest injects a hermetic one)
+export function checkPath({ home, env = process.env, platform = process.platform, readRegPath = winRegPath, runShell = loginShell } = {}) {
+  const h = home || env.HOME || env.USERPROFILE || "";
+  let winPath = null;
+  const fails = [];
+  for (const bin of BINS) {
+    let out = "";
+    if (platform === "win32") {
+      if (winPath === null) {
+        const machine = expandVars(readRegPath("HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment"), env);
+        const user = expandVars(readRegPath("HKCU\\Environment"), env);
+        winPath = [machine, user].filter(Boolean).join(";");
+      }
+      try {
+        out = execFileSync("cmd.exe", ["/d", "/s", "/c", `${bin} --version`], {
+          encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 60000,
+          env: { SystemRoot: env.SystemRoot || "C:\\Windows", USERPROFILE: h, HOME: h, PATH: winPath },
+        });
+      } catch (e) {
+        out = typeof e.stdout === "string" ? e.stdout : "";
+      }
+    } else {
+      out = runShell(h, env, bin);
+    }
+    if (!out.includes(OK_MARK)) fails.push(bin);
+  }
+  if (fails.length) return { ok: false, text: fails.map((b) => `path: FAIL ${b} not found by bare name in a fresh shell`).join("; ") };
+  return { ok: true, text: "path: PASS wkappbot and wkappbot-core found by bare name in a fresh shell" };
+}
+
+// ---- installer helper: create the missing links on the persistent PATH ----------------------------------------
+
+const WIN_MACHINE_KEY = "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment";
+const WIN_USER_KEY = "HKCU\\Environment";
+
+// The PERSISTENT PATH entries. win32: machine Path then user Path from the registry (%VAR% expanded), the same
+// values a new cmd.exe is built from; the process PATH is never consulted there. POSIX: the PATH given in env.
+function persistentEntries(env, platform, readRegPath) {
+  if (platform !== "win32") return (env.PATH || "").split(":");
+  const machine = expandVars(readRegPath(WIN_MACHINE_KEY), env);
+  const user = expandVars(readRegPath(WIN_USER_KEY), env);
+  return [machine, user].join(";").split(";");
+}
+
+const onPathList = (env, platform, dir, readRegPath = winRegPath) => {
+  const norm = (p) => p.replace(/[\\/]+$/, "").toLowerCase();
+  return persistentEntries(env, platform, readRegPath).some((p) => p && norm(p) === norm(dir));
+};
+
+function occupied(p) {
+  try { lstatSync(p); return true; } catch { return false; }
+}
+
+function defaultNpmPrefix(platform) {
+  try {
+    return execFileSync(platform === "win32" ? "npm.cmd" : "npm", ["prefix", "-g"], {
+      encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 20000, shell: platform === "win32",
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+
+// The folder the links go in: npm global bin first, then ~/.local/bin. Prefers a folder already on PATH.
+// needsPath is true when neither is on the persistent PATH (then ensureLinks adds the chosen folder).
+export function pickBinDir({ home, env = process.env, platform = process.platform, npmPrefix = defaultNpmPrefix(platform), readRegPath = winRegPath } = {}) {
+  const npmBin = npmPrefix ? (platform === "win32" ? npmPrefix : join(npmPrefix, "bin")) : "";
+  const local = join(home, ".local", "bin");
+  const candidates = [npmBin, local].filter(Boolean);
+  const hit = candidates.find((d) => onPathList(env, platform, d, readRegPath));
+  if (hit) return { dir: hit, needsPath: false };
+  return { dir: candidates[0] || local, needsPath: true };
+}
+
+const exportLine = (dir) => `export PATH="${dir}:$PATH"`;
+const trimSlash = (p) => p.replace(/[\\/]+$/, "").toLowerCase();
+
+// PowerShell does the user-Path write: [Environment]::SetEnvironmentVariable broadcasts the settings change.
+// The folder arrives in an env var, never in the script text. Prints ADDED, or PRESENT when it is already there.
+const WIN_ADD_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  "$d = $env:WK_PATH_DIR",
+  "$cur = [Environment]::GetEnvironmentVariable('Path', 'User')",
+  "if ($null -eq $cur) { $cur = '' }",
+  "$want = $d.TrimEnd([char[]]@('\\', '/')).ToLowerInvariant()",
+  "$hit = @($cur.Split(';') | Where-Object { $_ -and ($_.TrimEnd([char[]]@('\\', '/')).ToLowerInvariant() -eq $want) })",
+  "if ($hit.Count -gt 0) { Write-Output 'PRESENT'; exit 0 }",
+  "$new = if ($cur.Trim() -eq '') { $d } else { $cur.TrimEnd(';') + ';' + $d }",
+  "[Environment]::SetEnvironmentVariable('Path', $new, 'User')",
+  "Write-Output 'ADDED'",
+].join("\n");
+
+// Removes exactly the folder's entries from the user Path (untouched entries keep their order and text).
+const WIN_REMOVE_SCRIPT = [
+  "$ErrorActionPreference = 'Stop'",
+  "$d = $env:WK_PATH_DIR",
+  "$cur = [Environment]::GetEnvironmentVariable('Path', 'User')",
+  "if ($null -eq $cur) { Write-Output 'ABSENT'; exit 0 }",
+  "$want = $d.TrimEnd([char[]]@('\\', '/')).ToLowerInvariant()",
+  "$keep = @($cur.Split(';') | Where-Object { -not ($_ -and ($_.TrimEnd([char[]]@('\\', '/')).ToLowerInvariant() -eq $want)) })",
+  "$new = $keep -join ';'",
+  "if ($new -eq $cur) { Write-Output 'ABSENT'; exit 0 }",
+  "[Environment]::SetEnvironmentVariable('Path', $new, 'User')",
+  "Write-Output 'REMOVED'",
+].join("\n");
+
+function psRun(script, dir) {
+  return execFileSync("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], {
+    encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 30000,
+    env: { ...process.env, WK_PATH_DIR: dir },
+  }).trim();
+}
+
+// Windows: append the folder to the USER Path. PowerShell first; the reg add road only when PowerShell fails.
+// Returns true only when this call wrote the entry (so uninstall removes only what install added).
+function addUserPathWin(dir, readRegPath) {
+  try {
+    return psRun(WIN_ADD_SCRIPT, dir) === "ADDED";
+  } catch {
+    const cur = readRegPath(WIN_USER_KEY);
+    if (cur.split(";").some((p) => p && trimSlash(p) === trimSlash(dir))) return false;
+    const next = cur ? cur + ";" + dir : dir;
+    execFileSync("reg", ["add", WIN_USER_KEY, "/v", "Path", "/t", "REG_EXPAND_SZ", "/d", next, "/f"], { stdio: "ignore", timeout: 15000 });
+    return true;
+  }
+}
+
+// Default PATH addition: POSIX appends an export line to ~/.profile; Windows appends to the user Path value.
+// Returns true only when this call wrote the PATH entry.
+function defaultAddToPath({ dir, home, platform, readRegPath = winRegPath }) {
+  try {
+    if (platform === "win32") return addUserPathWin(dir, readRegPath);
+    const profile = join(home, ".profile");
+    const text = existsSync(profile) ? readFileSync(profile, "utf8") : "";
+    if (text.includes(dir)) return false;
+    appendFileSync(profile, `\n${exportLine(dir)}\n`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Uninstall side of defaultAddToPath: removes exactly the entry install wrote. Returns true when something was removed.
+function defaultRemovePath({ dir, home, platform }) {
+  try {
+    if (platform === "win32") return psRun(WIN_REMOVE_SCRIPT, dir) === "REMOVED";
+    const profile = join(home, ".profile");
+    if (!existsSync(profile)) return false;
+    const lines = readFileSync(profile, "utf8").split("\n");
+    const keep = lines.filter((l) => l !== exportLine(dir));
+    if (keep.length === lines.length) return false;
+    writeFileSync(profile, keep.join("\n"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ensureLinks({home, platform, binDir, env, targets, npmPrefix, addToPath}) -> {created, dir, pathAdded}
+//   targets  REQUIRED {wkappbot: <core path>, "wkappbot-core": <core path>}; the installer passes the real files.
+//   Creates a link (POSIX symlink) or a .cmd shim (Windows) only where NOTHING exists yet: a user's own file is
+//   never overwritten and never listed in created. created is exactly what removeCreatedLinks may delete.
+export function ensureLinks({ home, platform = process.platform, binDir, env = process.env, targets, npmPrefix, addToPath = defaultAddToPath, readRegPath = winRegPath } = {}) {
+  if (!targets || !targets.wkappbot || !targets["wkappbot-core"]) throw new Error("ensureLinks: targets {wkappbot, wkappbot-core} required");
+  let dir = binDir, needsPath = false;
+  if (dir) needsPath = !onPathList(env, platform, dir, readRegPath);
+  else ({ dir, needsPath } = pickBinDir({ home, env, platform, npmPrefix, readRegPath }));
+  mkdirSync(dir, { recursive: true });
+  const created = [];
+  for (const bin of BINS) {
+    const dest = join(dir, platform === "win32" ? bin + ".cmd" : bin);
+    if (occupied(dest)) continue;
+    if (platform === "win32") writeFileSync(dest, `@"${targets[bin]}" %*\r\n`);
+    else symlinkSync(targets[bin], dest);
+    created.push(dest);
+  }
+  // Windows runs the PATH logic even when both shims already existed: the doctor row reads the persistent PATH,
+  // so a missing entry is a FAIL whether or not this run wrote a shim. POSIX keeps its old rule (a link was written).
+  const pathWanted = needsPath && (created.length > 0 || platform === "win32");
+  const pathAdded = pathWanted ? !!addToPath({ dir, home, platform, readRegPath }) : false;
+  return { created, dir, pathAdded };
+}
+
+// removeCreatedLinks(created, opts) -> the entries actually removed. Deletes only the listed entries, nothing else.
+// A "PATH:<folder>" entry is the PATH entry install added: it is removed by removePath (exactly that folder),
+// never by unlink. opts: platform, home, and an injectable removePath({dir, home, platform}) -> boolean.
+export function removeCreatedLinks(created = [], { platform = process.platform, home = process.env.HOME || process.env.USERPROFILE || "", removePath = defaultRemovePath } = {}) {
+  const removed = [];
+  for (const p of created) {
+    if (p.startsWith("PATH:")) {
+      try { if (removePath({ dir: p.slice(5), home, platform })) removed.push(p); } catch { /* not removed */ }
+      continue;
+    }
+    try { unlinkSync(p); removed.push(p); } catch { /* already gone */ }
+  }
+  return removed;
+}
+
+// installBothLinks({dest, home, platform, binDir, env, log}) -> {created, pathAdded, kept, dir}
+//   ALWAYS makes both bare names, wkappbot and wkappbot-core, in binDir (env WK_LINK_DIR, else ~/.local/bin).
+//   dest is the core file; Windows wkappbot-core.cmd points at wkappbot-core.exe beside it. A user's own file
+//   stays and is listed in kept (and logged), never in created. A path already holding THIS install's link (a
+//   re-install) is ours: it is recorded in created again, so uninstall removes it and the folder is left empty.
+export function installBothLinks({ dest, home, platform = process.platform, binDir, env = process.env, log = () => {}, addToPath = defaultAddToPath, readRegPath = winRegPath } = {}) {
+  const dir = binDir || env.WK_LINK_DIR || join(home, ".local", "bin");
+  const coreExe = platform === "win32" ? join(dirname(dest), "wkappbot-core.exe") : dest;
+  const targets = { wkappbot: dest, "wkappbot-core": coreExe };
+  const pathOf = (bin) => join(dir, platform === "win32" ? bin + ".cmd" : bin);
+  const ours = BINS.filter((bin) => occupied(pathOf(bin)) && isOurLink(pathOf(bin), targets[bin], platform));
+  const kept = BINS.filter((bin) => occupied(pathOf(bin)) && !ours.includes(bin));
+  for (const bin of kept) log("links: kept " + join(dir, bin) + " (not ours)");
+  const r = ensureLinks({ home, platform, binDir: dir, env, targets, addToPath, readRegPath });
+  const created = BINS.map(pathOf).filter((p) => r.created.includes(p) || ours.some((bin) => pathOf(bin) === p));
+  if (r.pathAdded) created.push("PATH:" + dir);  // recorded only when this install wrote the PATH entry
+  return { created, pathAdded: r.pathAdded, kept, dir };
+}
+
+// An occupied link path is OURS when a POSIX symlink resolves to the target this install would create, or a
+// Windows .cmd shim names that target. Anything else (a user's own file or symlink) is not ours.
+function isOurLink(p, target, platform) {
+  try {
+    if (platform === "win32") return readFileSync(p, "utf8").includes(`"${target}"`);
+    return lstatSync(p).isSymbolicLink() && resolve(dirname(p), readlinkSync(p)) === resolve(target);
+  } catch {
+    return false;
+  }
+}
+
+// removeRecorded(created): the uninstall side of installBothLinks; removes only what that install recorded.
+export function removeRecorded(created) {
+  return removeCreatedLinks(Array.isArray(created) ? created : []);
+}

package/lib/hook-wire.js

@@ -20,7 +20,10 @@ import { pickPython, stubWarning } from "./python-pick.js";
 // for harness hooks and deleted or rewrote them. Now a harness hook is a wkharness*.sh/.ps1/.cmd file name standing at a
 // path or word start, a file under a .wk-harness folder, the kih .claude/hooks scripts, or the two named sync hooks.
 const HARNESS_HOOK = /(^|[\s"'\\/])wkharness(-[\w-]+)?\.(sh|ps1|cmd)\b|\.wk-harness[\\/]|[\\/]\.claude[\\/]hooks[\\/](user-prompt-submit|session-start)\.sh\b|(^|[\s"'\\/])(wk-global-md-sync|wk-session-pull|wkappbot-shim)(\.[a-z0-9]+)?\b/;
-const ARMS = [["PreToolUse", "pre"], ["Stop", "stop"], ["UserPromptSubmit", "prompt"], ["SessionStart", "session"]];
+// The history arms (owner 2026-11-12) push the reflex history like the repo hooks: PostToolUse only for the cross-session
+// tools (a matcher, so no spawn per tool call), PreCompact, SessionEnd and StopFailure (a rate limit).
+const ARMS = [["PreToolUse", "pre"], ["Stop", "stop"], ["UserPromptSubmit", "prompt"], ["SessionStart", "session"],
+  ["PostToolUse", "post", "mcp__claude-code-remote__send_message|ReadNotifications"], ["PreCompact", "precompact"], ["SessionEnd", "sessionend"], ["StopFailure", "stopfail"]];
 const fwd = (p) => String(p || "").replace(/\\/g, "/").replace(/\/+$/, "");
 
 export function readSettings(path) {
@@ -80,10 +83,10 @@ export function wireSettings(path, lite) {
     }
     if (keep.length) out[ev] = keep;
   }
-  for (const [ev, arm] of ARMS) {
+  for (const [ev, arm, matcher] of ARMS) {
     const c = '"' + lite + '" ' + arm;
     if (!(out[ev] || []).some((g) => (g.hooks || []).some((h) => h.command === c)))
-      (out[ev] = out[ev] || []).push({ hooks: [{ type: "command", command: c, timeout: 10 }] });
+      (out[ev] = out[ev] || []).push({ ...(matcher ? { matcher } : {}), hooks: [{ type: "command", command: c, timeout: 10 }] });
   }
   d.hooks = out;
   mkdirSync(dirname(path), { recursive: true });

package/lib/stale-wkskill.js

@@ -0,0 +1,23 @@
+// stale-wkskill.js -- uninstall also removes the counterfeit wkskill command an OLDER harness install left in the link dir
+// (owner 2026-11-11: the fake wkskill is deleted; spokesman 2026-11-12: SDK e2e "after: local-bin=wkskill", RESULT 20/21 on every leg).
+// A link or .cmd twin is removed ONLY while it still points into a harness (its target or body names wkharness or wk-harness);
+// a wkskill file or link of the user's own stays. Spec: wkappbot skill read harness-installer-owns-all-setup
+import { lstatSync, readFileSync, readlinkSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+const isHarness = (s) => /wkharness|wk-harness/.test(String(s || ""));
+
+// -> the paths removed; log gets one line per candidate
+export function removeStaleWkskill(dir, log = () => {}) {
+  const removed = [];
+  for (const n of ["wkskill", "wkskill.cmd"]) {
+    const p = join(dir, n);
+    let st;
+    try { st = lstatSync(p); } catch { continue; }
+    let body = "";
+    try { body = st.isSymbolicLink() ? readlinkSync(p) : readFileSync(p, "utf8"); } catch { /* unreadable: kept */ }
+    if (isHarness(body)) { rmSync(p, { force: true }); removed.push(p); log("shim: removed " + p + " (the counterfeit wkskill command an older harness install linked)"); }
+    else log("shim: kept " + p + " (not a harness link)");
+  }
+  return removed;
+}

package/lib/wk-hook.js

@@ -301,16 +301,16 @@ export function isFastRead(tool, input) {
 }
 
 // SHIM PATH (SDK ROOT C 2026-11-06, run 42289814533): OpenCode's bash tool runs /bin/zsh on macOS, whose default PATH
-// has no ~/.local/bin, so "zsh:1: command not found: wkskill" and a Mac user could never pay the intent lock. A bash call
-// that names wkskill or wk-verify gets the shim dir (WK_LINK_DIR, else ~/.local/bin, where harness install.sh links
+// has no ~/.local/bin, so "zsh:1: command not found: wkappbot" and a Mac user could never pay the intent lock. A bash call
+// that names wkappbot or wk-verify gets the shim dir (WK_LINK_DIR, else ~/.local/bin, where harness install.sh links
 // them) prepended to PATH for that one command; nothing else changes. Returns the command to run (unchanged when the
 // shim is absent or the command names neither shim).
 export function withShimPath(tool, args, linkDir) {
   if (claudeToolName(tool) !== "Bash" || !args || typeof args.command !== "string") return args && args.command;
   const c = args.command;
-  if (!/(^|[\s;&|(`])(wkskill|wk-verify)(\s|$)/.test(c)) return c;
+  if (!/(^|[\s;&|(`])(wkappbot|wk-verify)(\s|$)/.test(c)) return c;
   const dir = linkDir || process.env.WK_LINK_DIR || join(homedir(), ".local", "bin");
-  if (!existsSync(join(dir, "wkskill")) && !existsSync(join(dir, "wk-verify"))) return c;
+  if (!existsSync(join(dir, "wkappbot")) && !existsSync(join(dir, "wk-verify"))) return c;
   if (c.startsWith("PATH=")) return c;
   return "PATH=" + JSON.stringify(dir) + ':"$PATH"; export PATH; ' + c;
 }
@@ -323,10 +323,10 @@ export const RULES_MARK = "[wisdom-kernel rules]";
 export const RULES = [
   RULES_MARK + " You run under the Wisdom Kernel harness (wkappbot-code). On every turn:",
   "1. One command per shell call; never chain a write with anything else.",
-  "2. A refusal names a skill: run wkskill read <id> (or wkappbot skill read <id>) and apply its remedy; never route around it.",
+  "2. A refusal names a skill: run wkappbot skill read <id> and apply its remedy; never route around it.",
   "3. Never use git --no-verify or git push --force, never change core.hooksPath, never rm -r a home directory, / or the project source.",
   "4. Never edit or delete files under .git.",
-  "5. After a new user prompt, run wkskill search <three or more words> before the first write; read-only tools stay open.",
+  "5. After a new user prompt, run wkappbot skill search <three or more words> before the first write; read-only tools stay open.",
 ].join("\n");
 
 // The top step lines of the on-load skill, fetched ONCE per process (one OpenCode server = its sessions) in the
@@ -337,7 +337,7 @@ export function onLoadLines(kihDir) {
   if (_onload) return _onload;
   _onload = new Promise((res) => {
     const k = kihDir || resolveKihDir();
-    const cands = [process.env.WK_APPBOT_SKILL_CMD, k && join(k, "bin", "wkskill"), "wkskill"].filter(Boolean);
+    const cands = [process.env.WK_APPBOT_SKILL_CMD, k && join(k, "bin", "wkappbot"), "wkappbot"].filter(Boolean);
     let out = "", done = false;
     const finish = () => {
       if (done) return; done = true;
@@ -347,9 +347,9 @@ export function onLoadLines(kihDir) {
       res(lines.slice(0, 3).map((l) => l.slice(0, 240)));
     };
     try {
-      const target = cands.find((p) => p === "wkskill" || existsSync(p)), opt = { stdio: ["ignore", "pipe", "ignore"] };
-      // Windows: a shell-less spawn cannot run a .cmd shim, the bare wkskill name (PATHEXT) or an extensionless sh script
-      const c = process.platform !== "win32" ? spawn(target, ["read", "on-load"], opt) : /\.exe$/i.test(target) ? spawn(target, ["read", "on-load"], opt) : /\.(cmd|bat)$/i.test(target) || target === "wkskill" ? spawn(target, ["read", "on-load"], { ...opt, shell: true }) : spawn("sh", [target.replace(/\\/g, "/"), "read", "on-load"], opt);
+      const target = cands.find((p) => p === "wkappbot" || existsSync(p)), opt = { stdio: ["ignore", "pipe", "ignore"] };
+      // Windows: a shell-less spawn cannot run a .cmd shim, the bare wkappbot name (PATHEXT) or an extensionless sh script
+      const c = process.platform !== "win32" ? spawn(target, ["skill", "read", "on-load"], opt) : /\.exe$/i.test(target) ? spawn(target, ["skill", "read", "on-load"], opt) : /\.(cmd|bat)$/i.test(target) || target === "wkappbot" ? spawn(target, ["skill", "read", "on-load"], { ...opt, shell: true }) : spawn("sh", [target.replace(/\\/g, "/"), "skill", "read", "on-load"], opt);
       c.stdout.on("data", (d) => { out += d; if (out.length > 65536) c.kill("SIGKILL"); });
       c.on("error", finish); c.on("close", finish);
       setTimeout(() => { try { c.kill("SIGKILL"); } catch {} finish(); }, 8000).unref();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wkappbot-code",
-  "version": "0.3.22",
+  "version": "0.3.25",
   "description": "wkappbot-code -- Wisdom Kernel: the pinned OpenCode bridge plus the reflex harness plugin, the wkappbot core, the web harness and the latest public skills in one install",
   "type": "module",
   "scripts": {

package/plugin/wisdom-kernel.js

@@ -51,7 +51,7 @@ export const WisdomKernel = async (ctx = {}, options = {}) => {
             (tail ? ": " + tail : "") + ". Fix the harness (wkappbot-code doctor) and retry.");
         }
       }
-      // macOS /bin/zsh has no ~/.local/bin on PATH: a wkskill call gets the shim dir for that one command (lib/wk-hook.js).
+      // macOS /bin/zsh has no ~/.local/bin on PATH: a wkappbot call gets the shim dir for that one command (lib/wk-hook.js).
       try { if (args && typeof args.command === "string") args.command = H.withShimPath(inp.tool, args); } catch {}
     },
     "tool.execute.after": async (input, output) => {

package/templates/global-CLAUDE.md

@@ -5,7 +5,7 @@ change it, install never touches it again, and `wkappbot-code uninstall` leaves
 
 ## How to work
 - Reply in the language the user writes in. Keep replies short and concrete; lead with the result.
-- Before real work, find the skill that governs it: `wkskill search <three or more words>`, then `wkskill read <id>`,
+- Before real work, find the skill that governs it: `wkappbot skill search <three or more words>`, then `wkappbot skill read <id>`,
   and follow the road it gives. Search again for any term you are not sure of, instead of guessing.
 - Run, do not guess: prove a change by running its test or command, and report the real output, failures included.
 - One command per tool call. Change only what the task needs, and back up a config file before you edit it.