harnesstrim 0.0.6 → 0.1.0

package/dist/cli.mjs

@@ -713,6 +713,22 @@ var init_dispatch = __esm({
 });
 
 // ../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,
+    changed: partial2.changed ?? true,
+    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;
@@ -720,10 +736,30 @@ function pct(before, after) {
 function summarize(events) {
   let beforeChars = 0;
   let afterChars = 0;
+  let reduced = 0;
+  let passThrough = 0;
+  let reductionErrors = 0;
+  let grewChars = 0;
   const byReducerMap = /* @__PURE__ */ new Map();
+  const byHarnessMap = /* @__PURE__ */ new Map();
   for (const e of events) {
     beforeChars += e.beforeChars;
     afterChars += e.afterChars;
+    if (e.changed === false) {
+      passThrough++;
+    } else if (e.afterChars > e.beforeChars) {
+      reductionErrors++;
+      grewChars += e.afterChars - e.beforeChars;
+    } else {
+      reduced++;
+    }
+    const harness = e.harness ?? "unknown";
+    const h = byHarnessMap.get(harness) ?? { harness, count: 0, beforeChars: 0, afterChars: 0, savedChars: 0, reductionPct: 0 };
+    h.count += 1;
+    h.beforeChars += e.beforeChars;
+    h.afterChars += e.afterChars;
+    h.savedChars += e.beforeChars - e.afterChars;
+    byHarnessMap.set(harness, h);
     if (e.reducer === null) continue;
     const b = byReducerMap.get(e.reducer) ?? { reducer: e.reducer, count: 0, beforeChars: 0, afterChars: 0, savedChars: 0 };
     b.count += 1;
@@ -733,13 +769,20 @@ function summarize(events) {
     byReducerMap.set(e.reducer, b);
   }
   const byReducer = [...byReducerMap.values()].sort((a, b) => b.savedChars - a.savedChars);
+  const byHarness = [...byHarnessMap.values()].map((h) => ({ ...h, reductionPct: pct(h.beforeChars, h.afterChars) })).sort((a, b) => b.savedChars - a.savedChars);
   return {
     events: events.length,
     beforeChars,
     afterChars,
     savedChars: beforeChars - afterChars,
     reductionPct: pct(beforeChars, afterChars),
-    byReducer
+    byReducer,
+    byHarness,
+    reduced,
+    passThrough,
+    passThroughRate: events.length === 0 ? 0 : Math.round(passThrough / events.length * 1e3) / 10,
+    reductionErrors,
+    grewChars
   };
 }
 function parseTrimEvents(jsonl) {
@@ -753,7 +796,7 @@ function parseTrimEvents(jsonl) {
     } catch {
       continue;
     }
-    if (isTrimEvent(parsed)) out.push(parsed);
+    if (isTrimEvent(parsed)) out.push(normalize(parsed));
   }
   return out;
 }
@@ -762,9 +805,26 @@ 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,
+    changed: typeof v.changed === "boolean" ? v.changed : true,
+    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;
   }
 });
 
@@ -1239,8 +1299,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
@@ -1548,11 +1608,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() {
@@ -5133,10 +5193,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);
@@ -5385,11 +5445,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;
   });
 }
@@ -16225,8 +16285,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);
@@ -17219,8 +17279,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;
@@ -17472,8 +17532,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;
       }
@@ -17622,7 +17682,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);
@@ -17889,7 +17949,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize,
+      normalize: normalize2,
       resolve,
       resolveComponent,
       equal,
@@ -20866,12 +20926,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 });
@@ -22632,34 +22692,48 @@ __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 {
     }
   };
 }
