harnesstrim 0.0.3 → 0.0.5

package/dist/cli.mjs

@@ -1166,8 +1166,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path15, errorMaps, issueData } = params;
-      const fullPath = [...path15, ...issueData.path || []];
+      const { data, path: path16, errorMaps, issueData } = params;
+      const fullPath = [...path16, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -1475,11 +1475,11 @@ var init_types2 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path15, key) {
+      constructor(parent, value, path16, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path15;
+        this._path = path16;
         this._key = key;
       }
       get path() {
@@ -5060,10 +5060,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path16) {
+  if (!path16)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path16.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5312,11 +5312,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path16, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path16);
     return iss;
   });
 }
@@ -17146,8 +17146,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path15) {
-      let input = path15;
+    function removeDotSegments(path16) {
+      let input = path16;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -17399,8 +17399,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path15, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path15 && path15 !== "/" ? path15 : void 0;
+        const [path16, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -20793,12 +20793,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs11, exportName) {
+    function addFormats(ajv, list, fs12, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs11[f]);
+        ajv.addFormat(f, fs12[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -22554,15 +22554,39 @@ var init_stdio2 = __esm({
 // ../mcp/src/server.ts
 var server_exports = {};
 __export(server_exports, {
+  createFileSink: () => createFileSink,
   createServer: () => createServer,
   runReduceTool: () => runReduceTool,
   startStdioServer: () => startStdioServer
 });
-function runReduceTool(text, minLength) {
+import fs10 from "node:fs";
+import path14 from "node:path";
+function createFileSink(metricsPath) {
+  return (event) => {
+    try {
+      const p = path14.resolve(metricsPath);
+      fs10.mkdirSync(path14.dirname(p), { recursive: true });
+      fs10.appendFileSync(p, JSON.stringify(event) + "\n");
+    } catch {
+    }
+  };
+}
+function runReduceTool(text, minLength, sink = noopSink) {
   const result = reduceAuto(text, minLength);
+  if (result.changed) {
+    sink({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      harness: "mcp",
+      tool: "reduce",
+      reducer: result.reducer,
+      beforeChars: text.length,
+      afterChars: result.output.length
+    });
+  }
   return { content: [{ type: "text", text: result.output }] };
 }
-function createServer() {
+function createServer(options = {}) {
+  const sink = options.metricsPath ? createFileSink(options.metricsPath) : noopSink;
   const server = new McpServer({ name: "harnesstrim", version: "0.0.1" });
   server.registerTool(
     "reduce",
@@ -22574,16 +22598,17 @@ function createServer() {
         minLength: external_exports.number().optional().describe("Skip reduction for inputs shorter than this many characters (default 400)")
       }
     },
-    async ({ text, minLength }) => runReduceTool(text, minLength)
+    async ({ text, minLength }) => runReduceTool(text, minLength, sink)
   );
   return server;
 }
-async function startStdioServer() {
-  const server = createServer();
+async function startStdioServer(options = {}) {
+  const metricsPath = options.metricsPath ?? process.env.HARNESSTRIM_TELEMETRY_PATH;
+  const server = createServer({ metricsPath });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
-var REDUCE_DESCRIPTION;
+var noopSink, REDUCE_DESCRIPTION;
 var init_server3 = __esm({
   "../mcp/src/server.ts"() {
     "use strict";
@@ -22591,6 +22616,8 @@ var init_server3 = __esm({
     init_stdio2();
     init_zod();
     init_src();
+    noopSink = () => {
+    };
     REDUCE_DESCRIPTION = "Slim noisy text to its signal: keeps failures, errors, assertions and summaries while dropping passing-test noise and generated-file (lockfile/dist) diffs. Pass test-runner output or a git diff and use the returned text instead of the raw output. Deterministic and idempotent; returns the input unchanged if no reducer matches or it is too short.";
   }
 });
@@ -22598,8 +22625,8 @@ var init_server3 = __esm({
 // src/cli.ts
 init_src();
 import { parseArgs } from "node:util";
-import fs10 from "node:fs";
-import path14 from "node:path";
+import fs11 from "node:fs";
+import path15 from "node:path";
 import os2 from "node:os";
 
 // src/doctor.ts
@@ -22681,40 +22708,45 @@ function checkSkills(dir, findings) {
   }
 }
 function checkOpenCode(dir, findings) {
-  const raw = readIfExists(path.join(dir, "opencode.json"));
-  if (raw === null) {
+  const hasOpencodeProject = readIfExists(path.join(dir, "opencode.json")) !== null || fs.existsSync(path.join(dir, ".opencode"));
+  if (!hasOpencodeProject) {
     findings.push({
       severity: "info",
-      title: "No opencode.json found",
-      detail: "No OpenCode project config in this directory."
+      title: "No OpenCode project config found",
+      detail: "No opencode.json or .opencode/ in this directory."
     });
     return;
   }
-  let config2;
-  try {
-    config2 = JSON.parse(raw);
-  } catch {
-    findings.push({
-      severity: "warn",
-      title: "opencode.json is not valid JSON",
-      detail: "Could not parse opencode.json to check plugin wiring."
-    });
-    return;
+  const wrapper = path.join(dir, ".opencode", "plugin", "harnesstrim.ts");
+  const wrapperPresent = fs.existsSync(wrapper);
+  const raw = readIfExists(path.join(dir, "opencode.json"));
+  let staleEntry = false;
+  if (raw !== null) {
+    try {
+      staleEntry = extractPluginNames(JSON.parse(raw)).some((p) => p.includes("@harnesstrim/adapter-opencode"));
+    } catch {
+    }
   }
-  const plugins = extractPluginNames(config2);
-  const installed = plugins.some((p) => p.includes("@harnesstrim/adapter-opencode"));
-  if (installed) {
+  if (wrapperPresent) {
     findings.push({
       severity: "ok",
-      title: "HarnessTrim OpenCode adapter is wired in",
-      detail: "@harnesstrim/adapter-opencode is present in opencode.json plugins."
+      title: "HarnessTrim OpenCode adapter is installed",
+      detail: ".opencode/plugin/harnesstrim.ts loads the adapter (OpenCode auto-loads it)."
     });
   } else {
     findings.push({
       severity: "warn",
-      title: "HarnessTrim adapter not installed in opencode.json",
+      title: "HarnessTrim adapter not installed for OpenCode",
       detail: "The OpenCode adapter would slim tool output automatically.",
-      suggestion: "Run `harnesstrim install opencode` to wire it in."
+      suggestion: "Run `harnesstrim install opencode --apply` to install the local plugin."
+    });
+  }
+  if (staleEntry && !wrapperPresent) {
+    findings.push({
+      severity: "warn",
+      title: "Stale adapter entry in opencode.json",
+      detail: "opencode.json lists @harnesstrim/adapter-opencode, but OpenCode's plugin field is a string array and ignores option tuples \u2014 this entry never loaded.",
+      suggestion: "Run `harnesstrim install opencode --apply` to migrate to the local plugin wrapper."
     });
   }
 }
@@ -22741,70 +22773,151 @@ function inspect(dir) {
 init_src();
 import fs2 from "node:fs";
 import path2 from "node:path";
+import { spawnSync } from "node:child_process";
 var OPENCODE_PLUGIN_NAME = "@harnesstrim/adapter-opencode";
-function pluginIndex(plugin) {
-  return plugin.findIndex(
-    (e) => typeof e === "string" && e.includes(OPENCODE_PLUGIN_NAME) || Array.isArray(e) && typeof e[0] === "string" && e[0].includes(OPENCODE_PLUGIN_NAME)
-  );
+var OPENCODE_ADAPTER_VERSION = "^0.0.2";
+var DEFAULT_OPENCODE_ADAPTER_CONFIG = {
+  mode: "active",
+  telemetry: true,
+  telemetryPath: ".harnesstrim/metrics.jsonl"
+};
+var WRAPPER_REL = path2.join(".opencode", "plugin", "harnesstrim.ts");
+var PKG_REL = path2.join(".opencode", "package.json");
+var OPENCODE_JSON = "opencode.json";
+function buildOpencodeWrapper(adapterConfig) {
+  const opts = JSON.stringify(adapterConfig, null, 2).replace(/\n/g, "\n  ");
+  return `// Generated by \`harnesstrim install opencode\`. Do not reference this plugin from
+// opencode.json \u2014 OpenCode's \`plugin\` field is a string array and cannot pass options,
+// so HarnessTrim options live here and OpenCode auto-loads this file from .opencode/plugin/.
+// The dependency is declared in ../package.json. Edit the options below freely.
+import { HarnessTrim } from "${OPENCODE_PLUGIN_NAME}";
+
+export const HarnessTrimPlugin = async (input) =>
+  HarnessTrim(input, ${opts});
+`;
 }
-function legacyPluginIndex(plugin) {
-  return plugin.findIndex(
-    (entry) => typeof entry === "object" && entry !== null && typeof entry.name === "string" && entry.name.includes(OPENCODE_PLUGIN_NAME)
-  );
+function buildOpencodePackageJson(existing) {
+  let base = {};
+  if (existing) {
+    try {
+      const parsed = JSON.parse(existing);
+      if (parsed && typeof parsed === "object") base = parsed;
+    } catch {
+    }
+  }
+  const deps = { ...base.dependencies };
+  deps[OPENCODE_PLUGIN_NAME] = OPENCODE_ADAPTER_VERSION;
+  return JSON.stringify({ ...base, dependencies: deps }, null, 2) + "\n";
+}
+function opencodeJsonReferencesAdapter(config2) {
+  const plugin = config2.plugin;
+  if (!Array.isArray(plugin)) return false;
+  return plugin.some((e) => {
+    if (typeof e === "string") return e.includes(OPENCODE_PLUGIN_NAME);
+    if (Array.isArray(e)) return typeof e[0] === "string" && e[0].includes(OPENCODE_PLUGIN_NAME);
+    if (e && typeof e === "object") {
+      const name = e.name;
+      return typeof name === "string" && name.includes(OPENCODE_PLUGIN_NAME);
+    }
+    return false;
+  });
 }
-function planOpencodeInstall(config2, adapterConfig) {
-  const base = typeof config2 === "object" && config2 !== null ? { ...config2 } : {};
-  const plugin = Array.isArray(base.plugin) ? [...base.plugin] : [];
-  const desired = adapterConfig ? [OPENCODE_PLUGIN_NAME, adapterConfig] : OPENCODE_PLUGIN_NAME;
-  const idx = pluginIndex(plugin);
-  const legacyIdx = idx === -1 ? legacyPluginIndex(plugin) : -1;
-  if (legacyIdx !== -1) {
-    const legacy = plugin[legacyIdx];
-    const options = legacy.options;
-    plugin[legacyIdx] = adapterConfig ? desired : typeof options === "object" && options !== null && !Array.isArray(options) ? [OPENCODE_PLUGIN_NAME, options] : OPENCODE_PLUGIN_NAME;
-    return { nextConfig: { ...base, plugin }, alreadyInstalled: true, changed: true };
-  }
-  if (idx === -1) {
-    plugin.push(desired);
-    return { nextConfig: { ...base, plugin }, alreadyInstalled: false, changed: true };
-  }
-  if (adapterConfig && JSON.stringify(plugin[idx]) !== JSON.stringify(desired)) {
-    plugin[idx] = desired;
-    return { nextConfig: { ...base, plugin }, alreadyInstalled: true, changed: true };
-  }
-  return { nextConfig: { ...base, plugin }, alreadyInstalled: true, changed: false };
-}
-function runInstallOpencode(dir, apply, presetName) {
+function cleanOpencodeJson(existing) {
+  let config2;
+  try {
+    config2 = JSON.parse(existing);
+  } catch {
+    throw new Error(`${OPENCODE_JSON} exists but is not valid JSON`);
+  }
+  if (!opencodeJsonReferencesAdapter(config2)) return null;
+  const plugin = config2.plugin.filter((e) => {
+    if (typeof e === "string") return !e.includes(OPENCODE_PLUGIN_NAME);
+    if (Array.isArray(e)) return !(typeof e[0] === "string" && e[0].includes(OPENCODE_PLUGIN_NAME));
+    if (e && typeof e === "object") {
+      const name = e.name;
+      return !(typeof name === "string" && name.includes(OPENCODE_PLUGIN_NAME));
+    }
+    return true;
+  });
+  const next = { ...config2 };
+  if (plugin.length === 0) delete next.plugin;
+  else next.plugin = plugin;
+  return { content: JSON.stringify(next, null, 2) + "\n" };
+}
+function planOpencodeInstall(input) {
+  const adapterConfig = input.adapterConfig ?? DEFAULT_OPENCODE_ADAPTER_CONFIG;
+  const wrapperContent = buildOpencodeWrapper(adapterConfig);
+  const packageJsonContent = buildOpencodePackageJson(input.existingPackageJson);
+  const opencodeClean = input.existingOpencodeJson ? cleanOpencodeJson(input.existingOpencodeJson) : null;
+  const opencodeJsonContent = opencodeClean?.content ?? null;
+  const wrapperChanged = input.existingWrapper !== wrapperContent;
+  const pkgChanged = input.existingPackageJson !== packageJsonContent;
+  const opencodeChanged = opencodeJsonContent !== null;
+  const alreadyInstalled = input.existingWrapper !== null;
+  const changed = wrapperChanged || pkgChanged || opencodeChanged;
+  return { wrapperContent, packageJsonContent, opencodeJsonContent, alreadyInstalled, changed };
+}
+function runInstallOpencode(dir, apply, presetName, installDeps = true) {
   let preset;
-  let adapterConfig;
+  let adapterConfig = { ...DEFAULT_OPENCODE_ADAPTER_CONFIG };
   if (presetName) {
     preset = getPreset(presetName);
     if (!preset) throw new Error(`Unknown preset: ${presetName}`);
-    adapterConfig = { ...preset.adapter };
-  }
-  const configPath = path2.join(dir, "opencode.json");
-  let raw = null;
-  try {
-    raw = fs2.readFileSync(configPath, "utf8");
-  } catch {
-    raw = null;
+    adapterConfig = { ...adapterConfig, ...preset.adapter };
   }
-  const existed = raw !== null;
-  let config2 = {};
-  if (raw !== null) {
+  const wrapperPath = path2.join(dir, WRAPPER_REL);
+  const packageJsonPath = path2.join(dir, PKG_REL);
+  const opencodeJsonPath = path2.join(dir, OPENCODE_JSON);
+  const readOrNull = (p) => {
     try {
-      config2 = JSON.parse(raw);
+      return fs2.readFileSync(p, "utf8");
     } catch {
-      throw new Error(`${configPath} exists but is not valid JSON`);
+      return null;
     }
-  }
-  const plan = planOpencodeInstall(config2, adapterConfig);
+  };
+  const existingWrapper = readOrNull(wrapperPath);
+  const existingPackageJson = readOrNull(packageJsonPath);
+  const existingOpencodeJson = readOrNull(opencodeJsonPath);
+  const plan = planOpencodeInstall({
+    existingWrapper,
+    existingPackageJson,
+    existingOpencodeJson,
+    adapterConfig
+  });
   let applied = false;
+  let depsInstalled = null;
+  let depsMessage;
   if (apply && plan.changed) {
-    fs2.writeFileSync(configPath, JSON.stringify(plan.nextConfig, null, 2) + "\n");
+    fs2.mkdirSync(path2.dirname(wrapperPath), { recursive: true });
+    fs2.writeFileSync(wrapperPath, plan.wrapperContent);
+    fs2.writeFileSync(packageJsonPath, plan.packageJsonContent);
+    if (plan.opencodeJsonContent !== null) fs2.writeFileSync(opencodeJsonPath, plan.opencodeJsonContent);
     applied = true;
+    if (installDeps) {
+      const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+      const res = spawnSync(npm, ["install", "--silent"], {
+        cwd: path2.dirname(packageJsonPath),
+        encoding: "utf8"
+      });
+      if (res.error || res.status !== 0) {
+        depsInstalled = false;
+        depsMessage = `Could not auto-install the adapter; run \`npm install\` in ${path2.dirname(packageJsonPath)}.`;
+      } else {
+        depsInstalled = true;
+      }
+    }
   }
-  return { configPath, existed, applied, preset, ...plan };
+  return {
+    ...plan,
+    wrapperPath,
+    packageJsonPath,
+    opencodeJsonPath,
+    existed: existingWrapper !== null,
+    applied,
+    depsInstalled,
+    depsMessage,
+    preset
+  };
 }
 
 // src/install-codex.ts
@@ -23101,6 +23214,19 @@ function extractOutputText2(p) {
 import path7 from "node:path";
 var HOOK_COMMAND = "harnesstrim hook claude";
 var HOOK_MATCHER = "Bash";
+var HARNESSTRIM_MARKER2 = "harnesstrim:begin";
+var REDUCE_INSTRUCTION_SNIPPET2 = `<!-- ${HARNESSTRIM_MARKER2} -->
+## Token economy (HarnessTrim)
+
+When a shell command produces long, noisy output \u2014 test runners, \`git diff\`, build logs,
+large file dumps \u2014 pipe it through the reducer so only the signal enters context:
+
+    <your command> 2>&1 | harnesstrim reduce --metrics .harnesstrim/metrics.jsonl
+
+This keeps failures, errors, assertions, and summaries while dropping passing-test noise and
+generated-file (lockfile/dist) diffs, and records what was saved. Prefer the installed skills
+for output, review, and scaffolding discipline.
+<!-- harnesstrim:end -->`;
 function hasHarnessTrimHook2(settings) {
   const hooks = settings.hooks;
   const post = hooks?.PostToolUse;
@@ -23132,12 +23258,16 @@ function planClaudeInstall(input) {
     action = hasHarnessTrimHook2(settings) ? "present" : "patch";
   }
   const nextSettings = action === "present" ? settings : addHook(settings);
+  const instructionsAction = input.claudeMdContent === null ? "create" : input.claudeMdContent.includes(HARNESSTRIM_MARKER2) ? "present" : "append";
   return {
     skillsDest,
     skills,
     settingsFile: path7.join(input.projectDir, ".claude", "settings.json"),
     settingsAction: action,
-    nextSettings
+    nextSettings,
+    instructionsFile: path7.join(input.projectDir, "CLAUDE.md"),
+    instructionsAction,
+    instructionsSnippet: REDUCE_INSTRUCTION_SNIPPET2
   };
 }
 function addHook(settings) {
@@ -23162,11 +23292,19 @@ function runInstallClaude(dir, apply) {
   } catch {
     settingsJsonContent = null;
   }
+  const claudeMdPath = path8.join(dir, "CLAUDE.md");
+  let claudeMdContent = null;
+  try {
+    claudeMdContent = fs6.readFileSync(claudeMdPath, "utf8");
+  } catch {
+    claudeMdContent = null;
+  }
   const plan = planClaudeInstall({
     projectDir: dir,
     skillsSourceDir,
     skillNames,
     settingsJsonContent,
+    claudeMdContent,
     existingSkillNames: existingSkillNames(skillsDest)
   });
   const copied = [];
@@ -23181,6 +23319,11 @@ function runInstallClaude(dir, apply) {
       fs6.mkdirSync(path8.dirname(plan.settingsFile), { recursive: true });
       fs6.writeFileSync(plan.settingsFile, JSON.stringify(plan.nextSettings, null, 2) + "\n");
     }
+    if (plan.instructionsAction === "create") {
+      fs6.writeFileSync(plan.instructionsFile, plan.instructionsSnippet + "\n");
+    } else if (plan.instructionsAction === "append") {
+      fs6.appendFileSync(plan.instructionsFile, "\n\n" + plan.instructionsSnippet + "\n");
+    }
     applied = true;
   }
   return { plan, applied, copied };
@@ -23256,7 +23399,7 @@ function runInstallPi(installDir, apply) {
 // src/install-hermes.ts
 import fs8 from "node:fs";
 import path12 from "node:path";
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 
 // ../adapter-hermes/src/index.ts
 import path11 from "node:path";
@@ -23323,7 +23466,7 @@ function runInstallHermes(installDir, apply) {
     fs8.writeFileSync(path12.join(pluginDest, ".installed"), markerFileContent2());
     copiedFiles.push(".installed");
     applied = true;
-    const enable = spawnSync("hermes", ["plugins", "enable", HERMES_PLUGIN_NAME], {
+    const enable = spawnSync2("hermes", ["plugins", "enable", HERMES_PLUGIN_NAME], {
       encoding: "utf8"
     });
     if (enable.error) {
@@ -23389,19 +23532,38 @@ function renderDoctor(report) {
 }
 function renderInstall(result, apply) {
   const lines = [];
-  if (result.alreadyInstalled) {
-    lines.push(`Already installed: ${result.configPath} already wires in the HarnessTrim adapter.`);
+  const wrapper = result.wrapperPath;
+  const pkg = result.packageJsonPath;
+  if (!result.changed) {
+    lines.push(`Already installed and up to date: ${wrapper} loads the HarnessTrim adapter.`);
+    if (result.preset) {
+      lines.push("");
+      lines.push(renderPresetAdvisory(result.preset));
+    }
     return lines.join("\n");
   }
   if (apply) {
-    lines.push(`Wrote ${result.configPath}:`);
-    lines.push(JSON.stringify(result.nextConfig, null, 2));
-  } else {
-    lines.push(`Dry run \u2014 no files changed. This is what \`--apply\` would write to ${result.configPath}:`);
+    lines.push(`Installed the OpenCode adapter as a local plugin:`);
+    lines.push(`  \u2022 wrote ${wrapper} (auto-loaded by OpenCode from .opencode/plugin/)`);
+    lines.push(`  \u2022 wrote ${pkg} (declares @harnesstrim/adapter-opencode)`);
+    if (result.opencodeJsonContent !== null) {
+      lines.push(`  \u2022 cleaned the adapter entry out of ${result.opencodeJsonPath} (options live in the wrapper now)`);
+    }
+    if (result.depsInstalled === true) lines.push(`  \u2022 installed the .opencode dependency`);
+    else if (result.depsInstalled === false) lines.push(`  ! ${result.depsMessage}`);
     lines.push("");
-    lines.push(JSON.stringify(result.nextConfig, null, 2));
+    lines.push("Reduction is active; telemetry writes to .harnesstrim/metrics.jsonl.");
+    lines.push("Reload OpenCode so it loads the plugin, then check `harnesstrim metrics`.");
+  } else {
+    lines.push(`Dry run \u2014 no files changed. \`--apply\` would:`);
+    lines.push(`  \u2022 write ${wrapper} (local plugin wrapper with the adapter options)`);
+    lines.push(`  \u2022 write ${pkg} (declare @harnesstrim/adapter-opencode) and install it`);
+    if (result.opencodeJsonContent !== null) {
+      lines.push(`  \u2022 remove the stale adapter entry from ${result.opencodeJsonPath}`);
+    }
     lines.push("");
-    lines.push("Re-run with `--apply` to write it.");
+    lines.push("OpenCode's `plugin` config can't pass options, so the adapter is installed as a");
+    lines.push("local plugin file instead. Re-run with `--apply` to write it.");
   }
   if (result.preset) {
     lines.push("");
@@ -23514,7 +23676,19 @@ function renderClaudeInstall(result, apply) {
     }
   }
   lines.push("");
-  lines.push("Note: the hook command is `harnesstrim hook claude` \u2014 ensure harnesstrim is on PATH.");
+  if (plan.instructionsAction === "present") {
+    lines.push(`${plan.instructionsFile}: reduce-pipe instruction already present (no change).`);
+  } else {
+    lines.push(
+      `${plan.instructionsFile}: reduce-pipe instruction ${apply ? plan.instructionsAction === "create" ? "created" : "appended" : "would be added"}.`
+    );
+  }
+  lines.push("");
+  lines.push("Note: `harnesstrim` must be on PATH (used by both the hook and the reduce pipe).");
+  lines.push(
+    "The CLAUDE.md instruction is the effective path today: current Claude Code versions don't apply"
+  );
+  lines.push("the hook's updatedToolOutput, so piping through `harnesstrim reduce` is what saves tokens.");
   if (!apply) lines.push("Dry run \u2014 nothing written. Re-run with `--apply`.");
   return lines.join("\n");
 }
@@ -23618,8 +23792,11 @@ Usage:
   harnesstrim preset list                  List policy presets
   harnesstrim preset show <name>           Show a preset in detail
   harnesstrim metrics [path]               Summarize adapter telemetry (JSONL)
-  harnesstrim reduce [--stats]             Slim stdin -> stdout (pipe noisy command output)
-  harnesstrim mcp                          Start the MCP server (stdio) exposing a reduce tool
+  harnesstrim reduce [--stats] [--metrics <path>]
+                                           Slim stdin -> stdout (pipe noisy command output);
+                                           --metrics records a TrimEvent per reduction
+  harnesstrim mcp [--metrics <path>]       Start the MCP server (stdio) exposing a reduce tool;
+                                           --metrics records a TrimEvent per reduction
   harnesstrim bench                        Run the Tier A reducer micro-benchmark
   harnesstrim --help                       Show this help
 
@@ -23669,7 +23846,7 @@ async function main(argv) {
             console.error("`harnesstrim install codex --global` requires `--hook`.");
             return 1;
           }
-          console.log(renderCodexGlobalHookInstall(runInstallCodexGlobalHook(path14.join(os2.homedir(), ".codex"), apply), apply));
+          console.log(renderCodexGlobalHookInstall(runInstallCodexGlobalHook(path15.join(os2.homedir(), ".codex"), apply), apply));
           return 0;
         }
         console.log(renderCodexInstall(runInstallCodex(dir, apply, values.hook === true), apply));
@@ -23701,9 +23878,9 @@ async function main(argv) {
       process.stdout.write(response);
       if (values.metrics && event) {
         try {
-          const p = path14.resolve(values.metrics);
-          fs10.mkdirSync(path14.dirname(p), { recursive: true });
-          fs10.appendFileSync(
+          const p = path15.resolve(values.metrics);
+          fs11.mkdirSync(path15.dirname(p), { recursive: true });
+          fs11.appendFileSync(
             p,
             JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), harness: which, ...event }) + "\n"
           );
@@ -23712,7 +23889,7 @@ async function main(argv) {
       }
       if (values.log) {
         try {
-          fs10.appendFileSync(
+          fs11.appendFileSync(
             values.log,
             JSON.stringify({ inputChars: input.length, changed: response !== "{}", responseChars: response.length }) + "\n"
           );
@@ -23741,8 +23918,8 @@ async function main(argv) {
       return 1;
     }
     case "metrics": {
-      const path15 = rest[0] ?? DEFAULT_METRICS_PATH;
-      console.log(renderMetrics(loadMetrics(path15)));
+      const path16 = rest[0] ?? DEFAULT_METRICS_PATH;
+      console.log(renderMetrics(loadMetrics(path16)));
       return 0;
     }
     case "reduce": {
@@ -23755,6 +23932,24 @@ async function main(argv) {
       const input = await readStdin();
       const result = reducePipe(input, minLength);
       process.stdout.write(result.output);
+      if (values.metrics && result.changed) {
+        try {
+          const p = path15.resolve(values.metrics);
+          fs11.mkdirSync(path15.dirname(p), { recursive: true });
+          fs11.appendFileSync(
+            p,
+            JSON.stringify({
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              harness: "pipe",
+              tool: "reduce",
+              reducer: result.reducer,
+              beforeChars: result.beforeChars,
+              afterChars: result.afterChars
+            }) + "\n"
+          );
+        } catch {
+        }
+      }
       if (values.stats) {
         const note = result.changed ? `${result.reducer}: ${result.beforeChars} -> ${result.afterChars} chars` : "no reduction (no reducer matched or below min-length)";
         console.error(`[harnesstrim reduce] ${note}`);
@@ -23763,7 +23958,7 @@ async function main(argv) {
     }
     case "mcp": {
       const { startStdioServer: startStdioServer2 } = await Promise.resolve().then(() => (init_server3(), server_exports));
-      await startStdioServer2();
+      await startStdioServer2(values.metrics ? { metricsPath: values.metrics } : {});
       await new Promise(() => {
       });
       return 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnesstrim",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "HarnessTrim CLI: doctor (diagnose token waste), install adapters, run benchmarks.",
   "license": "MIT",
   "type": "module",