harnesstrim 0.0.6 → 0.0.7

package/assets/adapter-hermes/plugin/__init__.py

@@ -225,14 +225,19 @@ def _write_metric(tool: str, reducer: str | None, before: int, after: int) -> No
     directory lazily and swallows any error — telemetry must never crash the plugin.
     """
     import datetime as _dt
+    import uuid as _uuid
 
     event = {
+        "schemaVersion": 1,
+        "eventId": str(_uuid.uuid4()),
         "ts": _dt.datetime.now(_dt.timezone.utc).isoformat(),
         "harness": "hermes",
         "tool": tool,
         "reducer": reducer,
         "beforeChars": before,
         "afterChars": after,
+        "beforeTokens": None,
+        "afterTokens": None,
     }
     try:
         METRICS_PATH.parent.mkdir(parents=True, exist_ok=True)

package/assets/adapter-pi/extension/{harnesstrim.ts → index.ts}

@@ -29,6 +29,11 @@ const MODE = env.HARNESSTRIM_MODE ?? "dryrun";
 const MIN_LENGTH = Number(env.HARNESSTRIM_MINLENGTH ?? "400") || 400;
 const MARKER = "[harnesstrim";
 
+/** True when a text chunk should not be reduced: too short, or already reduced. */
+export function shouldSkip(text: string, minLength: number): boolean {
+  return text.length < minLength || text.includes(MARKER);
+}
+
 function reduceViaCli(text: string): string | null {
   try {
     const r = spawnSync("harnesstrim", ["reduce", "--min-length", String(MIN_LENGTH)], {
@@ -54,7 +59,7 @@ export default function harnesstrim(pi: ExtensionAPI): void {
     const content = event.content.map((chunk) => {
       if (chunk.type !== "text" || typeof chunk.text !== "string") return chunk;
       const text = chunk.text;
-      if (text.length < MIN_LENGTH || text.includes(MARKER)) return chunk;
+      if (shouldSkip(text, MIN_LENGTH)) return chunk;
 
       const reduced = reduceViaCli(text);
       if (!reduced || reduced.length >= text.length) return chunk;

package/dist/cli.mjs

@@ -713,6 +713,21 @@ 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,
+    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;
@@ -753,7 +768,7 @@ function parseTrimEvents(jsonl) {
     } catch {
       continue;
     }
-    if (isTrimEvent(parsed)) out.push(parsed);
+    if (isTrimEvent(parsed)) out.push(normalize(parsed));
   }
   return out;
 }
@@ -762,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;
   }
 });
 
@@ -1239,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
@@ -1548,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() {
@@ -5133,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);
@@ -5385,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;
   });
 }
@@ -16225,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);
@@ -17219,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;
@@ -17472,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;
       }
@@ -17622,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);
@@ -17889,7 +17920,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize,
+      normalize: normalize2,
       resolve,
       resolveComponent,
       equal,
@@ -20866,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 });
@@ -22632,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 {
     }
   };
@@ -22647,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 }] };
 }
@@ -22698,8 +22730,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 +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) {
@@ -22938,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,
@@ -23133,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) => ({
@@ -23142,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";
@@ -23154,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"
   };
 }
 
@@ -23219,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");
@@ -23235,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, 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 +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 };
@@ -23349,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) => ({
@@ -23370,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,
@@ -23380,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) {
@@ -23394,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");
@@ -23418,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");
     }
@@ -23499,12 +23549,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 +23675,7 @@ function loadMetrics(filePath) {
 // package.json
 var package_default = {
   name: "harnesstrim",
-  version: "0.0.6",
+  version: "0.0.7",
   description: "HarnessTrim CLI: doctor (diagnose token waste), install adapters, run benchmarks.",
   license: "MIT",
   type: "module",
@@ -23669,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) {
@@ -23767,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("");
@@ -23816,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(
@@ -23829,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(
@@ -23884,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.");
@@ -23919,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
@@ -23928,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>]
@@ -23953,8 +24524,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 +24545,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 +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" ? 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 +24601,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") {
@@ -24036,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"
           );
@@ -24076,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": {
@@ -24092,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 {
         }
@@ -24144,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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harnesstrim",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "HarnessTrim CLI: doctor (diagnose token waste), install adapters, run benchmarks.",
   "license": "MIT",
   "type": "module",
@@ -16,13 +16,13 @@
   },
   "devDependencies": {
     "esbuild": "^0.25.0",
-    "@harnesstrim/adapter-claude": "0.0.1",
-    "@harnesstrim/adapter-hermes": "0.0.1",
-    "@harnesstrim/core": "0.0.2",
     "@harnesstrim/adapter-codex": "0.0.1",
+    "@harnesstrim/adapter-claude": "0.0.1",
+    "@harnesstrim/adapter-pi": "0.0.1",
     "@harnesstrim/benchmarks": "0.0.1",
     "@harnesstrim/mcp": "0.0.1",
-    "@harnesstrim/adapter-pi": "0.0.1"
+    "@harnesstrim/adapter-hermes": "0.0.1",
+    "@harnesstrim/core": "0.0.2"
   },
   "scripts": {
     "build": "node build.mjs",