@drewpayment/mink 0.12.0 → 0.13.0-beta.2

package/dist/cli.node.js

@@ -422,6 +422,41 @@ var init_config = __esm(() => {
       envVar: "MINK_PROJECTS_IDENTITY",
       description: "Project identity strategy: path-derived (legacy) or git-remote (stable across machines)",
       scope: "shared"
+    },
+    {
+      key: "compression.enabled",
+      default: "false",
+      envVar: "MINK_COMPRESSION_ENABLED",
+      description: "Enable tool-output compression (spec 21). Off until inline compression ships.",
+      scope: "shared"
+    },
+    {
+      key: "compression.threshold-tokens",
+      default: "800",
+      envVar: "MINK_COMPRESSION_THRESHOLD_TOKENS",
+      description: "Minimum estimated token size before a tool output is eligible for compression",
+      scope: "shared"
+    },
+    {
+      key: "compression.min-savings-ratio",
+      default: "0.25",
+      envVar: "MINK_COMPRESSION_MIN_SAVINGS_RATIO",
+      description: "Discard a compression attempt unless it saves at least this fraction of tokens",
+      scope: "shared"
+    },
+    {
+      key: "compression.holdout-fraction",
+      default: "0.1",
+      envVar: "MINK_COMPRESSION_HOLDOUT_FRACTION",
+      description: "Fraction of eligible outputs left uncompressed as a measured control group",
+      scope: "shared"
+    },
+    {
+      key: "compression.retention-hours",
+      default: "168",
+      envVar: "MINK_COMPRESSION_RETENTION_HOURS",
+      description: "How long compressed originals stay retrievable before eviction",
+      scope: "shared"
     }
   ];
   VALID_KEYS = new Set(CONFIG_KEYS.map((k) => k.key));