-function runReduceTool(text, minLength, sink = noopSink) {
+function runReduceTool(text, minLength, sink = noopSink, trackPassThrough2 = true) {
   const result = reduceAuto(text, minLength);
+  const threshold = minLength ?? DEFAULT_MIN_LENGTH;
   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
+      })
+    );
+  } else if (trackPassThrough2 && text.length >= threshold) {
+    sink(
+      makeTrimEvent({
+        harness: "mcp",
+        tool: "reduce",
+        reducer: null,
+        beforeChars: text.length,
+        afterChars: text.length,
+        changed: false
+      })
+    );
   }
   return { content: [{ type: "text", text: result.output }] };
 }
 function createServer(options = {}) {
   const sink = options.metricsPath ? createFileSink(options.metricsPath) : noopSink;
+  const trackPassThrough2 = options.trackPassThrough !== false;
   const server = new McpServer({ name: "harnesstrim", version: "0.0.1" });
   server.registerTool(
     "reduce",
@@ -22671,13 +22745,15 @@ function createServer(options = {}) {
         minLength: external_exports.number().optional().describe("Skip reduction for inputs shorter than this many characters (default 400)")
       }
     },
-    async ({ text, minLength }) => runReduceTool(text, minLength, sink)
+    async ({ text, minLength }) => runReduceTool(text, minLength, sink, trackPassThrough2)
   );
   return server;
 }
 async function startStdioServer(options = {}) {
   const metricsPath = options.metricsPath ?? process.env.HARNESSTRIM_TELEMETRY_PATH;
-  const server = createServer({ metricsPath });
+  const envTrack = process.env.HARNESSTRIM_TRACK_PASSTHROUGH;
+  const trackPassThrough2 = options.trackPassThrough ?? (envTrack !== void 0 ? envTrack !== "0" && envTrack !== "false" : true);
+  const server = createServer({ metricsPath, trackPassThrough: trackPassThrough2 });
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
@@ -22698,8 +22774,8 @@ 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 fs12 from "node:fs";
+import path16 from "node:path";
 import os4 from "node:os";
 
 // src/doctor.ts
@@ -22930,7 +23006,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) {
@@ -22938,19 +23014,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,
@@ -23007,9 +23086,15 @@ import path3 from "node:path";
 init_src();
 function reduceCodexPayload(rawJson, minLength) {
   const extracted = extractToolOutput(rawJson);
-  if (extracted === null) return { response: "{}", event: null };
+  if (extracted === null) return { response: "{}", event: null, attempt: null };
   const result = reduceAuto(extracted.output, minLength);
-  if (!result.changed) return { response: "{}", event: null };
+  if (!result.changed) {
+    return {
+      response: "{}",
+      event: null,
+      attempt: extracted.output.length >= (minLength ?? DEFAULT_MIN_LENGTH) ? { tool: extracted.toolName, beforeChars: extracted.output.length } : null
+    };
+  }
   const response = JSON.stringify({
     decision: "block",
     reason: `HarnessTrim reduced ${extracted.toolName} output (${result.reducer}):
@@ -23023,7 +23108,8 @@ ${result.output}`
       reducer: result.reducer,
       beforeChars: extracted.output.length,
       afterChars: result.output.length
-    }
+    },
+    attempt: null
   };
 }
 function extractToolOutput(rawJson) {
@@ -23133,6 +23219,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) => ({
@@ -23142,7 +23229,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";
@@ -23154,7 +23243,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"
   };
 }
 
