harnesstrim 0.0.5 → 0.0.7

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,17 +700,34 @@ 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;
   }
 });
 
 // ../core/src/metrics/trim-event.ts
+import { randomUUID } from "node:crypto";
+function makeTrimEvent(partial2) {
+  return {
+    schemaVersion: TRIM_EVENT_SCHEMA_VERSION,
+    eventId: randomUUID(),
+    ts: partial2.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    harness: partial2.harness,
+    tool: partial2.tool,
+    reducer: partial2.reducer,
+    beforeChars: partial2.beforeChars,
+    afterChars: partial2.afterChars,
+    beforeTokens: partial2.beforeTokens ?? null,
+    afterTokens: partial2.afterTokens ?? null
+  };
+}
 function pct(before, after) {
   if (before === 0) return 0;
   return Math.round((1 - after / before) * 1e3) / 10;
@@ -680,7 +768,7 @@ function parseTrimEvents(jsonl) {
     } catch {
       continue;
     }
-    if (isTrimEvent(parsed)) out.push(parsed);
+    if (isTrimEvent(parsed)) out.push(normalize(parsed));
   }
   return out;
 }
@@ -689,9 +777,25 @@ function isTrimEvent(value) {
   const v = value;
   return typeof v.beforeChars === "number" && typeof v.afterChars === "number" && typeof v.tool === "string" && (typeof v.reducer === "string" || v.reducer === null);
 }
+function normalize(v) {
+  return {
+    schemaVersion: typeof v.schemaVersion === "number" ? v.schemaVersion : 0,
+    eventId: typeof v.eventId === "string" ? v.eventId : "",
+    ts: v.ts,
+    harness: v.harness,
+    tool: v.tool,
+    reducer: v.reducer,
+    beforeChars: v.beforeChars,
+    afterChars: v.afterChars,
+    beforeTokens: typeof v.beforeTokens === "number" ? v.beforeTokens : null,
+    afterTokens: typeof v.afterTokens === "number" ? v.afterTokens : null
+  };
+}
+var TRIM_EVENT_SCHEMA_VERSION;
 var init_trim_event = __esm({
   "../core/src/metrics/trim-event.ts"() {
     "use strict";
+    TRIM_EVENT_SCHEMA_VERSION = 1;
   }
 });
 
