harnesstrim 0.0.4 → 0.0.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HarnessTrim contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/assets/adapter-pi/extension/harnesstrim.ts

@@ -2,7 +2,7 @@
 //
 // Pi fires `tool_result` after a tool finishes and before the result reaches the model;
 // handlers chain like middleware and may return a patch ({ content, details, isError }).
-// This extension reduces string `content` for noisy output (test runners, git diffs, ...)
+// This extension reduces text chunks in structured tool results (test runners, git diffs, ...)
 // by shelling out to `harnesstrim reduce`, so it is self-contained (no workspace imports)
 // and loads from `~/.pi/agent/extensions/` or `<project>/.pi/extensions/`.
 //
@@ -12,15 +12,19 @@
 //   HARNESSTRIM_MINLENGTH=<chars>        (default 400)
 import { spawnSync } from "node:child_process";
 
+type TextContent = { type: "text"; text: string };
+type ToolContent = TextContent | { type: string; [key: string]: unknown };
+
 interface ToolResultEvent {
-  content?: unknown;
+  content?: ToolContent[];
   isError?: boolean;
 }
 interface ExtensionAPI {
   on(event: string, handler: (event: ToolResultEvent, ctx: unknown) => unknown): void;
 }
 
-const env = globalThis.process?.env ?? {};
+const runtime = globalThis as typeof globalThis & { process?: NodeJS.Process };
+const env = runtime.process?.env ?? {};
 const MODE = env.HARNESSTRIM_MODE ?? "dryrun";
 const MIN_LENGTH = Number(env.HARNESSTRIM_MINLENGTH ?? "400") || 400;
 const MARKER = "[harnesstrim";