@@ -3096,7 +3131,7 @@ function readMeta(db, key) {
 function writeMeta(db, key, value) {
   db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
 }
-var SCHEMA_VERSION = 1, INITIAL_SCHEMA = `
+var SCHEMA_VERSION = 3, INITIAL_SCHEMA = `
 CREATE TABLE IF NOT EXISTS meta (
   key   TEXT PRIMARY KEY,
   value TEXT NOT NULL
@@ -3258,6 +3293,55 @@ CREATE TABLE IF NOT EXISTS counters (
   file_index_hits   INTEGER NOT NULL DEFAULT 0,
   file_index_misses INTEGER NOT NULL DEFAULT 0
 );
+
+-- Tool-output compression measurement (spec 21). One row per compression
+-- decision: either a compressed arm (compressed_tokens < original_tokens) or a
+-- holdout arm (left uncompressed for control, compressed_tokens = original_tokens).
+-- These are append-only telemetry, independent of session lifecycle, written at
+-- the moment a tool output is processed. New table → applied to existing DBs via
+-- IF NOT EXISTS on the next open.
+CREATE TABLE IF NOT EXISTS ledger_compressions (
+  id                TEXT PRIMARY KEY,
+  created_at        TEXT NOT NULL,
+  tool_name         TEXT NOT NULL,
+  content_kind      TEXT NOT NULL,
+  original_tokens   INTEGER NOT NULL DEFAULT 0,
+  compressed_tokens INTEGER NOT NULL DEFAULT 0,
+  holdout           INTEGER NOT NULL DEFAULT 0,
+  device_id         TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_ledger_compressions_created ON ledger_compressions(created_at);
+CREATE INDEX IF NOT EXISTS idx_ledger_compressions_device  ON ledger_compressions(device_id);
+
+-- Per-device compression aggregates, summed across devices like ledger_lifetime.
+-- measured_savings only credits compressed arms (holdout arms save nothing by
+-- construction), so the reported figure is a true measured delta, not an estimate.
+CREATE TABLE IF NOT EXISTS ledger_compression_lifetime (
+  device_id               TEXT PRIMARY KEY,
+  total_events            INTEGER NOT NULL DEFAULT 0,
+  total_holdout_events    INTEGER NOT NULL DEFAULT 0,
+  total_original_tokens   INTEGER NOT NULL DEFAULT 0,
+  total_compressed_tokens INTEGER NOT NULL DEFAULT 0,
+  total_measured_savings  INTEGER NOT NULL DEFAULT 0
+);
+
+-- Reversible-compression cache (spec 21 §Reversibility). When a tool output is
+-- compressed, the original is stored here keyed by a short retrieval token and
+-- embedded in the compressed result; "mink retrieve <token>" returns it
+-- byte-exact. Rows expire after the configured retention window; an expired or
+-- unknown token is a graceful miss. This is a local cache, not synced state, so
+-- (unlike other tables) it carries no merge semantics beyond device_id for audit.
+CREATE TABLE IF NOT EXISTS compression_cache (
+  token        TEXT PRIMARY KEY,
+  created_at   TEXT NOT NULL,
+  expires_at   TEXT NOT NULL,
+  tool_name    TEXT NOT NULL,
+  content_kind TEXT NOT NULL,
+  content      TEXT NOT NULL,
+  size_bytes   INTEGER NOT NULL,
+  device_id    TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_compression_cache_expires ON compression_cache(expires_at);
 `;
 
 // src/storage/migrate-json.ts
@@ -3675,6 +3759,68 @@ class TokenLedgerRepo {
       }
     });
   }
+  recordCompression(event, deviceId = getOrCreateDeviceId()) {
+    const id = event.id ?? crypto.randomUUID();
+    const createdAt = event.createdAt ?? new Date().toISOString();
+    const holdout = event.holdout ? 1 : 0;
+    const savings = event.holdout ? 0 : Math.max(0, event.originalTokens - event.compressedTokens);
+    this.db.transaction(() => {
+      this.db.prepare(`
+        INSERT OR REPLACE INTO ledger_compressions
+          (id, created_at, tool_name, content_kind,
+           original_tokens, compressed_tokens, holdout, device_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(id, createdAt, event.toolName, event.contentKind, event.originalTokens, event.compressedTokens, holdout, deviceId);
+      this.db.prepare(`
+        INSERT INTO ledger_compression_lifetime
+          (device_id, total_events, total_holdout_events,
+           total_original_tokens, total_compressed_tokens, total_measured_savings)
+        VALUES (?, ?, ?, ?, ?, ?)
+        ON CONFLICT(device_id) DO UPDATE SET
+          total_events            = ledger_compression_lifetime.total_events            + excluded.total_events,
+          total_holdout_events    = ledger_compression_lifetime.total_holdout_events    + excluded.total_holdout_events,
+          total_original_tokens   = ledger_compression_lifetime.total_original_tokens   + excluded.total_original_tokens,
+          total_compressed_tokens = ledger_compression_lifetime.total_compressed_tokens + excluded.total_compressed_tokens,
+          total_measured_savings  = ledger_compression_lifetime.total_measured_savings  + excluded.total_measured_savings
+      `).run(deviceId, 1, holdout, event.originalTokens, event.compressedTokens, savings);
+    });
+  }
+  compressionLifetime() {
+    const row = this.db.prepare(`
+      SELECT
+        COALESCE(SUM(total_events),            0) AS totalEvents,
+        COALESCE(SUM(total_holdout_events),    0) AS totalHoldoutEvents,
+        COALESCE(SUM(total_original_tokens),   0) AS totalOriginalTokens,
+        COALESCE(SUM(total_compressed_tokens), 0) AS totalCompressedTokens,
+        COALESCE(SUM(total_measured_savings),  0) AS totalMeasuredSavings
+      FROM ledger_compression_lifetime
+    `).get();
+    return {
+      totalEvents: Number(row?.totalEvents ?? 0),
+      totalHoldoutEvents: Number(row?.totalHoldoutEvents ?? 0),
+      totalOriginalTokens: Number(row?.totalOriginalTokens ?? 0),
+      totalCompressedTokens: Number(row?.totalCompressedTokens ?? 0),
+      totalMeasuredSavings: Number(row?.totalMeasuredSavings ?? 0)
+    };
+  }
+  compressionEvents(limit = 100) {
+    const rows = this.db.prepare(`
+      SELECT id, created_at, tool_name, content_kind,
+             original_tokens, compressed_tokens, holdout
+      FROM ledger_compressions
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(limit);
+    return rows.map((r) => ({
+      id: String(r.id),
+      createdAt: String(r.created_at),
+      toolName: String(r.tool_name),
+      contentKind: String(r.content_kind),
+      originalTokens: Number(r.original_tokens),
+      compressedTokens: Number(r.compressed_tokens),
+      holdout: Number(r.holdout) === 1
+    }));
+  }
   insertSessionRow(summary, deviceId, archived) {
     this.db.prepare(`
       INSERT OR REPLACE INTO ledger_sessions
@@ -4449,6 +4595,28 @@ function estimateTokens2(content, filePath) {
   }
   return Math.ceil(content.length / ratio);
 }
+function countTokens(text) {
+  if (!text)
+    return 0;
+  const segments = text.match(/[A-Za-z]+|[0-9]+|[^A-Za-z0-9]/g);
+  if (!segments)
+    return 0;
+  let tokens = 0;
+  for (const seg of segments) {
+    const first = seg.charCodeAt(0);
+    if (first >= 65 && first <= 90 || first >= 97 && first <= 122) {
+      tokens += Math.ceil(seg.length / 4);
+    } else if (first >= 48 && first <= 57) {
+      tokens += Math.ceil(seg.length / 3);
+    } else if (seg === `
+`) {
+      tokens += 1;
+    } else if (seg === " " || seg === "\t" || seg === "\r") {} else {
+      tokens += 1;
+    }
+  }
+  return tokens;
+}
 var CODE_EXTENSIONS, PROSE_EXTENSIONS, BINARY_EXTENSIONS;
 var init_token_estimate = __esm(() => {
   CODE_EXTENSIONS = new Set([
@@ -5813,12 +5981,14 @@ function buildHooksConfig(cliPath) {
     PostToolUse: [
       { matcher: "Read", hooks: hook(`${prefix} post-read`) },
       { matcher: "Edit", hooks: hook(`${prefix} post-write`) },
-      { matcher: "Write", hooks: hook(`${prefix} post-write`) }
+      { matcher: "Write", hooks: hook(`${prefix} post-write`) },
+      { matcher: "Bash", hooks: hook(`${prefix} post-tool`) },
+      { matcher: "Grep", hooks: hook(`${prefix} post-tool`) }
     ]
   };
 }
 function isMinkCommand(cmd) {
-  const hasMinkSubcommand = cmd.includes("session-start") || cmd.includes("session-stop") || cmd.includes("pre-read") || cmd.includes("post-read") || cmd.includes("pre-write") || cmd.includes("post-write");
+  const hasMinkSubcommand = cmd.includes("session-start") || cmd.includes("session-stop") || cmd.includes("pre-read") || cmd.includes("post-read") || cmd.includes("pre-write") || cmd.includes("post-write") || cmd.includes("post-tool");
   if (!hasMinkSubcommand)
     return false;
   if (/(^|\/|\s)mink\s/.test(cmd))
@@ -7121,6 +7291,488 @@ var init_pre_read = __esm(() => {
   init_counters_repo();
 });
 
+// src/core/compression.ts
+function numberValue(key, fallback, min, max) {
+  const raw = resolveConfigValue(key).value;
+  const n = Number(raw);
+  if (!Number.isFinite(n))
+    return fallback;
+  return Math.min(max, Math.max(min, n));
+}
+function loadCompressionConfig() {
+  return {
+    enabled: resolveConfigValue("compression.enabled").value === "true",
+    thresholdTokens: numberValue("compression.threshold-tokens", 800, 0, Number.MAX_SAFE_INTEGER),
+    minSavingsRatio: numberValue("compression.min-savings-ratio", 0.25, 0, 1),
+    holdoutFraction: numberValue("compression.holdout-fraction", 0.1, 0, 1),
+    retentionHours: numberValue("compression.retention-hours", 168, 0, Number.MAX_SAFE_INTEGER)
+  };
+}
+function isEligible(originalTokens, config) {
+  return config.enabled && originalTokens >= config.thresholdTokens;
+}
+function meetsMinSavings(originalTokens, compressedTokens, config) {
+  if (originalTokens <= 0)
+    return false;
+  const ratio = (originalTokens - compressedTokens) / originalTokens;
+  return ratio >= config.minSavingsRatio;
+}
+function hashUnitInterval(key) {
+  let h = 2166136261;
+  for (let i = 0;i < key.length; i++) {
+    h ^= key.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0) / 4294967296;
+}
+function selectHoldout(eventKey, fraction) {
+  if (fraction <= 0)
+    return false;
+  if (fraction >= 1)
+    return true;
+  return hashUnitInterval(eventKey) < fraction;
+}
+var init_compression = __esm(() => {
+  init_global_config();
+});
+
+// src/core/code-skeleton.ts
+function countChar(s, c) {
+  let n = 0;
+  for (let i = 0;i < s.length; i++)
+    if (s[i] === c)
+      n++;
+  return n;
+}
+function netBraces(line) {
+  let s = line.replace(/\/\/.*$/, "");
+  s = s.replace(/\/\*.*?\*\//g, "");
+  s = s.replace(/"(?:\\.|[^"\\])*"/g, '""');
+  s = s.replace(/'(?:\\.|[^'\\])*'/g, "''");
+  s = s.replace(/`(?:\\.|[^`\\])*`/g, "``");
+  return countChar(s, "{") - countChar(s, "}");
+}
+function stripOpenBrace(sig) {
+  return sig.replace(/\{\s*$/, "").trimEnd();
+}
+function extractCodeSkeleton(content, opts = {}) {
+  const rawLines = content.split(`
+`);
+  const totalLines = rawLines.length > 0 && rawLines[rawLines.length - 1] === "" ? rawLines.length - 1 : rawLines.length;
+  const out = [];
+  let depth = 0;
+  let suppress = Infinity;
+  for (const line of rawLines) {
+    if (out.length >= MAX_SIGNATURES)
+      break;
+    const start = depth;
+    const net = netBraces(line);
+    if (start < suppress) {
+      const isHeading = opts.markdown === true && HEADING.test(line);
+      const captured = isHeading || DECL_ALWAYS.test(line) || DECL_EXPORTED_VAR.test(line) || start >= 1 && MEMBER.test(line);
+      if (captured) {
+        const sig = line.trim();
+        if (net > 0) {
+          if (DESCEND.test(line) && !isHeading) {
+            out.push(INDENT.repeat(start) + stripOpenBrace(sig) + " {");
+          } else {
+            out.push(INDENT.repeat(start) + stripOpenBrace(sig) + " { … }");
+            suppress = start + 1;
+          }
+        } else {
+          out.push(INDENT.repeat(start) + sig);
+        }
+      }
+    }
+    depth = Math.max(0, depth + net);
+    if (depth < suppress)
+      suppress = Infinity;
+  }
+  if (out.length === 0)
+    return null;
+  return { lines: out, totalLines };
+}
+var MAX_SIGNATURES = 80, INDENT = "  ", DECL_ALWAYS, DECL_EXPORTED_VAR, MEMBER, HEADING, DESCEND;
+var init_code_skeleton = __esm(() => {
+  DECL_ALWAYS = /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?(?:async\s+)?(?:function|class|interface|type|enum|namespace|module|def|fn|func|impl|struct|trait)\b/;
+  DECL_EXPORTED_VAR = /^\s*export\s+(?:default\s+)?(?:const|let|var)\b/;
+  MEMBER = /^\s*(?:public\s+|private\s+|protected\s+|readonly\s+|static\s+|async\s+|get\s+|set\s+|#)*[\w$]+\??\s*(?:\(|:|=)/;
+  HEADING = /^#{1,6}\s+\S/;
+  DESCEND = /\b(?:class|interface|enum|namespace|module|struct|trait|impl)\b/;
+});
+
+// src/core/output-compression.ts
+function stripAnsi(s) {
+  return s.replace(ANSI, "");
+}
+function omittedMarker(n) {
+  return `  … ${n} line${n === 1 ? "" : "s"} omitted — mink retrieve …`;
+}
+function toLines(content) {
+  const lines = content.split(`
+`);
+  if (lines.length > 0 && lines[lines.length - 1] === "")
+    lines.pop();
+  return lines;
+}
+function compressLog(content) {
+  const lines = toLines(stripAnsi(content));
+  const collapsed = [];
+  let i = 0;
+  while (i < lines.length) {
+    let run = 1;
+    while (i + run < lines.length && lines[i + run] === lines[i])
+      run++;
+    collapsed.push(run > 1 ? `${lines[i]}  (×${run})` : lines[i]);
+    i += run;
+  }
+  if (collapsed.length <= LOG_HEAD + LOG_TAIL) {
+    if (collapsed.length === lines.length)
+      return null;
+    return {
+      compressed: collapsed.join(`
+`),
+      omittedNote: `collapsed ${lines.length - collapsed.length} repeated line(s)`
+    };
+  }
+  const omitted = collapsed.length - LOG_HEAD - LOG_TAIL;
+  const head = collapsed.slice(0, LOG_HEAD);
+  const tail = collapsed.slice(collapsed.length - LOG_TAIL);
+  return {
+    compressed: [...head, omittedMarker(omitted), ...tail].join(`
+`),
+    omittedNote: `${omitted} of ${collapsed.length} log line(s) omitted (middle)`
+  };
+}
+function compressSearch(content) {
+  const lines = toLines(content);
+  const seen = new Set;
+  const perFile = new Map;
+  const omittedByFile = new Map;
+  const out = [];
+  for (const line of lines) {
+    if (seen.has(line))
+      continue;
+    seen.add(line);
+    const colon = line.indexOf(":");
+    const file = colon > 0 ? line.slice(0, colon) : line;
+    const count = perFile.get(file) ?? 0;
+    if (count < SEARCH_MAX_PER_FILE) {
+      perFile.set(file, count + 1);
+      out.push(line);
+    } else {
+      omittedByFile.set(file, (omittedByFile.get(file) ?? 0) + 1);
+    }
+  }
+  let totalOmitted = 0;
+  for (const [file, n] of omittedByFile) {
+    totalOmitted += n;
+    out.push(`  … +${n} more match(es) in ${file} — mink retrieve …`);
+  }
+  const dedupRemoved = lines.length - seen.size;
+  if (totalOmitted === 0 && dedupRemoved === 0)
+    return null;
+  const notes = [];
+  if (totalOmitted > 0)
+    notes.push(`${totalOmitted} match(es) capped`);
+  if (dedupRemoved > 0)
+    notes.push(`${dedupRemoved} duplicate(s) removed`);
+  return { compressed: out.join(`
+`), omittedNote: notes.join("; ") };
+}
+function compressFile(filePath, content) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  const markdown = ext === ".md" || ext === ".mdx" || ext === ".markdown";
+  const skeleton = extractCodeSkeleton(content, { markdown });
+  if (!skeleton) {
+    return compressText(content);
+  }
+  const header = `${filePath} — structural summary ` + `(${skeleton.lines.length} signature(s) of ${skeleton.totalLines} lines)`;
+  return {
+    compressed: [header, ...skeleton.lines].join(`
+`),
+    omittedNote: `bodies elided; ${skeleton.totalLines} lines available via mink retrieve`
+  };
+}
+function crush(value) {
+  if (Array.isArray(value)) {
+    let omitted = 0;
+    const mapEl = (el) => {
+      const r = crush(el);
+      omitted += r.omitted;
+      return r.value;
+    };
+    if (value.length <= JSON_ARRAY_HEAD + JSON_ARRAY_TAIL) {
+      return { value: value.map(mapEl), omitted };
+    }
+    const dropped = value.length - JSON_ARRAY_HEAD - JSON_ARRAY_TAIL;
+    omitted += dropped;
+    const out = [
+      ...value.slice(0, JSON_ARRAY_HEAD).map(mapEl),
+      `… ${dropped} element(s) omitted — mink retrieve …`,
+      ...value.slice(value.length - JSON_ARRAY_TAIL).map(mapEl)
+    ];
+    return { value: out, omitted };
+  }
+  if (value && typeof value === "object") {
+    let omitted = 0;
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      const r = crush(v);
+      omitted += r.omitted;
+      out[k] = r.value;
+    }
+    return { value: out, omitted };
+  }
+  return { value, omitted: 0 };
+}
+function compressJson(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  const { value, omitted } = crush(parsed);
+  if (omitted === 0)
+    return null;
+  return {
+    compressed: JSON.stringify(value, null, 2),
+    omittedNote: `${omitted} array element(s) sampled out`
+  };
+}
+function compressText(content) {
+  const lines = toLines(content);
+  if (lines.length <= TEXT_HEAD + TEXT_TAIL)
+    return null;
+  const omitted = lines.length - TEXT_HEAD - TEXT_TAIL;
+  const head = lines.slice(0, TEXT_HEAD);
+  const tail = lines.slice(lines.length - TEXT_TAIL);
+  return {
+    compressed: [...head, omittedMarker(omitted), ...tail].join(`
+`),
+    omittedNote: `${omitted} of ${lines.length} line(s) omitted (middle)`
+  };
+}
+function detectContentKind(toolName, content, filePath) {
+  const t = toolName.toLowerCase();
+  if (t === "read")
+    return "file";
+  if (t === "grep" || t === "glob")
+    return "search";
+  if (t === "bash")
+    return "log";
+  const head = content.trimStart()[0];
+  if (head === "{" || head === "[") {
+    try {
+      JSON.parse(content);
+      return "json";
+    } catch {}
+  }
+  if (filePath)
+    return "file";
+  return "text";
+}
+function compressOutput(toolName, content, filePath) {
+  const kind = detectContentKind(toolName, content, filePath);
+  let result;
+  switch (kind) {
+    case "search":
+      result = compressSearch(content);
+      break;
+    case "log":
+      result = compressLog(content);
+      break;
+    case "file":
+      result = compressFile(filePath ?? "file", content);
+      break;
+    case "json":
+      result = compressJson(content);
+      break;
+    case "text":
+      result = compressText(content);
+      break;
+  }
+  if (!result)
+    return null;
+  return { kind, compressed: result.compressed, omittedNote: result.omittedNote };
+}
+var SEARCH_MAX_PER_FILE = 5, LOG_HEAD = 40, LOG_TAIL = 40, TEXT_HEAD = 30, TEXT_TAIL = 20, JSON_ARRAY_HEAD = 20, JSON_ARRAY_TAIL = 5, ANSI;
+var init_output_compression = __esm(() => {
+  init_code_skeleton();
+  ANSI = /\[[0-9;?]*[ -/]*[@-~]/g;
+});
+
+// src/repositories/compression-cache-repo.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
+class CompressionCacheRepo {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  static for(cwd) {
+    return new CompressionCacheRepo(openProjectDb(cwd));
+  }
+  static newToken() {
+    return `mc-${randomUUID3().slice(0, 8)}`;
+  }
+  store(input, deviceId = getOrCreateDeviceId()) {
+    const token = input.token ?? CompressionCacheRepo.newToken();
+    const now = input.now ?? new Date;
+    const createdAt = now.toISOString();
+    const expiresAt = new Date(now.getTime() + Math.max(0, input.retentionHours) * 3600000).toISOString();
+    this.db.prepare(`
+      INSERT OR REPLACE INTO compression_cache
+        (token, created_at, expires_at, tool_name, content_kind,
+         content, size_bytes, device_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(token, createdAt, expiresAt, input.toolName, input.contentKind, input.content, Buffer.byteLength(input.content, "utf-8"), deviceId);
+    return token;
+  }
+  get(token, now = new Date) {
+    const row = this.db.prepare("SELECT * FROM compression_cache WHERE token = ?").get(token);
+    if (!row)
+      return null;
+    const expiresAt = String(row.expires_at);
+    if (expiresAt <= now.toISOString()) {
+      try {
+        this.db.prepare("DELETE FROM compression_cache WHERE token = ?").run(token);
+      } catch {}
+      return null;
+    }
+    return {
+      token: String(row.token),
+      createdAt: String(row.created_at),
+      expiresAt,
+      toolName: String(row.tool_name),
+      contentKind: String(row.content_kind),
+      content: String(row.content),
+      sizeBytes: Number(row.size_bytes)
+    };
+  }
+  evictExpired(now = new Date) {
+    const r = this.db.prepare("DELETE FROM compression_cache WHERE expires_at <= ?").run(now.toISOString());
+    return Number(r.changes);
+  }
+  count() {
+    const row = this.db.prepare("SELECT COUNT(*) AS n FROM compression_cache").get();
+    return Number(row.n);
+  }
+}
+var init_compression_cache_repo = __esm(() => {
+  init_db();
+  init_device();
+});
+
+// src/core/compress-tool-output.ts
+function contentKey(s) {
+  let h = 2166136261;
+  for (let i = 0;i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function render(result, token) {
+  return result.compressed + `
+
+` + `— mink: compressed ${result.kind} output (${result.omittedNote}). ` + `Full original: mink retrieve ${token}`;
+}
+function safeRecord(cwd, toolName, contentKind, originalTokens, compressedTokens, holdout) {
+  try {
+    TokenLedgerRepo.for(cwd).recordCompression({
+      toolName,
+      contentKind,
+      originalTokens,
+      compressedTokens,
+      holdout
+    });
+  } catch {}
+}
+function compressToolOutput(cwd, toolName, output, filePath) {
+  let cfg;
+  try {
+    cfg = loadCompressionConfig();
+  } catch {
+    return null;
+  }
+  if (!cfg.enabled)
+    return null;
+  if (typeof output !== "string" || output.length === 0)
+    return null;
+  const originalTokens = countTokens(output);
+  if (!isEligible(originalTokens, cfg))
+    return null;
+  const eventKey = contentKey(output);
+  if (selectHoldout(eventKey, cfg.holdoutFraction)) {
+    const kind = detectContentKind(toolName, output, filePath);
+    safeRecord(cwd, toolName, kind, originalTokens, originalTokens, true);
+    return null;
+  }
+  const result = compressOutput(toolName, output, filePath);
+  if (!result)
+    return null;
+  const token = CompressionCacheRepo.newToken();
+  const replacement = render(result, token);
+  const compressedTokens = countTokens(replacement);
+  if (!meetsMinSavings(originalTokens, compressedTokens, cfg))
+    return null;
+  try {
+    CompressionCacheRepo.for(cwd).store({
+      toolName,
+      contentKind: result.kind,
+      content: output,
+      retentionHours: cfg.retentionHours,
+      token
+    });
+  } catch {
+    return null;
+  }
+  safeRecord(cwd, toolName, result.kind, originalTokens, compressedTokens, false);
+  return { updatedToolOutput: replacement, token };
+}
+var init_compress_tool_output = __esm(() => {
+  init_compression();
+  init_token_estimate();
+  init_output_compression();
+  init_compression_cache_repo();
+  init_token_ledger_repo();
+});
+
+// src/core/hook-output.ts
+function extractToolOutputText(input) {
+  const tr = input.tool_response;
+  if (tr) {
+    if (typeof tr.content === "string")
+      return tr.content;
+    if (Array.isArray(tr.content)) {
+      const parts = tr.content.map((p) => p && typeof p.text === "string" ? p.text : "").filter((s) => s.length > 0);
+      if (parts.length > 0)
+        return parts.join("");
+    }
+    if (typeof tr.stdout === "string" && tr.stdout.length > 0)
+      return tr.stdout;
+    if (typeof tr.text === "string")
+      return tr.text;
+    const file = tr.file;
+    if (file && typeof file.content === "string")
+      return file.content;
+  }
+  const to = input.tool_output;
+  if (to && typeof to.content === "string")
+    return to.content;
+  return null;
+}
+function emitUpdatedToolOutput(text) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      updatedToolOutput: text
+    }
+  }));
+}
+
 // src/commands/post-read.ts
 var exports_post_read = {};
 __export(exports_post_read, {
@@ -7250,6 +7902,14 @@ async function postRead(cwd) {
       logWriter.appendReadEntry(new Date().toISOString(), filePath, result.indexHit, result.estimatedTokens);
     } catch {}
     atomicWriteJson(sessionPath(cwd), state);
+    const isRanged = input.tool_input.offset != null || input.tool_input.limit != null;
+    if (!isRanged && content && content.length > 0) {
+      try {
+        const outcome = compressToolOutput(cwd, "Read", content, filePath);
+        if (outcome)
+          emitUpdatedToolOutput(outcome.updatedToolOutput);
+      } catch {}
+    }
   } catch {} finally {
     clearTimeout(timer);
   }
@@ -7263,6 +7923,43 @@ var init_post_read = __esm(() => {
   init_description();
   init_action_log();
   init_device();
+  init_compress_tool_output();
+});
+
+// src/commands/post-tool.ts
+var exports_post_tool = {};
+__export(exports_post_tool, {
+  postTool: () => postTool
+});
+function isPostToolUseInput2(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const obj = value;
+  return typeof obj.tool_name === "string";
+}
+function isCompressibleTool(toolName) {
+  return toolName === "Bash" || toolName === "Grep" || toolName === "Glob" || toolName.startsWith("mcp__");
+}
+async function postTool(cwd) {
+  const timer = setTimeout(() => process.exit(0), 5000);
+  try {
+    const input = await readStdinJson();
+    if (!isPostToolUseInput2(input))
+      return;
+    if (!isCompressibleTool(input.tool_name))
+      return;
+    const output = extractToolOutputText(input);
+    if (!output)
+      return;
+    const outcome = compressToolOutput(cwd, input.tool_name, output);
+    if (outcome)
+      emitUpdatedToolOutput(outcome.updatedToolOutput);
+  } catch {} finally {
+    clearTimeout(timer);
+  }
+}
+var init_post_tool = __esm(() => {
+  init_compress_tool_output();
 });
 
 // src/core/pattern-engine.ts
@@ -7501,7 +8198,7 @@ function analyzePostWrite(filePath, fileContent, index) {
     indexEntry
   };
 }
-function isPostToolUseInput2(value) {
+function isPostToolUseInput3(value) {
   if (value === null || typeof value !== "object")
     return false;
   const obj = value;
@@ -7515,7 +8212,7 @@ async function postWrite(cwd) {
   const timer = setTimeout(() => process.exit(0), 1e4);
   try {
     const input = await readStdinJson();
-    if (!isPostToolUseInput2(input))
+    if (!isPostToolUseInput3(input))
       return;
     if (input.tool_name !== "Write" && input.tool_name !== "Edit")
       return;
@@ -7744,6 +8441,35 @@ var init_detect_waste = __esm(() => {
   init_device();
 });
 
+// src/commands/retrieve.ts
+var exports_retrieve = {};
+__export(exports_retrieve, {
+  retrieve: () => retrieve
+});
+function retrieve(cwd, args) {
+  const token = args[0];
+  if (!token) {
+    process.stderr.write(`[mink] usage: mink retrieve <token>
+`);
+    return;
+  }
+  let entry = null;
+  try {
+    entry = CompressionCacheRepo.for(cwd).get(token);
+  } catch {
+    entry = null;
+  }
+  if (!entry) {
+    process.stderr.write(`[mink] no retrievable output for token "${token}" (unknown or expired)
+`);
+    return;
+  }
+  process.stdout.write(entry.content);
+}
+var init_retrieve = __esm(() => {
+  init_compression_cache_repo();
+});
+
 // src/core/cron-parser.ts
 function parseField(field, min, max) {
   const values = new Set;
@@ -10654,12 +11380,14 @@ function buildHooksConfig2(cliPath) {
     PostToolUse: [
       { matcher: "Read", hooks: hook(`${prefix} post-read`) },
       { matcher: "Edit", hooks: hook(`${prefix} post-write`) },
-      { matcher: "Write", hooks: hook(`${prefix} post-write`) }
+      { matcher: "Write", hooks: hook(`${prefix} post-write`) },
+      { matcher: "Bash", hooks: hook(`${prefix} post-tool`) },
+      { matcher: "Grep", hooks: hook(`${prefix} post-tool`) }
     ]
   };
 }
 function isMinkCommand2(cmd) {
-  const hasMinkSubcommand = cmd.includes("session-start") || cmd.includes("session-stop") || cmd.includes("pre-read") || cmd.includes("post-read") || cmd.includes("pre-write") || cmd.includes("post-write");
+  const hasMinkSubcommand = cmd.includes("session-start") || cmd.includes("session-stop") || cmd.includes("pre-read") || cmd.includes("post-read") || cmd.includes("pre-write") || cmd.includes("post-write") || cmd.includes("post-tool");
   if (!hasMinkSubcommand)
     return false;
   if (/(^|\/|\s)mink\s/.test(cmd))
@@ -77088,7 +77816,7 @@ var require_dist10 = __commonJS((exports) => {
   exports.PacProxyAgent = undefined;
   var net = __importStar(__require("net"));
   var tls = __importStar(__require("tls"));
-  var crypto = __importStar(__require("crypto"));
+  var crypto2 = __importStar(__require("crypto"));
   var events_1 = __require("events");
   var debug_1 = __importDefault(require_src());
   var url_1 = __require("url");
@@ -77138,7 +77866,7 @@ var require_dist10 = __commonJS((exports) => {
           (0, quickjs_emscripten_1.getQuickJS)(),
           this.loadPacFile()
         ]);
-        const hash = crypto.createHash("sha1").update(code).digest("hex");
+        const hash = crypto2.createHash("sha1").update(code).digest("hex");
         if (this.resolver && this.resolverHash === hash) {
           debug2("Same sha1 hash for code - contents have not changed, reusing previous proxy resolver");
           return this.resolver;
@@ -84409,12 +85137,12 @@ var init_lib = __esm(() => {
 });
 
 // node_modules/cliui/build/lib/string-utils.js
-function stripAnsi(str) {
+function stripAnsi2(str) {
   return str.replace(ansi, "");
 }
 function wrap(str, width) {
   const [start, end] = str.match(ansi) || ["", ""];
-  str = stripAnsi(str);
+  str = stripAnsi2(str);
   let wrapped = "";
   for (let i = 0;i < str.length; i++) {
     if (i !== 0 && i % width === 0) {
@@ -84439,7 +85167,7 @@ function ui(opts) {
     stringWidth: (str) => {
       return [...str].length;
     },
-    stripAnsi,
+    stripAnsi: stripAnsi2,
     wrap
   });
 }
@@ -93860,6 +94588,11 @@ switch (command2) {
     await postRead2(cwd);
     break;
   }
+  case "post-tool": {
+    const { postTool: postTool2 } = await Promise.resolve().then(() => (init_post_tool(), exports_post_tool));
+    await postTool2(cwd);
+    break;
+  }
   case "pre-write": {
     const { preWrite: preWrite2 } = await Promise.resolve().then(() => (init_pre_write(), exports_pre_write));
     await preWrite2(cwd);
@@ -93875,6 +94608,11 @@ switch (command2) {
     detectWaste3(cwd);
     break;
   }
+  case "retrieve": {
+    const { retrieve: retrieve2 } = await Promise.resolve().then(() => (init_retrieve(), exports_retrieve));
+    retrieve2(cwd, process.argv.slice(3));
+    break;
+  }
   case "cron": {
     const { cron: cron2 } = await Promise.resolve().then(() => (init_cron(), exports_cron));
     await cron2(cwd, process.argv.slice(3));
@@ -94044,6 +94782,7 @@ switch (command2) {
     console.log("  restore [backup]        Restore state from a backup");
     console.log("  bug search <term>       Search the bug log");
     console.log("  detect-waste            Detect and flag wasteful patterns");
+    console.log("  retrieve <token>        Return a compressed tool output's original (spec 21)");
     console.log("  reflect                 Generate learning memory reflections");
     console.log("  designqc [target]       Capture design screenshots (spec 13)");
     console.log("  framework-advisor       Generate framework advisor knowledge file (spec 14)");
@@ -94053,6 +94792,7 @@ switch (command2) {
     console.log("  session-stop            Finalize session and log data");
     console.log("  pre-read / post-read    File read hooks");
     console.log("  pre-write / post-write  File write hooks");
+    console.log("  post-tool               Tool-output compression hook (Bash/Grep/MCP, spec 21)");
     break;
   default:
     console.error(`[mink] unknown command: ${command2 ?? "(none)"}`);