@@ -1166,8 +1270,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path16, errorMaps, issueData } = params;
-      const fullPath = [...path16, ...issueData.path || []];
+      const { data, path: path17, errorMaps, issueData } = params;
+      const fullPath = [...path17, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -1475,11 +1579,11 @@ var init_types2 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path16, key) {
+      constructor(parent, value, path17, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path16;
+        this._path = path17;
         this._key = key;
       }
       get path() {
@@ -5060,10 +5164,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path16) {
-  if (!path16)
+function getElementAtPath(obj, path17) {
+  if (!path17)
     return obj;
-  return path16.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5312,11 +5416,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path16, issues) {
+function prefixIssues(path17, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path16);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -16152,8 +16256,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize) {
-      if (normalize !== false)
+    function getFullPath(resolver, id = "", normalize2) {
+      if (normalize2 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -17146,8 +17250,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path16) {
-      let input = path16;
+    function removeDotSegments(path17) {
+      let input = path17;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -17399,8 +17503,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path16, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path16 && path16 !== "/" ? path16 : void 0;
+        const [path17, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path17 && path17 !== "/" ? path17 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -17549,7 +17653,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize(uri, options) {
+    function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         normalizeString(uri, options);
@@ -17816,7 +17920,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize,
+      normalize: normalize2,
       resolve,
       resolveComponent,
       equal,
@@ -20793,12 +20897,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs12, exportName) {
+    function addFormats(ajv, list, fs13, 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, fs12[f]);
+        ajv.addFormat(f, fs13[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -22559,14 +22663,14 @@ __export(server_exports, {
   runReduceTool: () => runReduceTool,
   startStdioServer: () => startStdioServer
 });
-import fs10 from "node:fs";
-import path14 from "node:path";
+import fs11 from "node:fs";
+import path15 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");
+      const p = path15.resolve(metricsPath);
+      fs11.mkdirSync(path15.dirname(p), { recursive: true });
+      fs11.appendFileSync(p, JSON.stringify(event) + "\n");
     } catch {
     }
   };
@@ -22574,14 +22678,15 @@ function createFileSink(metricsPath) {
 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
-    });
+    sink(
+      makeTrimEvent({
+        harness: "mcp",
+        tool: "reduce",
+        reducer: result.reducer,
+        beforeChars: text.length,
+        afterChars: result.output.length
+      })
+    );
   }
   return { content: [{ type: "text", text: result.output }] };
 }
@@ -22625,9 +22730,9 @@ var init_server3 = __esm({
 // src/cli.ts
 init_src();
 import { parseArgs } from "node:util";
-import fs11 from "node:fs";
-import path15 from "node:path";
-import os2 from "node:os";
+import fs12 from "node:fs";
+import path16 from "node:path";
+import os4 from "node:os";
 
 // src/doctor.ts
 import fs from "node:fs";
@@ -22857,7 +22962,7 @@ function planOpencodeInstall(input) {
   const changed = wrapperChanged || pkgChanged || opencodeChanged;
   return { wrapperContent, packageJsonContent, opencodeJsonContent, alreadyInstalled, changed };
 }
-function runInstallOpencode(dir, apply, presetName, installDeps = true) {
+function runInstallOpencode(dir, apply, presetName, installDeps = true, options = {}) {
   let preset;
   let adapterConfig = { ...DEFAULT_OPENCODE_ADAPTER_CONFIG };
   if (presetName) {
@@ -22865,19 +22970,22 @@ function runInstallOpencode(dir, apply, presetName, installDeps = true) {
     if (!preset) throw new Error(`Unknown preset: ${presetName}`);
     adapterConfig = { ...adapterConfig, ...preset.adapter };
   }
+  if (options.mode !== void 0) adapterConfig.mode = options.mode;
+  if (options.minLength !== void 0) adapterConfig.minLength = options.minLength;
+  if (options.tools !== void 0) adapterConfig.toolFilter = options.tools;
   const wrapperPath = path2.join(dir, WRAPPER_REL);
   const packageJsonPath = path2.join(dir, PKG_REL);
   const opencodeJsonPath = path2.join(dir, OPENCODE_JSON);
-  const readOrNull = (p) => {
+  const readOrNull2 = (p) => {
     try {
       return fs2.readFileSync(p, "utf8");
     } catch {
       return null;
     }
   };
-  const existingWrapper = readOrNull(wrapperPath);
-  const existingPackageJson = readOrNull(packageJsonPath);
-  const existingOpencodeJson = readOrNull(opencodeJsonPath);
+  const existingWrapper = readOrNull2(wrapperPath);
+  const existingPackageJson = readOrNull2(packageJsonPath);
+  const existingOpencodeJson = readOrNull2(opencodeJsonPath);
   const plan = planOpencodeInstall({
     existingWrapper,
     existingPackageJson,
@@ -22897,7 +23005,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;
@@ -22922,6 +23032,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
@@ -22993,9 +23104,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;
@@ -23012,14 +23145,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"),
@@ -23028,6 +23168,7 @@ function planCodexHookInstall(input) {
   };
 }
 function planCodexInstall(input) {
+  const includeInstructions = input.includeInstructions ?? true;
   const skillsDest = path3.join(input.projectDir, ".codex", "skills");
   const existing = new Set(input.existingSkillNames);
   const skills = input.skillNames.map((name) => ({
@@ -23037,7 +23178,9 @@ function planCodexInstall(input) {
     present: existing.has(name)
   }));
   let instructionsAction;
-  if (input.agentsMdContent === null) {
+  if (!includeInstructions) {
+    instructionsAction = "skip";
+  } else if (input.agentsMdContent === null) {
     instructionsAction = "create";
   } else if (input.agentsMdContent.includes(HARNESSTRIM_MARKER)) {
     instructionsAction = "present";
@@ -23049,7 +23192,8 @@ function planCodexInstall(input) {
     skills,
     instructionsFile: path3.join(input.projectDir, "AGENTS.md"),
     instructionsAction,
-    instructionsSnippet: REDUCE_INSTRUCTION_SNIPPET
+    instructionsSnippet: REDUCE_INSTRUCTION_SNIPPET,
+    changed: skills.some((s) => !s.present) || instructionsAction !== "present" && instructionsAction !== "skip"
   };
 }
 
@@ -23094,6 +23238,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");
@@ -23107,7 +23258,7 @@ function applyHookPlan(plan, apply) {
   fs5.writeFileSync(plan.hooksFile, JSON.stringify(plan.nextHooks, null, 2) + "\n");
   return true;
 }
-function runInstallCodex(dir, apply, hook = false) {
+function runInstallCodex(dir, apply, hook = false, options = {}) {
   const skillsSourceDir = resolveSkillsSourceDir();
   const skillNames = listShippedSkills(skillsSourceDir);
   const skillsDest = path6.join(dir, ".codex", "skills");
@@ -23123,14 +23274,16 @@ function runInstallCodex(dir, apply, hook = false) {
     skillsSourceDir,
     skillNames,
     agentsMdContent,
-    existingSkillNames: existingSkillNames(skillsDest)
+    existingSkillNames: existingSkillNames(skillsDest),
+    includeInstructions: options.includeInstructions
   });
   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 = [];
+  const hookChanged = hookPlan !== null && hookPlan.action !== "present";
   let applied = false;
-  if (apply) {
+  if (apply && (plan.changed || hookChanged)) {
     for (const skill of plan.skills) {
       if (skill.present) continue;
       fs5.cpSync(skill.from, skill.to, { recursive: true });
@@ -23141,7 +23294,7 @@ function runInstallCodex(dir, apply, hook = false) {
     } else if (plan.instructionsAction === "append") {
       fs5.appendFileSync(plan.instructionsFile, "\n\n" + plan.instructionsSnippet + "\n");
     }
-    if (hookPlan) applyHookPlan(hookPlan, true);
+    if (hookPlan && hookChanged) applyHookPlan(hookPlan, true);
     applied = true;
   }
   return { plan, hookPlan, applied, copied };
@@ -23152,7 +23305,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) };
 }
@@ -23236,6 +23390,8 @@ function hasHarnessTrimHook2(settings) {
   );
 }
 function planClaudeInstall(input) {
+  const includeHook = input.includeHook ?? true;
+  const includeInstructions = input.includeInstructions ?? true;
   const skillsDest = path7.join(input.projectDir, ".claude", "skills");
   const existing = new Set(input.existingSkillNames);
   const skills = input.skillNames.map((name) => ({
@@ -23257,8 +23413,12 @@ 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";
+  if (!includeHook) {
+    action = "skip";
+    settings = input.settingsJsonContent === null ? {} : settings;
+  }
+  const nextSettings = action === "present" || action === "skip" ? settings : addHook(settings);
+  const instructionsAction = !includeInstructions ? "skip" : input.claudeMdContent === null ? "create" : input.claudeMdContent.includes(HARNESSTRIM_MARKER2) ? "present" : "append";
   return {
     skillsDest,
     skills,
@@ -23267,7 +23427,8 @@ function planClaudeInstall(input) {
     nextSettings,
     instructionsFile: path7.join(input.projectDir, "CLAUDE.md"),
     instructionsAction,
-    instructionsSnippet: REDUCE_INSTRUCTION_SNIPPET2
+    instructionsSnippet: REDUCE_INSTRUCTION_SNIPPET2,
+    changed: skills.some((s) => !s.present) || action !== "present" && action !== "skip" || instructionsAction !== "present" && instructionsAction !== "skip"
   };
 }
 function addHook(settings) {
@@ -23281,7 +23442,7 @@ function addHook(settings) {
 }
 
 // src/install-claude.ts
-function runInstallClaude(dir, apply) {
+function runInstallClaude(dir, apply, options = {}) {
   const skillsSourceDir = resolveSkillsSourceDir();
   const skillNames = listShippedSkills(skillsSourceDir);
   const skillsDest = path8.join(dir, ".claude", "skills");
@@ -23305,17 +23466,19 @@ function runInstallClaude(dir, apply) {
     skillNames,
     settingsJsonContent,
     claudeMdContent,
-    existingSkillNames: existingSkillNames(skillsDest)
+    existingSkillNames: existingSkillNames(skillsDest),
+    includeHook: options.includeHook,
+    includeInstructions: options.includeInstructions
   });
   const copied = [];
   let applied = false;
-  if (apply) {
+  if (apply && plan.changed) {
     for (const skill of plan.skills) {
       if (skill.present) continue;
       fs6.cpSync(skill.from, skill.to, { recursive: true });
       copied.push(skill.name);
     }
-    if (plan.settingsAction !== "present") {
+    if (plan.settingsAction !== "present" && plan.settingsAction !== "skip") {
       fs6.mkdirSync(path8.dirname(plan.settingsFile), { recursive: true });
       fs6.writeFileSync(plan.settingsFile, JSON.stringify(plan.nextSettings, null, 2) + "\n");
     }
@@ -23332,12 +23495,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,
@@ -23372,23 +23536,29 @@ 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()) {
-        fs7.copyFileSync(path10.join(extensionSourceDir, entry.name), path10.join(dest, entry.name));
-        copiedFiles.push(entry.name);
+    const sourceFiles = fs7.readdirSync(extensionSourceDir, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name);
+    for (const existing of fs7.readdirSync(dest)) {
+      if (existing !== ".installed" && !sourceFiles.includes(existing)) {
+        fs7.rmSync(path10.join(dest, existing), { recursive: true, force: true });
       }
     }
+    for (const entry of sourceFiles) {
+      fs7.copyFileSync(path10.join(extensionSourceDir, entry), path10.join(dest, entry));
+      copiedFiles.push(entry);
+    }
     fs7.writeFileSync(path10.join(dest, ".installed"), markerFileContent());
     copiedFiles.push(".installed");
     applied = true;
@@ -23485,8 +23655,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) {
@@ -23502,9 +23672,46 @@ function loadMetrics(filePath) {
   return { path: filePath, found: true, summary: summarize(parseTrimEvents(raw)) };
 }
 
+// package.json
+var package_default = {
+  name: "harnesstrim",
+  version: "0.0.7",
+  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);
@@ -23516,6 +23723,324 @@ function reducePipe(input, minLength) {
   return { ...result, beforeChars: input.length, afterChars: result.output.length };
 }
 
+// src/capabilities.ts
+var CAPABILITIES = {
+  harnesses: {
+    opencode: {
+      adapter: "@harnesstrim/adapter-opencode",
+      surfaces: [
+        "tool.execute.after \u2014 slims noisy tool output in place before it enters context",
+        "experimental.session.compacting \u2014 injects compaction-handoff guidance"
+      ],
+      narrowing: [
+        { flag: "--mode active|dryrun|off", produces: "bake the reduction mode into the generated wrapper (active/dryrun/off)" },
+        { flag: "--min-length <n>", produces: "leave tool outputs shorter than n chars untouched (overrides preset)" },
+        { flag: "--tools <name,...>", produces: "confine reduction to a subset of tool families (e.g. bash,read)" },
+        { flag: "--preset <name>", produces: "bake a policy preset's adapter config into the wrapper" }
+      ],
+      writeSet: [
+        ".opencode/plugin/harnesstrim.ts",
+        ".opencode/package.json",
+        "opencode.json (cleans a stale adapter entry, never adds one)"
+      ]
+    },
+    codex: {
+      adapter: "@harnesstrim/adapter-codex",
+      surfaces: [
+        "PostToolUse Bash hook \u2014 deterministic reduction of simple Bash output (optional --hook)",
+        "AGENTS.md reduce-pipe instruction \u2014 model pipes noisy output through `harnesstrim reduce`",
+        "MCP reduce tool \u2014 deterministic, instruction-free reduction (separate `harnesstrim mcp`)"
+      ],
+      narrowing: [
+        { flag: "--no-instructions", produces: "skills only \u2014 no AGENTS.md reduce-pipe instruction" },
+        { flag: "--hook", produces: "also install the experimental Bash PostToolUse hook" },
+        { flag: "--global", produces: "install the hook once in ~/.codex (with --hook)" }
+      ],
+      writeSet: [".codex/skills/", "AGENTS.md (marker-guarded snippet)", ".codex/hooks.json (with --hook)"]
+    },
+    claude: {
+      adapter: "@harnesstrim/adapter-claude",
+      surfaces: [
+        "PostToolUse Bash hook \u2014 spec-correct updatedToolOutput (not honored by Claude Code 2.1.37\u20132.1.212)",
+        "CLAUDE.md reduce-pipe instruction \u2014 the effective reduction path on current Claude Code"
+      ],
+      narrowing: [
+        { flag: "--no-hook", produces: "skills only \u2014 no PostToolUse hook in .claude/settings.json" },
+        { flag: "--no-instructions", produces: "skills only \u2014 no CLAUDE.md reduce-pipe instruction" }
+      ],
+      writeSet: [".claude/skills/", ".claude/settings.json", "CLAUDE.md (marker-guarded snippet)"]
+    },
+    hermes: {
+      adapter: "@harnesstrim/adapter-hermes",
+      surfaces: ["transform_tool_result \u2014 deterministic reduction before the result enters context"],
+      narrowing: [],
+      writeSet: [".hermes/plugins/harnesstrim/ (incl. .installed marker)"]
+    },
+    pi: {
+      adapter: "@harnesstrim/adapter-pi",
+      surfaces: ["tool_result \u2014 deterministic reduction of text chunks in structured results"],
+      narrowing: [],
+      writeSet: [".pi/extensions/harnesstrim/ or .pi/agent/extensions/harnesstrim/ (incl. .installed marker)"]
+    }
+  }
+};
+function getCapabilities(version2) {
+  return { version: version2, ...CAPABILITIES };
+}
+
+// src/uninstall.ts
+import fs10 from "node:fs";
+import path14 from "node:path";
+function readOrNull(p) {
+  try {
+    return fs10.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+function stripMarkedRegion(content, marker) {
+  const begin = `<!-- ${marker} -->`;
+  const end = "<!-- harnesstrim:end -->";
+  const start = content.indexOf(begin);
+  if (start === -1) return content;
+  const endIdx = content.indexOf(end, start);
+  if (endIdx === -1) return content;
+  const after = content.slice(endIdx + end.length);
+  const before = content.slice(0, start).replace(/\s+$/, "");
+  const next = (before + "\n" + after.replace(/^\s+/, "")).replace(/\n{3,}/g, "\n\n").trim();
+  return next;
+}
+function stripHookEntries(settings) {
+  const hooks = settings.hooks;
+  if (!hooks || !Array.isArray(hooks.PostToolUse)) return { next: settings, removed: false };
+  const post = hooks.PostToolUse;
+  const kept = post.filter((entry) => {
+    const hooksArr = entry.hooks;
+    if (!Array.isArray(hooksArr)) return true;
+    return !hooksArr.some((h) => typeof h.command === "string" && h.command.includes("harnesstrim hook"));
+  });
+  if (kept.length === post.length) return { next: settings, removed: false };
+  const nextHooks = { ...hooks };
+  nextHooks.PostToolUse = kept;
+  const next = { ...settings, hooks: nextHooks };
+  return { next, removed: true };
+}
+function isSkillDir(pathName) {
+  try {
+    return fs10.statSync(pathName).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function markerPresent3(dest) {
+  try {
+    return fs10.statSync(path14.join(dest, ".installed")).isFile();
+  } catch {
+    return false;
+  }
+}
+function skillRemovalActions(dir, destRel) {
+  const sourceDir = resolveSkillsSourceDir();
+  const shipped = listShippedSkills(sourceDir);
+  const dest = path14.join(dir, destRel);
+  const actions = [];
+  for (const name of shipped) {
+    const skillPath = path14.join(dest, name);
+    if (isSkillDir(skillPath)) {
+      actions.push({ type: "remove-dir", path: skillPath, note: `skill directory installed by HarnessTrim` });
+    }
+  }
+  if (actions.length > 0 && isSkillDir(dest)) {
+    const remaining = fs10.readdirSync(dest).filter((name) => !shipped.includes(name));
+    if (remaining.length === 0) {
+      actions.push({ type: "remove-dir", path: dest, note: "empty skills directory left by HarnessTrim" });
+    }
+  }
+  return actions;
+}
+function planClaudeUninstall(dir) {
+  const actions = [...skillRemovalActions(dir, ".claude/skills")];
+  const settingsPath = path14.join(dir, ".claude", "settings.json");
+  const settingsContent = readOrNull(settingsPath);
+  if (settingsContent !== null) {
+    try {
+      const parsed = JSON.parse(settingsContent);
+      const { next, removed } = stripHookEntries(parsed);
+      if (removed) {
+        actions.push({
+          type: Object.keys(next).length === 0 ? "remove-file" : "write",
+          path: settingsPath,
+          note: "remove the HarnessTrim PostToolUse hook"
+        });
+      }
+    } catch {
+    }
+  }
+  const claudeMdPath = path14.join(dir, "CLAUDE.md");
+  const claudeMd = readOrNull(claudeMdPath);
+  if (claudeMd !== null && claudeMd.includes(HARNESSTRIM_MARKER2)) {
+    const next = stripMarkedRegion(claudeMd, HARNESSTRIM_MARKER2);
+    if (next !== null && next !== claudeMd) {
+      actions.push({
+        type: next.length === 0 ? "remove-file" : "write",
+        path: claudeMdPath,
+        note: "remove the marker-guarded HarnessTrim instruction"
+      });
+    }
+  }
+  return { harness: "claude", dir, changed: actions.length > 0, actions };
+}
+function planCodexUninstall(dir) {
+  const actions = [...skillRemovalActions(dir, ".codex/skills")];
+  const agentsPath = path14.join(dir, "AGENTS.md");
+  const agents = readOrNull(agentsPath);
+  if (agents !== null && agents.includes(HARNESSTRIM_MARKER)) {
+    const next = stripMarkedRegion(agents, HARNESSTRIM_MARKER);
+    if (next !== null && next !== agents) {
+      actions.push({
+        type: next.length === 0 ? "remove-file" : "write",
+        path: agentsPath,
+        note: "remove the marker-guarded HarnessTrim instruction"
+      });
+    }
+  }
+  const hooksPath = path14.join(dir, ".codex", "hooks.json");
+  const hooksContent = readOrNull(hooksPath);
+  if (hooksContent !== null) {
+    try {
+      const parsed = JSON.parse(hooksContent);
+      const { next, removed } = stripHookEntries(parsed);
+      if (removed) {
+        actions.push({
+          type: Object.keys(next).length === 0 ? "remove-file" : "write",
+          path: hooksPath,
+          note: "remove the HarnessTrim PostToolUse hook"
+        });
+      }
+    } catch {
+    }
+  }
+  return { harness: "codex", dir, changed: actions.length > 0, actions };
+}
+function planOpencodeUninstall(dir) {
+  const actions = [];
+  const wrapperPath = path14.join(dir, ".opencode", "plugin", "harnesstrim.ts");
+  const wrapper = readOrNull(wrapperPath);
+  if (wrapper !== null && wrapper.includes(OPENCODE_PLUGIN_NAME)) {
+    actions.push({ type: "remove-file", path: wrapperPath, note: "HarnessTrim plugin wrapper" });
+    const pluginDir = path14.join(dir, ".opencode", "plugin");
+    if (fs10.existsSync(pluginDir)) {
+      const entries = fs10.readdirSync(pluginDir).filter((name) => name !== "harnesstrim.ts");
+      if (entries.length === 0) {
+        actions.push({ type: "remove-dir", path: pluginDir, note: "empty plugin directory left by HarnessTrim" });
+      }
+    }
+  }
+  const pkgPath = path14.join(dir, ".opencode", "package.json");
+  const pkgContent = readOrNull(pkgPath);
+  if (pkgContent !== null) {
+    try {
+      const parsed = JSON.parse(pkgContent);
+      const deps = parsed.dependencies;
+      if (deps && typeof deps[OPENCODE_PLUGIN_NAME] === "string") {
+        const nextDeps = { ...deps };
+        delete nextDeps[OPENCODE_PLUGIN_NAME];
+        const next = { ...parsed, dependencies: nextDeps };
+        const onlyOurDep = Object.keys(nextDeps).length === 0 && Object.keys(parsed).length <= 1;
+        actions.push({
+          type: onlyOurDep ? "remove-file" : "write",
+          path: pkgPath,
+          note: onlyOurDep ? "remove .opencode/package.json (only declared the adapter)" : "drop the @harnesstrim/adapter-opencode dependency"
+        });
+      }
+    } catch {
+    }
+  }
+  return { harness: "opencode", dir, changed: actions.length > 0, actions };
+}
+function planHermesUninstall(dir) {
+  const pluginDest = path14.join(dir, ".hermes", "plugins", "harnesstrim");
+  const actions = [];
+  if (markerPresent3(pluginDest)) {
+    actions.push({ type: "remove-dir", path: pluginDest, note: "Hermes plugin installed by HarnessTrim" });
+  }
+  return { harness: "hermes", dir, changed: actions.length > 0, actions };
+}
+function planPiUninstall(dir) {
+  const scope = path14.resolve(dir) === path14.resolve(process.env.HOME ?? "") ? "user" : "project";
+  const dest = scope === "user" ? path14.join(dir, ".pi", "agent", "extensions", "harnesstrim") : path14.join(dir, ".pi", "extensions", "harnesstrim");
+  const actions = [];
+  if (markerPresent3(dest)) {
+    actions.push({ type: "remove-dir", path: dest, note: "Pi extension installed by HarnessTrim" });
+  }
+  return { harness: "pi", dir, changed: actions.length > 0, actions };
+}
+function planUninstall(harness, dir) {
+  switch (harness) {
+    case "claude":
+      return planClaudeUninstall(dir);
+    case "codex":
+      return planCodexUninstall(dir);
+    case "opencode":
+      return planOpencodeUninstall(dir);
+    case "hermes":
+      return planHermesUninstall(dir);
+    case "pi":
+      return planPiUninstall(dir);
+    default:
+      throw new Error(`Unknown uninstall target: ${harness}. Supported: opencode, codex, claude, hermes, pi.`);
+  }
+}
+function runUninstall(harness, dir, apply) {
+  const plan = planUninstall(harness, dir);
+  if (!apply || !plan.changed) return { ...plan, applied: false };
+  for (const action of plan.actions) {
+    switch (action.type) {
+      case "remove-file":
+        fs10.rmSync(action.path, { force: true });
+        break;
+      case "remove-dir":
+        fs10.rmSync(action.path, { recursive: true, force: true });
+        break;
+      case "write": {
+        if (action.path.endsWith("settings.json") || action.path.endsWith("hooks.json")) {
+          const raw = readOrNull(action.path);
+          if (raw !== null) {
+            try {
+              const parsed = JSON.parse(raw);
+              const { next } = stripHookEntries(parsed);
+              fs10.writeFileSync(action.path, JSON.stringify(next, null, 2) + "\n");
+            } catch {
+            }
+          }
+        } else if (action.path.endsWith(path14.join(".opencode", "package.json"))) {
+          const raw = readOrNull(action.path);
+          if (raw !== null) {
+            try {
+              const parsed = JSON.parse(raw);
+              const deps = { ...parsed.dependencies ?? {} };
+              delete deps[OPENCODE_PLUGIN_NAME];
+              fs10.writeFileSync(action.path, JSON.stringify({ ...parsed, dependencies: deps }, null, 2) + "\n");
+            } catch {
+            }
+          }
+        } else {
+          const marker = action.path.endsWith("CLAUDE.md") ? HARNESSTRIM_MARKER2 : HARNESSTRIM_MARKER;
+          const raw = readOrNull(action.path);
+          if (raw !== null) {
+            const next = stripMarkedRegion(raw, marker);
+            if (next !== null) fs10.writeFileSync(action.path, next + "\n");
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return { ...plan, applied: true };
+}
+
 // src/render.ts
 var ICON = { warn: "!", info: "i", ok: "+" };
 function renderDoctor(report) {
@@ -23614,7 +24139,7 @@ function renderCodexInstall(result, apply) {
     lines.push(`  ${s.name.padEnd(18)} ${state}`);
   }
   lines.push("");
-  const instr = plan.instructionsAction === "present" ? "AGENTS.md already contains the HarnessTrim instruction (no change)." : plan.instructionsAction === "create" ? `AGENTS.md ${apply ? "created" : "would be created"} with the reduce-pipe instruction.` : `Reduce-pipe instruction ${apply ? "appended" : "would be appended"} to AGENTS.md.`;
+  const instr = plan.instructionsAction === "skip" ? "AGENTS.md instruction skipped (--no-instructions); skills only." : plan.instructionsAction === "present" ? "AGENTS.md already contains the HarnessTrim instruction (no change)." : plan.instructionsAction === "create" ? `AGENTS.md ${apply ? "created" : "would be created"} with the reduce-pipe instruction.` : `Reduce-pipe instruction ${apply ? "appended" : "would be appended"} to AGENTS.md.`;
   lines.push(instr);
   if (result.hookPlan) {
     lines.push("");
@@ -23663,7 +24188,9 @@ function renderClaudeInstall(result, apply) {
     lines.push(`  ${s.name.padEnd(18)} ${state}`);
   }
   lines.push("");
-  if (plan.settingsAction === "present") {
+  if (plan.settingsAction === "skip") {
+    lines.push(`${plan.settingsFile}: PostToolUse hook skipped (--no-hook); skills only.`);
+  } else if (plan.settingsAction === "present") {
     lines.push(`${plan.settingsFile}: PostToolUse reducer hook already present (no change).`);
   } else {
     lines.push(
@@ -23676,7 +24203,9 @@ function renderClaudeInstall(result, apply) {
     }
   }
   lines.push("");
-  if (plan.instructionsAction === "present") {
+  if (plan.instructionsAction === "skip") {
+    lines.push(`${plan.instructionsFile}: reduce-pipe instruction skipped (--no-instructions); skills only.`);
+  } else if (plan.instructionsAction === "present") {
     lines.push(`${plan.instructionsFile}: reduce-pipe instruction already present (no change).`);
   } else {
     lines.push(
@@ -23731,7 +24260,7 @@ function renderPiInstall(result, apply) {
       lines.push(`  Copied: ${result.copiedFiles.join(", ")}`);
     } else {
       lines.push(`  Source: ${plan.extensionSource}`);
-      lines.push("  (harnesstrim.ts + .installed marker)");
+      lines.push("  (index.ts + .installed marker)");
     }
     lines.push("");
     lines.push("The extension hooks Pi's `tool_result` and needs `harnesstrim` on PATH.");
@@ -23766,6 +24295,192 @@ Enable it in the adapter (telemetry: true) to record reductions.`;
   }
   return lines.join("\n");
 }
+function renderUninstall(result, apply) {
+  const lines = [`${apply ? "Uninstalled" : "Would uninstall"} ${result.harness} integration`, ""];
+  if (!result.changed) {
+    lines.push("Nothing to remove \u2014 no HarnessTrim files found in the install set.");
+    return lines.join("\n");
+  }
+  for (const action of result.actions) {
+    const verb = action.type === "remove-file" || action.type === "remove-dir" ? apply ? "removed" : "remove" : action.type === "write" ? apply ? "updated" : "update" : "clean";
+    lines.push(`  ${verb.padEnd(8)} ${action.path}`);
+    if (action.note) lines.push(`             (${action.note})`);
+  }
+  if (!apply) {
+    lines.push("");
+    lines.push("Dry run \u2014 nothing written. Re-run with `--apply`.");
+  }
+  lines.push("");
+  lines.push("Only files HarnessTrim wrote are touched; marker-guarded regions and your");
+  lines.push("other settings/hook entries are preserved.");
+  return lines.join("\n");
+}
+
+// src/json.ts
+function doctorJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function metricsJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+function opencodeInstallJson(result, apply) {
+  const actions = [];
+  if (result.changed) {
+    actions.push(
+      {
+        type: "write",
+        path: result.wrapperPath,
+        note: "local plugin wrapper with the adapter options"
+      },
+      {
+        type: "write",
+        path: result.packageJsonPath,
+        note: "declares @harnesstrim/adapter-opencode"
+      }
+    );
+    if (result.opencodeJsonContent !== null) {
+      actions.push({
+        type: "clean",
+        path: result.opencodeJsonPath,
+        note: "remove the stale adapter entry (options live in the wrapper now)"
+      });
+    }
+  }
+  return {
+    harness: "opencode",
+    dryRun: !apply,
+    changed: result.changed,
+    alreadyInstalled: result.alreadyInstalled,
+    applied: result.applied,
+    actions,
+    details: {
+      preset: result.preset?.name ?? null,
+      depsInstalled: result.depsInstalled,
+      depsMessage: result.depsMessage ?? null
+    }
+  };
+}
+function codexInstallJson(result, apply) {
+  const actions = result.plan.skills.map((s) => ({
+    type: s.present ? "none" : "copy",
+    path: s.to,
+    from: s.from,
+    note: s.present ? "already present" : "copy skill"
+  }));
+  if (result.plan.instructionsAction !== "present" && result.plan.instructionsAction !== "skip") {
+    actions.push({
+      type: result.plan.instructionsAction === "create" ? "write" : "append",
+      path: result.plan.instructionsFile,
+      note: `reduce-pipe instruction (${result.plan.instructionsAction})`
+    });
+  }
+  if (result.hookPlan && result.hookPlan.action !== "present") {
+    actions.push({
+      type: "write",
+      path: result.hookPlan.hooksFile,
+      note: `Bash PostToolUse hook (${result.hookPlan.action})`
+    });
+  }
+  const hookChanged = result.hookPlan !== null && result.hookPlan.action !== "present";
+  return {
+    harness: "codex",
+    dryRun: !apply,
+    changed: result.plan.changed || hookChanged,
+    alreadyInstalled: !result.plan.changed && !hookChanged,
+    applied: result.applied,
+    actions,
+    details: { hook: result.hookPlan ? result.hookPlan.action : "skipped" }
+  };
+}
+function claudeInstallJson(result, apply) {
+  const actions = result.plan.skills.map((s) => ({
+    type: s.present ? "none" : "copy",
+    path: s.to,
+    from: s.from,
+    note: s.present ? "already present" : "copy skill"
+  }));
+  if (result.plan.settingsAction !== "present" && result.plan.settingsAction !== "skip") {
+    actions.push({
+      type: result.plan.settingsAction === "create" ? "write" : "write",
+      path: result.plan.settingsFile,
+      note: `PostToolUse Bash hook (${result.plan.settingsAction})`
+    });
+  }
+  if (result.plan.instructionsAction !== "present" && result.plan.instructionsAction !== "skip") {
+    actions.push({
+      type: result.plan.instructionsAction === "create" ? "write" : "append",
+      path: result.plan.instructionsFile,
+      note: `reduce-pipe instruction (${result.plan.instructionsAction})`
+    });
+  }
+  return {
+    harness: "claude",
+    dryRun: !apply,
+    changed: result.plan.changed,
+    alreadyInstalled: !result.plan.changed,
+    applied: result.applied,
+    actions,
+    details: {
+      settingsAction: result.plan.settingsAction,
+      instructionsAction: result.plan.instructionsAction
+    }
+  };
+}
+function hermesInstallJson(result, apply) {
+  const actions = [
+    {
+      type: result.plan.alreadyInstalled ? "none" : "copy",
+      path: result.plan.pluginDest,
+      from: result.plan.pluginSource,
+      note: result.plan.alreadyInstalled ? "already installed" : "copy Hermes plugin bundle"
+    }
+  ];
+  return {
+    harness: "hermes",
+    dryRun: !apply,
+    changed: !result.plan.alreadyInstalled,
+    alreadyInstalled: result.plan.alreadyInstalled,
+    applied: result.applied,
+    actions,
+    details: { enabled: result.enabled, enableMessage: result.enableMessage ?? null }
+  };
+}
+function piInstallJson(result, apply) {
+  const actions = [
+    {
+      type: result.plan.alreadyInstalled ? "none" : "copy",
+      path: result.plan.extensionDest,
+      from: result.plan.extensionSource,
+      note: result.plan.alreadyInstalled ? "already installed" : "copy Pi extension bundle"
+    }
+  ];
+  return {
+    harness: "pi",
+    dryRun: !apply,
+    changed: !result.plan.alreadyInstalled,
+    alreadyInstalled: result.plan.alreadyInstalled,
+    applied: result.applied,
+    actions
+  };
+}
+function codexGlobalHookJson(result, apply) {
+  const actions = [
+    {
+      type: result.hookPlan.action === "present" ? "none" : "write",
+      path: result.hookPlan.hooksFile,
+      note: `global Bash PostToolUse hook (${result.hookPlan.action})`
+    }
+  ];
+  return {
+    harness: "codex",
+    dryRun: !apply,
+    changed: result.hookPlan.action !== "present",
+    alreadyInstalled: result.hookPlan.action === "present",
+    applied: result.applied,
+    actions,
+    details: { scope: "global" }
+  };
+}
 
 // src/cli.ts
 var HELP = `harnesstrim \u2014 one token policy for coding harnesses
@@ -23775,16 +24490,25 @@ Usage:
   harnesstrim install opencode [dir]       Wire the adapter into opencode.json (dry-run)
                             --apply         Actually write the change
                             --preset <name> Bake a policy preset's adapter config in
+                            --mode <m>      Override mode: active|dryrun|off
+                            --min-length <n> Override the reduction threshold (chars)
+                            --tools <list>  Confine reduction to a subset of tool families
   harnesstrim install codex [dir]          Install skills + AGENTS.md reduction guidance (dry-run)
                             --apply         Actually write the change
                             --hook          Also install the experimental Bash PostToolUse hook
+                            --no-instructions  Skills only (no AGENTS.md reduce-pipe instruction)
                             --global        With --hook, install it once in ~/.codex (no project files)
   harnesstrim install claude [dir]         Install skills + PostToolUse reducer hook (dry-run)
                             --apply         Actually write the change
+                            --no-hook       Skills only (no PostToolUse hook)
+                            --no-instructions  Skills only (no CLAUDE.md reduce-pipe instruction)
   harnesstrim install hermes [dir]         Install Hermes plugin (dry-run)
                             --apply         Actually write the change
   harnesstrim install pi [dir]             Install Pi tool_result extension (dry-run)
                             --apply         Actually write the change
+  harnesstrim uninstall <harness> [dir]    Remove only what install wrote (dry-run)
+                            --apply         Actually write the change
+  harnesstrim capabilities                 Print machine-readable per-harness capabilities (JSON)
   harnesstrim hook claude [--metrics <path>]
                                            PostToolUse hook runtime; --metrics records a TrimEvent per reduction
   harnesstrim hook codex [--metrics <path>]
@@ -23798,10 +24522,13 @@ Usage:
   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
+
+Flags:
+  --json                                  Print machine-readable JSON (doctor, metrics, install, uninstall)
 
 Notes:
-  - install is dry-run by default; nothing is written without --apply.
+  - install and uninstall are dry-run by default; nothing is written without --apply.
   - dir defaults to the current directory; metrics path defaults to ${DEFAULT_METRICS_PATH}.
   - reduce reads stdin and writes slimmed output to stdout, e.g.  npm test 2>&1 | harnesstrim reduce`;
 async function main(argv) {
@@ -23810,6 +24537,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" },
@@ -23817,10 +24545,19 @@ async function main(argv) {
       log: { type: "string" },
       metrics: { type: "string" },
       hook: { type: "boolean" },
-      global: { type: "boolean" }
+      global: { type: "boolean" },
+      "no-hook": { type: "boolean" },
+      "no-instructions": { type: "boolean" },
+      mode: { type: "string" },
+      tools: { type: "string" },
+      json: { type: "boolean" }
     }
   });
   const [command, ...rest] = positionals;
+  if (values.version) {
+    console.log(package_default.version);
+    return 0;
+  }
   if (values.help || !command) {
     console.log(HELP);
     return 0;
@@ -23828,16 +24565,34 @@ async function main(argv) {
   switch (command) {
     case "doctor": {
       const dir = rest[0] ?? process.cwd();
-      console.log(renderDoctor(inspect(dir)));
+      const report = inspect(dir);
+      if (values.json) {
+        console.log(doctorJson(report));
+      } else {
+        console.log(renderDoctor(report));
+      }
       return 0;
     }
     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;
+      const asJson = values.json === true;
       if (target === "opencode") {
-        const result = runInstallOpencode(dir, apply, values.preset);
-        console.log(renderInstall(result, apply));
+        const mode = parseModeFlag(values.mode);
+        if (mode === void 0 && values.mode !== void 0) {
+          console.error(`Invalid --mode: ${values.mode} (expected active, dryrun, or off).`);
+          return 1;
+        }
+        const minLength = values["min-length"] !== void 0 ? Number(values["min-length"]) : void 0;
+        if (minLength !== void 0 && !Number.isFinite(minLength)) {
+          console.error(`Invalid --min-length: ${values["min-length"]}`);
+          return 1;
+        }
+        const tools = values.tools !== void 0 ? splitTools(values.tools) : void 0;
+        const result = runInstallOpencode(dir, apply, values.preset, true, { mode, minLength, tools });
+        if (asJson) console.log(JSON.stringify(opencodeInstallJson(result, apply), null, 2));
+        else console.log(renderInstall(result, apply));
         return 0;
       }
       if (target === "codex") {
@@ -23846,27 +24601,63 @@ async function main(argv) {
             console.error("`harnesstrim install codex --global` requires `--hook`.");
             return 1;
           }
-          console.log(renderCodexGlobalHookInstall(runInstallCodexGlobalHook(path15.join(os2.homedir(), ".codex"), apply), apply));
+          const result2 = runInstallCodexGlobalHook(path16.join(os4.homedir(), ".codex"), apply);
+          if (asJson) console.log(JSON.stringify(codexGlobalHookJson(result2, apply), null, 2));
+          else console.log(renderCodexGlobalHookInstall(result2, apply));
           return 0;
         }
-        console.log(renderCodexInstall(runInstallCodex(dir, apply, values.hook === true), apply));
+        const result = runInstallCodex(dir, apply, values.hook === true, {
+          includeInstructions: values["no-instructions"] !== true
+        });
+        if (asJson) console.log(JSON.stringify(codexInstallJson(result, apply), null, 2));
+        else console.log(renderCodexInstall(result, apply));
         return 0;
       }
       if (target === "claude") {
-        console.log(renderClaudeInstall(runInstallClaude(dir, apply), apply));
+        const result = runInstallClaude(dir, apply, {
+          includeHook: values["no-hook"] !== true,
+          includeInstructions: values["no-instructions"] !== true
+        });
+        if (asJson) console.log(JSON.stringify(claudeInstallJson(result, apply), null, 2));
+        else console.log(renderClaudeInstall(result, apply));
         return 0;
       }
       if (target === "hermes") {
-        console.log(renderHermesInstall(runInstallHermes(dir, apply), apply));
+        const result = runInstallHermes(dir, apply);
+        if (asJson) console.log(JSON.stringify(hermesInstallJson(result, apply), null, 2));
+        else console.log(renderHermesInstall(result, apply));
         return 0;
       }
       if (target === "pi") {
-        console.log(renderPiInstall(runInstallPi(dir, apply), apply));
+        const result = runInstallPi(dir, apply);
+        if (asJson) console.log(JSON.stringify(piInstallJson(result, apply), null, 2));
+        else console.log(renderPiInstall(result, apply));
         return 0;
       }
       console.error(`Unknown install target: ${target ?? "(none)"}. Supported: opencode, codex, claude, hermes, pi.`);
       return 1;
     }
+    case "uninstall": {
+      const target = rest[0];
+      const dir = rest[1] ?? (target === "hermes" ? os4.homedir() : process.cwd());
+      const apply = values.apply === true;
+      try {
+        const result = runUninstall(target, dir, apply);
+        if (values.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(renderUninstall(result, apply));
+        }
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return 1;
+      }
+      return 0;
+    }
+    case "capabilities": {
+      console.log(JSON.stringify(getCapabilities(package_default.version), null, 2));
+      return 0;
+    }
     case "hook": {
       const which = rest[0];
       if (which !== "claude" && which !== "codex") {
@@ -23878,18 +24669,24 @@ async function main(argv) {
       process.stdout.write(response);
       if (values.metrics && event) {
         try {
-          const p = path15.resolve(values.metrics);
-          fs11.mkdirSync(path15.dirname(p), { recursive: true });
-          fs11.appendFileSync(
+          const p = path16.resolve(values.metrics);
+          fs12.mkdirSync(path16.dirname(p), { recursive: true });
+          fs12.appendFileSync(
             p,
-            JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), harness: which, ...event }) + "\n"
+            JSON.stringify(
+              makeTrimEvent({
+                ts: (/* @__PURE__ */ new Date()).toISOString(),
+                harness: which,
+                ...event
+              })
+            ) + "\n"
           );
         } catch {
         }
       }
       if (values.log) {
         try {
-          fs11.appendFileSync(
+          fs12.appendFileSync(
             values.log,
             JSON.stringify({ inputChars: input.length, changed: response !== "{}", responseChars: response.length }) + "\n"
           );
@@ -23918,8 +24715,13 @@ async function main(argv) {
       return 1;
     }
     case "metrics": {
-      const path16 = rest[0] ?? DEFAULT_METRICS_PATH;
-      console.log(renderMetrics(loadMetrics(path16)));
+      const path17 = rest[0] ?? DEFAULT_METRICS_PATH;
+      const result = loadMetrics(path17);
+      if (values.json) {
+        console.log(metricsJson(result));
+      } else {
+        console.log(renderMetrics(result));
+      }
       return 0;
     }
     case "reduce": {
@@ -23934,18 +24736,20 @@ async function main(argv) {
       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(
+          const p = path16.resolve(values.metrics);
+          fs12.mkdirSync(path16.dirname(p), { recursive: true });
+          fs12.appendFileSync(
             p,
-            JSON.stringify({
-              ts: (/* @__PURE__ */ new Date()).toISOString(),
-              harness: "pipe",
-              tool: "reduce",
-              reducer: result.reducer,
-              beforeChars: result.beforeChars,
-              afterChars: result.afterChars
-            }) + "\n"
+            JSON.stringify(
+              makeTrimEvent({
+                ts: (/* @__PURE__ */ new Date()).toISOString(),
+                harness: "pipe",
+                tool: "reduce",
+                reducer: result.reducer,
+                beforeChars: result.beforeChars,
+                afterChars: result.afterChars
+              })
+            ) + "\n"
           );
         } catch {
         }
@@ -23986,6 +24790,12 @@ async function main(argv) {
       return 1;
   }
 }
+function parseModeFlag(value) {
+  return value === "active" || value === "dryrun" || value === "off" ? value : void 0;
+}
+function splitTools(value) {
+  return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
 main(process.argv.slice(2)).then((code) => {
   process.exitCode = code;
 }).catch((err) => {