@@ -44,19 +48,28 @@ function reduceViaCli(text: string): string | null {
 export default function harnesstrim(pi: ExtensionAPI): void {
   if (MODE === "off") return;
   pi.on("tool_result", async (event) => {
-    const content = event.content;
-    if (typeof content !== "string" || content.length < MIN_LENGTH) return;
-    if (content.includes(MARKER)) return; // already reduced — avoid double work
-
-    const reduced = reduceViaCli(content);
-    if (!reduced || reduced.length >= content.length) return;
-
-    if (MODE === "dryrun") {
-      globalThis.process?.stderr?.write(
-        `[harnesstrim] dryrun tool_result: ${content.length} -> ${reduced.length} chars\n`
-      );
-      return; // dryrun: observe only
-    }
-    return { content: reduced }; // active: patch the tool result the model sees
+    if (!Array.isArray(event.content)) return;
+
+    let changed = false;
+    const content = event.content.map((chunk) => {
+      if (chunk.type !== "text" || typeof chunk.text !== "string") return chunk;
+      const text = chunk.text;
+      if (text.length < MIN_LENGTH || text.includes(MARKER)) return chunk;
+
+      const reduced = reduceViaCli(text);
+      if (!reduced || reduced.length >= text.length) return chunk;
+
+      if (MODE === "dryrun") {
+        runtime.process?.stderr?.write(
+          `[harnesstrim] dryrun tool_result: ${text.length} -> ${reduced.length} chars\n`
+        );
+        return chunk;
+      }
+
+      changed = true;
+      return { ...chunk, text: reduced };
+    });
+
+    return changed ? { content } : undefined;
   });
 }

package/dist/cli.mjs

@@ -581,6 +581,75 @@ ${input.slice(response.index)}`;
   }
 });
 
+// ../core/src/reducers/lint-output-slim.ts
+function isLintLine(line) {
+  return LINT_LINE_RE.test(line);
+}
+var MARKER_PREFIX7, LINT_LINE_RE, MAX_RULES_IN_MARKER, lintOutputSlim;
+var init_lint_output_slim = __esm({
+  "../core/src/reducers/lint-output-slim.ts"() {
+    "use strict";
+    MARKER_PREFIX7 = "[harnesstrim:lint-output-slim]";
+    LINT_LINE_RE = /^[\w.\/\\-]+:\d+:\d+\s+(warning|error)\s+([\w@.\/-]+)/;
+    MAX_RULES_IN_MARKER = 8;
+    lintOutputSlim = {
+      name: "lint-output-slim",
+      reduce(input) {
+        const lines = input.split(/\r?\n/);
+        const out = [];
+        let droppedTotal = 0;
+        let i = 0;
+        while (i < lines.length) {
+          const line = lines[i];
+          if (!isLintLine(line)) {
+            out.push(line);
+            i++;
+            continue;
+          }
+          const counts = [];
+          const byKey = /* @__PURE__ */ new Map();
+          let runEnd = i;
+          while (runEnd < lines.length && isLintLine(lines[runEnd])) {
+            const m = LINT_LINE_RE.exec(lines[runEnd]);
+            const severity = m[1] === "error" ? "error" : "warning";
+            const rule = m[2];
+            const key = `${severity}:${rule}`;
+            const existing = byKey.get(key);
+            if (existing) {
+              existing.count++;
+            } else {
+              const entry = { severity, rule, count: 1 };
+              byKey.set(key, entry);
+              counts.push(entry);
+            }
+            runEnd++;
+          }
+          const runLength = runEnd - i;
+          if (runLength >= 2) {
+            const parts = counts.slice(0, MAX_RULES_IN_MARKER).map(
+              (c) => `${c.rule} \xD7${c.count}`
+            );
+            const truncated = counts.length > MAX_RULES_IN_MARKER;
+            const suffix = truncated ? `, +${counts.length - MAX_RULES_IN_MARKER} more rule(s)` : "";
+            const severities = counts.some((c) => c.severity === "error") && counts.some((c) => c.severity === "warning") ? "error(s) and warning(s)" : counts.some((c) => c.severity === "error") ? "error(s)" : "warning(s)";
+            out.push(`${MARKER_PREFIX7} omitted ${runLength} lint line(s) (${severities}: ${parts.join(", ")}${suffix})`);
+            droppedTotal += runLength;
+          } else {
+            for (let j = i; j < runEnd; j++) out.push(lines[j]);
+          }
+          i = runEnd;
+        }
+        const output = out.join("\n");
+        return {
+          output,
+          changed: droppedTotal > 0,
+          note: droppedTotal > 0 ? `dropped ${droppedTotal} lint noise line(s)` : void 0
+        };
+      }
+    };
+  }
+});
+
 // ../core/src/reducers/index.ts
 var init_reducers = __esm({
   "../core/src/reducers/index.ts"() {
@@ -592,6 +661,7 @@ var init_reducers = __esm({
     init_json_output_slim();
     init_file_listing_slim();
     init_cron_output_slim();
+    init_lint_output_slim();
   }
 });
 
@@ -600,6 +670,7 @@ function pickReducer(text) {
   if (GIT_DIFF_RE.test(text)) return gitDiffSlim;
   if (TEST_OUTPUT_RE.test(text)) return testOutputSlim;
   if (CRON_OUTPUT_RE.test(text) && text.length >= 400) return cronOutputSlim;
+  if (LINT_OUTPUT_RE.test(text) && text.length >= 400) return lintOutputSlim;
   if (JSON_RE.test(text) && text.length >= 400) return jsonOutputSlim;
   if (FILE_LISTING_RE.test(text) && text.length >= 400) return fileListingSlim;
   if (LONG_TEXT_RE.test(text) && text.length >= 1e3) return genericTextSlim;
@@ -619,7 +690,7 @@ function reduceAuto(text, minLength = DEFAULT_MIN_LENGTH) {
   }
   return { ...result, reducer: reducer.name };
 }
-var DEFAULT_MIN_LENGTH, GIT_DIFF_RE, TEST_OUTPUT_RE, JSON_RE, FILE_LISTING_RE, CRON_OUTPUT_RE, LONG_TEXT_RE;
+var DEFAULT_MIN_LENGTH, GIT_DIFF_RE, TEST_OUTPUT_RE, JSON_RE, FILE_LISTING_RE, CRON_OUTPUT_RE, LINT_OUTPUT_RE, LONG_TEXT_RE;
 var init_dispatch = __esm({
   "../core/src/dispatch.ts"() {
     "use strict";
@@ -629,12 +700,14 @@ var init_dispatch = __esm({
     init_json_output_slim();
     init_file_listing_slim();
     init_cron_output_slim();
+    init_lint_output_slim();
     DEFAULT_MIN_LENGTH = 400;
     GIT_DIFF_RE = /^diff --git /m;
     TEST_OUTPUT_RE = /\b\d+\s+(passed|failed)\b|^(PASS|FAIL)\s|::\w.*\b(PASSED|FAILED)\b|=+\s*(FAILURES|short test summary)/im;
     JSON_RE = /^\s*[\[{]/m;
     FILE_LISTING_RE = /(?:^total\s+\d+|^[\-bcdlsp][\-r][\-w][\-xs\-][\-r][\-w][\-xs\-][\-r][\-w][\-xs\-]|^\.\/(?:\.|[^.\s])|^\s*(?:├──|└──|│\s+)|^[\w.\/\-]+\.[a-zA-Z]{1,4}:\d+\|)/m;
     CRON_OUTPUT_RE = /^# Cron Job:.*\n[\s\S]*^## Prompt\s*$[\s\S]*^## Response\s*$/m;
+    LINT_OUTPUT_RE = /^[\w.\/\\-]+:\d+:\d+\s+(?:warning|error)\s+[\w@.\/-]+\s/m;
     LONG_TEXT_RE = /^#{1,4}\s.*\n(?:(?!^#{1,4}\s|^diff --git |^```).*\n){5,}/m;
   }
 });
