harnesstrim 0.0.7 → 0.2.0

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

@@ -59,9 +59,29 @@ def register(ctx):
     ctx.register_hook("transform_tool_result", on_tool_result)
 
 
+def _load_file_config():
+    """Read the baked config from `config.json` beside the plugin (written by
+    `harnesstrim install hermes --mode/--min-length --apply`). Environment variables
+    still override it at runtime. Any malformed/missing file degrades to {}."""
+    cfg_path = PLUGIN_DIR / "config.json"
+    if not cfg_path.is_file():
+        return {}
+    try:
+        loaded = json.loads(cfg_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    if not isinstance(loaded, dict):
+        return {}
+    return {key: loaded[key] for key in CONFIG_DEFAULTS if key in loaded}
+
+
 def _load_config():
-    """Return the active plugin config from the environment (no global registry needed)."""
+    """Return the active plugin config: env vars override the baked config.json
+    (from install), which overrides the built-in defaults. Keeps the runtime
+    override (HARNESSTRIM_MODE / HARNESSTRIM_MINLENGTH) winning, so an installed
+    state can always be switched without reinstalling."""
     cfg = dict(CONFIG_DEFAULTS)
+    cfg.update(_load_file_config())
     for key in CONFIG_DEFAULTS:
         env_key = f"HARNESSTRIM_{key.upper()}"
         val = os.environ.get(env_key)
@@ -89,10 +109,11 @@ def _find_harnesstrim_cli() -> str | None:
     return None
 
 
-def _call_reducer(text: str, min_length: int) -> tuple[str, str | None]:
-    """Shell out to ``harnesstrim reduce`` and return (slimmed_text, reducer_name).
+def _call_reducer(text: str, min_length: int) -> tuple[str, str | None, bool]:
+    """Shell out to ``harnesstrim reduce`` and return
+    (slimmed_text, reducer_name, reduction_failed).
 
-    Falls back to (original_text, None) if the CLI cannot be found or the pipe fails.
+    Falls back to (original_text, None, False) if the CLI cannot be found or the pipe fails.
     The reducer name is parsed from the ``--stats`` stderr line (e.g. ``test-output-slim``),
     used only for telemetry when enabled.
     """
@@ -105,10 +126,10 @@ def _call_reducer(text: str, min_length: int) -> tuple[str, str | None]:
             "or build from source: git clone https://github.com/harnesstrim/harnesstrim",
             stacklevel=2,
         )
-        return (text, None)
+        return (text, None, False)
 
     if len(text) < min_length:
-        return (text, None)
+        return (text, None, False)
 
     try:
         result = subprocess.run(
@@ -127,11 +148,12 @@ def _call_reducer(text: str, min_length: int) -> tuple[str, str | None]:
                     rest = line[len("[harnesstrim reduce] "):]
                     if ":" in rest and "no reduction" not in rest:
                         reducer = rest.split(":")[0].strip()
-            return (result.stdout.rstrip("\n"), reducer)
+            reduction_failed = "reducer failed; original output preserved" in result.stderr
+            return (result.stdout, reducer, reduction_failed)
     except (FileNotFoundError, subprocess.TimeoutExpired, OSError):
         pass
 
-    return (text, None)
+    return (text, None, False)
 
 
 def _text_targets(payload):
@@ -193,8 +215,17 @@ def on_tool_result(tool_name, args, result, **kwargs):
         if "[harnesstrim:" in text or "[hermes-trim" in text:
             continue
 
-        after, reducer = _call_reducer(text, cfg["minLength"])
+        after, reducer, reduction_failed = _call_reducer(text, cfg["minLength"])
         if after == text:
+            if reduction_failed and cfg["telemetry"]:
+                _write_metric(
+                    tool_name,
+                    reducer,
+                    before_len,
+                    before_len,
+                    changed=False,
+                    reduction_failed=True,
+                )
             continue
 
         changed = True
@@ -218,7 +249,14 @@ def on_tool_result(tool_name, args, result, **kwargs):
     return json.dumps(payload, ensure_ascii=False) if not isinstance(payload, str) else payload
 
 
-def _write_metric(tool: str, reducer: str | None, before: int, after: int) -> None:
+def _write_metric(
+    tool: str,
+    reducer: str | None,
+    before: int,
+    after: int,
+    changed: bool = True,
+    reduction_failed: bool = False,
+) -> None:
     """Append one TrimEvent JSONL line to METRICS_PATH (read by `harnesstrim metrics`).
 
     Only called in active mode when telemetry is explicitly enabled. Creates the parent
@@ -236,6 +274,8 @@ def _write_metric(tool: str, reducer: str | None, before: int, after: int) -> No
         "reducer": reducer,
         "beforeChars": before,
         "afterChars": after,
+        "changed": changed,
+        "reductionFailed": reduction_failed,
         "beforeTokens": None,
         "afterTokens": None,
     }