@@ -23219,7 +23309,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");
@@ -23235,14 +23325,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, 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 });
@@ -23253,7 +23345,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 };
@@ -23278,9 +23370,15 @@ import path8 from "node:path";
 init_src();
 function reduceClaudePayload(rawJson, minLength) {
   const extracted = extractToolOutput2(rawJson);
-  if (extracted === null) return { response: "{}", event: null };
+  if (extracted === null) return { response: "{}", event: null, attempt: null };
   const result = reduceAuto(extracted.output, minLength);
-  if (!result.changed) return { response: "{}", event: null };
+  if (!result.changed) {
+    return {
+      response: "{}",
+      event: null,
+      attempt: extracted.output.length >= (minLength ?? DEFAULT_MIN_LENGTH) ? { tool: extracted.toolName, beforeChars: extracted.output.length } : null
+    };
+  }
   const response = JSON.stringify({
     hookSpecificOutput: {
       hookEventName: "PostToolUse",
@@ -23294,7 +23392,8 @@ function reduceClaudePayload(rawJson, minLength) {
       reducer: result.reducer,
       beforeChars: extracted.output.length,
       afterChars: result.output.length
-    }
+    },
+    attempt: null
   };
 }
 function extractToolOutput2(rawJson) {
@@ -23349,6 +23448,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) => ({
@@ -23370,8 +23471,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,
@@ -23380,7 +23485,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) {
@@ -23394,7 +23500,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");
@@ -23418,17 +23524,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");
     }
@@ -23499,12 +23607,16 @@ function runInstallPi(installDir, apply) {
   let applied = false;
   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;
@@ -23621,7 +23733,7 @@ function loadMetrics(filePath) {
 // package.json
 var package_default = {
   name: "harnesstrim",
-  version: "0.0.6",
+  version: "0.1.0",
   description: "HarnessTrim CLI: doctor (diagnose token waste), install adapters, run benchmarks.",
   license: "MIT",
   type: "module",
@@ -23669,6 +23781,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) {
@@ -23767,7 +24197,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("");
@@ -23816,7 +24246,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(
@@ -23829,7 +24261,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(
@@ -23884,7 +24318,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.");
@@ -23908,18 +24342,217 @@ Enable it in the adapter (telemetry: true) to record reductions.`;
   const lines = [
     `harnesstrim metrics \u2014 ${result.path}`,
     "",
-    `Reductions: ${s.events}`,
-    `Chars:      ${s.beforeChars} -> ${s.afterChars}  (saved ${s.savedChars}, -${s.reductionPct}%)`,
-    "",
-    "By reducer:"
+    `Attempts:     ${s.events} (${s.reduced} reduced, ${s.passThrough} pass-through, ${s.reductionErrors} error)`,
+    `Pass-through: ${s.passThroughRate}% of attempts unchanged`,
+    `Chars:        ${s.beforeChars} -> ${s.afterChars}  (saved ${s.savedChars}, -${s.reductionPct}%)`
   ];
+  if (s.reductionErrors > 0) {
+    lines.push(`Reduction errors: ${s.reductionErrors} attempt(s) GREW the output (+${s.grewChars} chars) \u2014 investigate`);
+  }
+  lines.push("");
+  lines.push("By reducer:");
   for (const b of s.byReducer) {
     const p = b.beforeChars === 0 ? 0 : Math.round(b.savedChars / b.beforeChars * 1e3) / 10;
     lines.push(`  ${b.reducer.padEnd(20)} ${b.count}x  saved ${b.savedChars} chars (-${p}%)`);
   }
+  if (s.byHarness.length > 0) {
+    lines.push("");
+    lines.push("By harness:");
+    for (const h of s.byHarness) {
+      const p = h.beforeChars === 0 ? 0 : Math.round(h.savedChars / h.beforeChars * 1e3) / 10;
+      const sign = p < 0 ? "" : "-";
+      lines.push(`  ${h.harness.padEnd(12)} ${h.count}x  saved ${h.savedChars} chars (${sign}${Math.abs(p)}%)`);
+    }
+  }
+  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
 
@@ -23928,16 +24561,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>]
@@ -23953,8 +24595,11 @@ Usage:
   harnesstrim bench                        Run the Tier A reducer micro-benchmark
   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) {
@@ -23971,7 +24616,12 @@ 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;
@@ -23986,16 +24636,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" ? 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") {
@@ -24004,27 +24672,63 @@ async function main(argv) {
             console.error("`harnesstrim install codex --global` requires `--hook`.");
             return 1;
           }
-          console.log(renderCodexGlobalHookInstall(runInstallCodexGlobalHook(path15.join(os4.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") {
@@ -24032,22 +24736,45 @@ async function main(argv) {
         return 1;
       }
       const input = await readStdin();
-      const { response, event } = which === "claude" ? reduceClaudePayload(input) : reduceCodexPayload(input);
+      const { response, event, attempt } = which === "claude" ? reduceClaudePayload(input) : reduceCodexPayload(input);
       process.stdout.write(response);
-      if (values.metrics && event) {
+      if (values.metrics) {
         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: which, ...event }) + "\n"
-          );
+          const p = path16.resolve(values.metrics);
+          fs12.mkdirSync(path16.dirname(p), { recursive: true });
+          if (event) {
+            fs12.appendFileSync(
+              p,
+              JSON.stringify(
+                makeTrimEvent({
+                  ts: (/* @__PURE__ */ new Date()).toISOString(),
+                  harness: which,
+                  ...event
+                })
+              ) + "\n"
+            );
+          } else if (attempt && trackPassThrough()) {
+            fs12.appendFileSync(
+              p,
+              JSON.stringify(
+                makeTrimEvent({
+                  ts: (/* @__PURE__ */ new Date()).toISOString(),
+                  harness: which,
+                  tool: attempt.tool,
+                  reducer: null,
+                  beforeChars: attempt.beforeChars,
+                  afterChars: attempt.beforeChars,
+                  changed: false
+                })
+              ) + "\n"
+            );
+          }
         } catch {
         }
       }
       if (values.log) {
         try {
-          fs11.appendFileSync(
+          fs12.appendFileSync(
             values.log,
             JSON.stringify({ inputChars: input.length, changed: response !== "{}", responseChars: response.length }) + "\n"
           );
@@ -24076,8 +24803,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": {
@@ -24090,21 +24822,40 @@ async function main(argv) {
       const input = await readStdin();
       const result = reducePipe(input, minLength);
       process.stdout.write(result.output);
-      if (values.metrics && result.changed) {
+      if (values.metrics) {
         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"
-          );
+          const p = path16.resolve(values.metrics);
+          fs12.mkdirSync(path16.dirname(p), { recursive: true });
+          if (result.changed) {
+            fs12.appendFileSync(
+              p,
+              JSON.stringify(
+                makeTrimEvent({
+                  ts: (/* @__PURE__ */ new Date()).toISOString(),
+                  harness: "pipe",
+                  tool: "reduce",
+                  reducer: result.reducer,
+                  beforeChars: result.beforeChars,
+                  afterChars: result.afterChars
+                })
+              ) + "\n"
+            );
+          } else if (trackPassThrough() && input.length >= (minLength ?? DEFAULT_MIN_LENGTH)) {
+            fs12.appendFileSync(
+              p,
+              JSON.stringify(
+                makeTrimEvent({
+                  ts: (/* @__PURE__ */ new Date()).toISOString(),
+                  harness: "pipe",
+                  tool: "reduce",
+                  reducer: null,
+                  beforeChars: input.length,
+                  afterChars: input.length,
+                  changed: false
+                })
+              ) + "\n"
+            );
+          }
         } catch {
         }
       }
@@ -24144,6 +24895,16 @@ 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);
+}
+function trackPassThrough() {
+  const v = process.env.HARNESSTRIM_TRACK_PASSTHROUGH;
+  return v === void 0 || v !== "0" && v !== "false";
+}
 main(process.argv.slice(2)).then((code) => {
   process.exitCode = code;
 }).catch((err) => {