@@ -1166,8 +1239,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 +1548,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 +5133,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 +5385,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 +17219,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 +17472,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 +20866,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 +22627,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 +22671,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 +22689,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,9 +22698,9 @@ 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 os2 from "node:os";
+import fs11 from "node:fs";
+import path15 from "node:path";
+import os4 from "node:os";
 
 // src/doctor.ts
 import fs from "node:fs";
@@ -22870,7 +22970,9 @@ function runInstallOpencode(dir, apply, presetName, installDeps = true) {
       const npm = process.platform === "win32" ? "npm.cmd" : "npm";
       const res = spawnSync(npm, ["install", "--silent"], {
         cwd: path2.dirname(packageJsonPath),
-        encoding: "utf8"
+        encoding: "utf8",
+        input: "",
+        timeout: 12e4
       });
       if (res.error || res.status !== 0) {
         depsInstalled = false;
@@ -22895,6 +22997,7 @@ function runInstallOpencode(dir, apply, presetName, installDeps = true) {
 
 // src/install-codex.ts
 import fs5 from "node:fs";
+import os from "node:os";
 import path6 from "node:path";
 
 // ../adapter-codex/src/index.ts
@@ -22966,9 +23069,31 @@ function hasHarnessTrimHook(document) {
   const post = hooks?.PostToolUse;
   if (!Array.isArray(post)) return false;
   return post.some(
-    (entry) => Array.isArray(entry?.hooks) && entry.hooks.some((hook) => typeof hook?.command === "string" && hook.command.includes("harnesstrim hook codex"))
+    (entry) => Array.isArray(entry?.hooks) && entry.hooks.some(
+      (hook) => typeof hook?.command === "string" && hook.command.includes("harnesstrim") && hook.command.includes("hook codex")
+    )
   );
 }
+function hasExactHarnessTrimHookCommand(document, command) {
+  const hooks = document.hooks;
+  const post = hooks?.PostToolUse;
+  return Array.isArray(post) && post.some(
+    (entry) => Array.isArray(entry?.hooks) && entry.hooks.some((hook) => hook?.command === command)
+  );
+}
+function replaceHarnessTrimHookCommand(document, command) {
+  const hooks = document.hooks;
+  const post = hooks?.PostToolUse;
+  if (!Array.isArray(post)) return;
+  for (const entry of post) {
+    if (!Array.isArray(entry?.hooks)) continue;
+    for (const hook of entry.hooks) {
+      if (typeof hook?.command === "string" && hook.command.includes("harnesstrim") && hook.command.includes("hook codex")) {
+        hook.command = command;
+      }
+    }
+  }
+}
 function planCodexHookInstall(input) {
   let document = {};
   let action;
@@ -22985,14 +23110,21 @@ function planCodexHookInstall(input) {
       throw new Error(".codex/hooks.json must contain a JSON object; refusing to overwrite it.");
     }
     document = parsed;
-    action = hasHarnessTrimHook(document) ? "present" : "patch";
+    action = hasHarnessTrimHook(document) && (!input.hookCommand || hasExactHarnessTrimHookCommand(document, input.hookCommand)) ? "present" : "patch";
   }
   if (action === "present") {
     return { hooksFile: path3.join(input.projectDir, ".codex", "hooks.json"), action, nextHooks: document };
   }
+  if (hasHarnessTrimHook(document)) {
+    replaceHarnessTrimHookCommand(document, input.hookCommand ?? CODEX_HOOK_COMMAND);
+    return { hooksFile: path3.join(input.projectDir, ".codex", "hooks.json"), action, nextHooks: document };
+  }
   const hooks = { ...document.hooks ?? {} };
   const post = Array.isArray(hooks.PostToolUse) ? [...hooks.PostToolUse] : [];
-  post.push({ matcher: CODEX_HOOK_MATCHER, hooks: [{ type: "command", command: CODEX_HOOK_COMMAND }] });
+  post.push({
+    matcher: CODEX_HOOK_MATCHER,
+    hooks: [{ type: "command", command: input.hookCommand ?? CODEX_HOOK_COMMAND }]
+  });
   hooks.PostToolUse = post;
   return {
     hooksFile: path3.join(input.projectDir, ".codex", "hooks.json"),
@@ -23067,6 +23199,13 @@ function existingSkillNames(dest) {
 }
 
 // src/install-codex.ts
+function resolveCodexHookCommand() {
+  if (process.platform !== "win32") return void 0;
+  const pnpmHome = process.env.PNPM_HOME ?? path6.join(process.env.LOCALAPPDATA ?? path6.join(os.homedir(), "AppData", "Local"), "pnpm");
+  const shim = path6.join(pnpmHome, "harnesstrim.CMD");
+  if (!fs5.existsSync(shim)) return void 0;
+  return `"${shim}" hook codex --metrics .harnesstrim/metrics.jsonl`;
+}
 function readHooksJson(hooksPath) {
   try {
     return fs5.readFileSync(hooksPath, "utf8");
@@ -23100,7 +23239,7 @@ function runInstallCodex(dir, apply, hook = false) {
   });
   const hooksPath = path6.join(dir, ".codex", "hooks.json");
   const hooksJsonContent = hook ? readHooksJson(hooksPath) : null;
-  const hookPlan = hook ? planCodexHookInstall({ projectDir: dir, hooksJsonContent }) : null;
+  const hookPlan = hook ? planCodexHookInstall({ projectDir: dir, hooksJsonContent, hookCommand: resolveCodexHookCommand() }) : null;
   const copied = [];
   let applied = false;
   if (apply) {
@@ -23125,7 +23264,8 @@ function runInstallCodexGlobalHook(codexHome, apply) {
     // The planner expects the directory that contains .codex; for a user-level config
     // the Codex home is itself that directory, so add its parent and use a normal path.
     projectDir: path6.dirname(codexHome),
-    hooksJsonContent: readHooksJson(hooksPath)
+    hooksJsonContent: readHooksJson(hooksPath),
+    hookCommand: resolveCodexHookCommand()
   });
   return { hookPlan, applied: applyHookPlan(hookPlan, apply) };
 }
@@ -23187,6 +23327,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;
@@ -23218,12 +23371,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) {
@@ -23248,11 +23405,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 = [];
@@ -23267,6 +23432,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 };
@@ -23275,12 +23445,13 @@ function runInstallClaude(dir, apply) {
 // src/install-pi.ts
 import fs7 from "node:fs";
 import path10 from "node:path";
+import os2 from "node:os";
 
 // ../adapter-pi/src/index.ts
 import path9 from "node:path";
 var PI_EXTENSION_NAME = "harnesstrim";
 function planPiInstall(input) {
-  const extensionDest = path9.join(input.installDir, ".pi", "extensions", PI_EXTENSION_NAME);
+  const extensionDest = input.scope === "user" ? path9.join(input.installDir, ".pi", "agent", "extensions", PI_EXTENSION_NAME) : path9.join(input.installDir, ".pi", "extensions", PI_EXTENSION_NAME);
   return {
     extensionDest,
     extensionSource: input.extensionSourceDir,
@@ -23315,16 +23486,18 @@ function markerPresent(dest) {
 }
 function runInstallPi(installDir, apply) {
   const extensionSourceDir = resolvePiExtensionSourceDir();
-  const dest = path10.join(installDir, ".pi", "extensions", "harnesstrim");
+  const scope = path10.resolve(installDir) === path10.resolve(os2.homedir()) ? "user" : "project";
+  const dest = scope === "user" ? path10.join(installDir, ".pi", "agent", "extensions", "harnesstrim") : path10.join(installDir, ".pi", "extensions", "harnesstrim");
   const plan = planPiInstall({
     installDir,
     extensionSourceDir,
     extensionDirExists: dirExists(dest),
-    markerPresent: markerPresent(dest)
+    markerPresent: markerPresent(dest),
+    scope
   });
   const copiedFiles = [];
   let applied = false;
-  if (apply && !plan.alreadyInstalled) {
+  if (apply) {
     fs7.mkdirSync(dest, { recursive: true });
     for (const entry of fs7.readdirSync(extensionSourceDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
@@ -23428,8 +23601,8 @@ function runInstallHermes(installDir, apply) {
 init_src();
 import fs9 from "node:fs";
 import path13 from "node:path";
-import os from "node:os";
-var HERMES_METRICS_PATH = path13.join(os.homedir(), ".hermes", "harnesstrim-metrics.jsonl");
+import os3 from "node:os";
+var HERMES_METRICS_PATH = path13.join(os3.homedir(), ".hermes", "harnesstrim-metrics.jsonl");
 var LOCAL_METRICS_PATH = ".harnesstrim/metrics.jsonl";
 var DEFAULT_METRICS_PATH = fs9.existsSync(HERMES_METRICS_PATH) ? HERMES_METRICS_PATH : LOCAL_METRICS_PATH;
 function loadMetrics(filePath) {
@@ -23445,9 +23618,46 @@ function loadMetrics(filePath) {
   return { path: filePath, found: true, summary: summarize(parseTrimEvents(raw)) };
 }
 
+// package.json
+var package_default = {
+  name: "harnesstrim",
+  version: "0.0.6",
+  description: "HarnessTrim CLI: doctor (diagnose token waste), install adapters, run benchmarks.",
+  license: "MIT",
+  type: "module",
+  bin: {
+    harnesstrim: "./dist/cli.mjs"
+  },
+  files: [
+    "dist",
+    "assets"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  devDependencies: {
+    "@harnesstrim/adapter-claude": "workspace:*",
+    "@harnesstrim/adapter-codex": "workspace:*",
+    "@harnesstrim/adapter-hermes": "workspace:*",
+    "@harnesstrim/adapter-pi": "workspace:*",
+    "@harnesstrim/benchmarks": "workspace:*",
+    "@harnesstrim/core": "workspace:*",
+    "@harnesstrim/mcp": "workspace:*",
+    esbuild: "^0.25.0"
+  },
+  scripts: {
+    build: "node build.mjs",
+    prepare: "node build.mjs",
+    prepack: "node build.mjs",
+    test: 'node --test "src/**/*.test.ts"',
+    typecheck: "tsc -p tsconfig.json"
+  }
+};
+
 // src/reduce.ts
 init_src();
 async function readStdin() {
+  if (process.stdin.isTTY) return "";
   const chunks = [];
   for await (const chunk of process.stdin) {
     chunks.push(chunk);
@@ -23619,7 +23829,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");
 }
@@ -23723,10 +23945,13 @@ 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
+  harnesstrim --version                    Print the installed version
 
 Notes:
   - install is dry-run by default; nothing is written without --apply.
@@ -23738,6 +23963,7 @@ async function main(argv) {
     allowPositionals: true,
     options: {
       help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
       apply: { type: "boolean" },
       preset: { type: "string" },
       stats: { type: "boolean" },
@@ -23749,6 +23975,10 @@ async function main(argv) {
     }
   });
   const [command, ...rest] = positionals;
+  if (values.version) {
+    console.log(package_default.version);
+    return 0;
+  }
   if (values.help || !command) {
     console.log(HELP);
     return 0;
@@ -23761,7 +23991,7 @@ async function main(argv) {
     }
     case "install": {
       const target = rest[0];
-      const dir = rest[1] ?? (target === "hermes" ? os2.homedir() : process.cwd());
+      const dir = rest[1] ?? (target === "hermes" ? os4.homedir() : process.cwd());
       const apply = values.apply === true;
       if (target === "opencode") {
         const result = runInstallOpencode(dir, apply, values.preset);
@@ -23774,7 +24004,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(os4.homedir(), ".codex"), apply), apply));
           return 0;
         }
         console.log(renderCodexInstall(runInstallCodex(dir, apply, values.hook === true), apply));
@@ -23806,9 +24036,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"
           );
@@ -23817,7 +24047,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"
           );
@@ -23846,8 +24076,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": {
@@ -23860,6 +24090,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}`);
@@ -23868,7 +24116,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.4",
+  "version": "0.0.6",
   "description": "HarnessTrim CLI: doctor (diagnose token waste), install adapters, run benchmarks.",
   "license": "MIT",
   "type": "module",
@@ -15,20 +15,18 @@
     "access": "public"
   },
   "devDependencies": {
-    "@harnesstrim/adapter-claude": "workspace:*",
-    "@harnesstrim/adapter-codex": "workspace:*",
-    "@harnesstrim/adapter-hermes": "workspace:*",
-    "@harnesstrim/adapter-pi": "workspace:*",
-    "@harnesstrim/benchmarks": "workspace:*",
-    "@harnesstrim/core": "workspace:*",
-    "@harnesstrim/mcp": "workspace:*",
-    "esbuild": "^0.25.0"
+    "esbuild": "^0.25.0",
+    "@harnesstrim/adapter-claude": "0.0.1",
+    "@harnesstrim/adapter-hermes": "0.0.1",
+    "@harnesstrim/core": "0.0.2",
+    "@harnesstrim/adapter-codex": "0.0.1",
+    "@harnesstrim/benchmarks": "0.0.1",
+    "@harnesstrim/mcp": "0.0.1",
+    "@harnesstrim/adapter-pi": "0.0.1"
   },
   "scripts": {
     "build": "node build.mjs",
-    "prepare": "node build.mjs",
-    "prepack": "node build.mjs",
     "test": "node --test \"src/**/*.test.ts\"",
     "typecheck": "tsc -p tsconfig.json"
   }
-}
+}