package/assets/adapter-omp/hook/harnesstrim.ts

@@ -0,0 +1,177 @@
+// HarnessTrim OMP hook — slims noisy tool output via the `tool_result` hook.
+// Marker: harnesstrim:omp-hook
+//
+// omp auto-discovers default-export TS factories in ~/.omp/agent/hooks/post/*.ts
+// (global) and .omp/hooks/post/*.ts (project), loads them through its extension
+// runner, and fires `tool_result` after every successful tool call BEFORE the
+// result reaches the model. Returning `{ content }` replaces the result; returning
+// nothing leaves it untouched. Files in hooks/post/ are loaded with no trust gate
+// and no settings.json entry, so this hook's handlers bind on session start.
+//
+// This file is a hook FACTORY, not a harness process — it shells out to
+// `harnesstrim reduce` so the reducers live in the shared CLI core. Requires
+// `harnesstrim` on PATH; if missing or failing, output passes through unchanged
+// (a reducer must never break a tool result).
+//
+// Config precedence (highest first):
+//   1. Environment: HARNESSTRIM_MODE=dryrun|active|off, HARNESSTRIM_MINLENGTH=<chars>,
+//      HARNESSTRIM_METRICS=<path>
+//   2. config.json beside the hooks dir (written by `harnesstrim install omp --apply`
+//      with --mode/--min-length/--metrics)
+//   3. built-in defaults: dryrun, minLength 400.
+//
+// --metrics records a TrimEvent JSONL receipt per reduction (read by
+// `harnesstrim metrics`) — the receipt that makes interception verifiable.
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+const env = process.env;
+const MARKER = "[harnesstrim";
+const DEFAULT_MIN_LENGTH = 400;
+
+const HERE =
+  (typeof import.meta !== "undefined" && (import.meta as { dirname?: string }).dirname) || "";
+const CONFIG_PATH = HERE ? path.join(HERE, "..", "harnesstrim.json") : "";
+
+function readConfig(): { mode?: string; minLength?: number; metrics?: string } {
+  if (!CONFIG_PATH) return {};
+  try {
+    const parsed = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8")) as Record<string, unknown>;
+    return {
+      mode: typeof parsed.mode === "string" ? parsed.mode : undefined,
+      minLength: typeof parsed.minLength === "number" ? parsed.minLength : undefined,
+      metrics: typeof parsed.metrics === "string" ? parsed.metrics : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+const baked = readConfig();
+const MODE = env.HARNESSTRIM_MODE ?? baked.mode ?? "dryrun";
+const MIN_LENGTH = Number(env.HARNESSTRIM_MINLENGTH ?? (baked.minLength ?? DEFAULT_MIN_LENGTH)) || DEFAULT_MIN_LENGTH;
+const METRICS_PATH = env.HARNESSTRIM_METRICS || baked.metrics || undefined;
+
+interface TextChunk {
+  type: string;
+  text?: unknown;
+}
+
+function reduce(
+  text: string,
+): { output: string | null; reducer: string | null; reductionFailed: boolean } {
+  try {
+    const r = spawnSync("harnesstrim", ["reduce", "--min-length", String(MIN_LENGTH), "--stats"], {
+      input: text,
+      encoding: "utf8",
+      timeout: 30_000,
+    });
+    const stdout = typeof r.stdout === "string" ? r.stdout : "";
+    const stderr = typeof r.stderr === "string" ? r.stderr : "";
+    const output = stdout;
+    if (r.status === 0 && output && output.length > 0) {
+      return {
+        output,
+        reducer: parseReducer(stderr),
+        reductionFailed: stderr.includes("reducer failed; original output preserved"),
+      };
+    }
+  } catch {
+    /* harnesstrim not on PATH or failed — pass through */
+  }
+  return { output: null, reducer: null, reductionFailed: false };
+}
+
+function parseReducer(stderr: string): string | null {
+  for (const line of stderr.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[harnesstrim reduce]")) {
+      const rest = trimmed.slice("[harnesstrim reduce] ".length);
+      if (rest.includes(":") && !rest.includes("no reduction")) return rest.split(":")[0].trim();
+    }
+  }
+  return null;
+}
+
+function eventTool(event: Record<string, unknown>): string {
+  return typeof event.toolName === "string" && event.toolName ? event.toolName : "tool_result";
+}
+
+function writeMetric(partial: {
+  tool: string;
+  reducer: string | null;
+  before: number;
+  after: number;
+  changed: boolean;
+  reductionFailed?: boolean;
+}): void {
+  if (!METRICS_PATH) return;
+  try {
+    const event = {
+      schemaVersion: 1,
+      eventId:
+        typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+          ? crypto.randomUUID()
+          : `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      ts: new Date().toISOString(),
+      harness: "omp",
+      tool: partial.tool,
+      reducer: partial.reducer,
+      beforeChars: partial.before,
+      afterChars: partial.after,
+      changed: partial.changed,
+      reductionFailed: partial.reductionFailed ?? false,
+      beforeTokens: null,
+      afterTokens: null,
+    };
+    fs.mkdirSync(path.dirname(path.resolve(METRICS_PATH)), { recursive: true });
+    fs.appendFileSync(METRICS_PATH, JSON.stringify(event) + "\n");
+  } catch {
+    /* telemetry must never break the hook */
+  }
+}
+
+export default function harnessTrim(pi: { on(event: string, handler: (event: unknown) => unknown): void }): void {
+  if (MODE === "off") return;
+  pi.on("tool_result", (event) => {
+    const ev = event as { content?: TextChunk[] };
+    if (!Array.isArray(ev.content)) return;
+    let changed = false;
+    const content = ev.content.map((chunk: TextChunk) => {
+      if (chunk.type !== "text" || typeof chunk.text !== "string") return chunk;
+      const text = chunk.text;
+      if (text.length < MIN_LENGTH || text.includes(MARKER)) return chunk;
+
+      const { output: reduced, reducer, reductionFailed } = reduce(text);
+      if (!reduced || reduced.length >= text.length) {
+        if (METRICS_PATH) {
+          writeMetric({
+            tool: eventTool(ev),
+            reducer: reductionFailed ? reducer : null,
+            before: text.length,
+            after: text.length,
+            changed: false,
+            reductionFailed,
+          });
+        }
+        return chunk;
+      }
+
+      if (MODE === "dryrun") {
+        process.stderr.write(`[harnesstrim] dryrun OMP tool_result: ${text.length} -> ${reduced.length} chars\n`);
+        if (METRICS_PATH) {
+          writeMetric({ tool: eventTool(ev), reducer, before: text.length, after: reduced.length, changed: true });
+        }
+        return chunk;
+      }
+
+      changed = true;
+      if (METRICS_PATH) {
+        writeMetric({ tool: eventTool(ev), reducer, before: text.length, after: reduced.length, changed: true });
+      }
+      return { ...chunk, text: reduced };
+    });
+    return changed ? { content } : undefined;
+  });
+}

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

@@ -7,10 +7,20 @@
 // and loads from `~/.pi/agent/extensions/` or `<project>/.pi/extensions/`.
 //
 // Requires `harnesstrim` on PATH; if it is missing or fails, the output is passed through
-// unchanged (a reducer must never break a tool result). Config via env:
-//   HARNESSTRIM_MODE=dryrun|active|off   (default dryrun — logs, does not mutate)
-//   HARNESSTRIM_MINLENGTH=<chars>        (default 400)
+// unchanged (a reducer must never break a tool result).
+//
+// Config precedence (highest first):
+//   1. Environment: HARNESSTRIM_MODE=dryrun|active|off, HARNESSTRIM_MINLENGTH=<chars>,
+//      HARNESSTRIM_METRICS=<path>   (default dryrun — logs, does not mutate; min 400)
+//   2. config.json beside this file (written by `harnesstrim install pi --apply`
+//      with --mode/--min-length/--metrics)
+//   3. built-in defaults below.
+//
+// --metrics records a TrimEvent JSONL receipt per reduction attempt (read by
+// `harnesstrim metrics`), the receipt that makes interception verifiable.
 import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
 
 type TextContent = { type: "text"; text: string };
 type ToolContent = TextContent | { type: string; [key: string]: unknown };
@@ -25,29 +35,130 @@ interface ExtensionAPI {
 
 const runtime = globalThis as typeof globalThis & { process?: NodeJS.Process };
 const env = runtime.process?.env ?? {};
-const MODE = env.HARNESSTRIM_MODE ?? "dryrun";
-const MIN_LENGTH = Number(env.HARNESSTRIM_MINLENGTH ?? "400") || 400;
 const MARKER = "[harnesstrim";
 
+/** The directory this extension file lives in (the installed extension dir). */
+const HERE =
+  (typeof import.meta !== "undefined" &&
+    (import.meta as { dirname?: string }).dirname) ||
+  "";
+
+interface BakedConfig {
+  mode?: string;
+  minLength?: number;
+  metrics?: string;
+}
+
+function readBakedConfig(): BakedConfig {
+  if (!HERE) return {};
+  try {
+    const raw = fs.readFileSync(path.join(HERE, "config.json"), "utf8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    return {
+      mode: typeof parsed.mode === "string" ? parsed.mode : undefined,
+      minLength: typeof parsed.minLength === "number" ? parsed.minLength : undefined,
+      metrics: typeof parsed.metrics === "string" ? parsed.metrics : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+function resolveMode(baked: BakedConfig): string {
+  return env.HARNESSTRIM_MODE ?? baked.mode ?? "dryrun";
+}
+
+function resolveMinLength(baked: BakedConfig): number {
+  const raw = env.HARNESSTRIM_MINLENGTH ?? (baked.minLength !== undefined ? String(baked.minLength) : "400");
+  return Number(raw) || 400;
+}
+
+function resolveMetricsPath(baked: BakedConfig): string | undefined {
+  return env.HARNESSTRIM_METRICS || baked.metrics || undefined;
+}
+
+// Read the baked config once at load: the file cannot change mid-session without a
+// reinstall, and the env vars are the runtime override.
+const BAKED = readBakedConfig();
+const MODE = resolveMode(BAKED);
+const MIN_LENGTH = resolveMinLength(BAKED);
+const METRICS_PATH = resolveMetricsPath(BAKED);
+
 /** 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 {
+/** Parse the reducer name from `harnesstrim reduce --stats` stderr, if any. */
+function parseReducer(stderr: string): string | null {
+  for (const line of stderr.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[harnesstrim reduce]")) {
+      const rest = trimmed.slice("[harnesstrim reduce] ".length);
+      if (rest.includes(":") && !rest.includes("no reduction")) return rest.split(":")[0].trim();
+    }
+  }
+  return null;
+}
+
+function reduceViaCli(
+  text: string,
+): { output: string | null; reducer: string | null; reductionFailed: boolean } {
   try {
-    const r = spawnSync("harnesstrim", ["reduce", "--min-length", String(MIN_LENGTH)], {
+    const r = spawnSync("harnesstrim", ["reduce", "--min-length", String(MIN_LENGTH), "--stats"], {
       input: text,
       encoding: "utf8",
       timeout: 30000,
     });
     if (r.status === 0 && typeof r.stdout === "string" && r.stdout.length > 0) {
-      return r.stdout.replace(/\n$/, "");
+      const output = r.stdout;
+      const stderr = typeof r.stderr === "string" ? r.stderr : "";
+      const reducer = parseReducer(stderr);
+      return {
+        output,
+        reducer,
+        reductionFailed: stderr.includes("reducer failed; original output preserved"),
+      };
     }
   } catch {
     /* harnesstrim not on PATH or failed — pass through */
   }
-  return null;
+  return { output: null, reducer: null, reductionFailed: false };
+}
+
+/** Append a TrimEvent JSONL receipt (self-contained: no workspace imports allowed). */
+function writeMetric(partial: {
+  tool: string;
+  reducer: string | null;
+  before: number;
+  after: number;
+  changed: boolean;
+  reductionFailed?: boolean;
+}): void {
+  if (!METRICS_PATH) return;
+  try {
+    const event = {
+      schemaVersion: 1,
+      eventId:
+        typeof crypto !== "undefined" && typeof crypto.randomUUID === "function"
+          ? crypto.randomUUID()
+          : `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      ts: new Date().toISOString(),
+      harness: "pi",
+      tool: partial.tool,
+      reducer: partial.reducer,
+      beforeChars: partial.before,
+      afterChars: partial.after,
+      changed: partial.changed,
+      reductionFailed: partial.reductionFailed ?? false,
+      beforeTokens: null,
+      afterTokens: null,
+    };
+    fs.mkdirSync(path.dirname(path.resolve(METRICS_PATH)), { recursive: true });
+    fs.appendFileSync(METRICS_PATH, JSON.stringify(event) + "\n");
+  } catch {
+    /* telemetry must never break the extension */
+  }
 }
 
 export default function harnesstrim(pi: ExtensionAPI): void {
@@ -61,20 +172,46 @@ export default function harnesstrim(pi: ExtensionAPI): void {
       const text = chunk.text;
       if (shouldSkip(text, MIN_LENGTH)) return chunk;
 
-      const reduced = reduceViaCli(text);
-      if (!reduced || reduced.length >= text.length) return chunk;
+      const { output: reduced, reducer, reductionFailed } = reduceViaCli(text);
+      if (!reduced || reduced.length >= text.length) {
+        // A reducer exception is a distinct fail-open event; a no-match is a pass-through.
+        if (METRICS_PATH) {
+          writeMetric({
+            tool: eventTool(event),
+            reducer: reductionFailed ? reducer : null,
+            before: text.length,
+            after: text.length,
+            changed: false,
+            reductionFailed,
+          });
+        }
+        return chunk;
+      }
 
       if (MODE === "dryrun") {
         runtime.process?.stderr?.write(
           `[harnesstrim] dryrun tool_result: ${text.length} -> ${reduced.length} chars\n`
         );
+        // Receipt with the would-be counts — dryrun's value is proof it WOULD reduce.
+        if (METRICS_PATH) {
+          writeMetric({ tool: eventTool(event), reducer, before: text.length, after: reduced.length, changed: true });
+        }
         return chunk;
       }
 
       changed = true;
+      if (METRICS_PATH) {
+        writeMetric({ tool: eventTool(event), reducer, before: text.length, after: reduced.length, changed: true });
+      }
       return { ...chunk, text: reduced };
     });
 
     return changed ? { content } : undefined;
   });
 }
+
+/** Best-effort tool name from the event (Pi's event carries toolName when present). */
+function eventTool(event: ToolResultEvent): string {
+  const name = (event as ToolResultEvent & { toolName?: string }).toolName;
+  return typeof name === "string" && name.length > 0 ? name : "tool_result";
+}