@intentic/claude-plugin 1.317.0

package/dist/stats.mjs

@@ -0,0 +1,1847 @@
+import { createRequire as __intenticRequire } from 'node:module'; const require = __intenticRequire(import.meta.url);
+
+// src/stats.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
+import { join as join8 } from "node:path";
+
+// ../agent-context/src/arm-stats.ts
+var MIN_ARM_TURNS = 30;
+var Z_95 = 1.96;
+var round1 = (value) => Math.round(value * 10) / 10;
+var SEARCH_CALLS = { name: "searchCalls", of: (turn) => turn.searchCalls, round: round1 };
+var OPENING_SEARCHES = { name: "openingSearches", of: (turn) => turn.openingSearches, round: round1 };
+var ROOT_LISTINGS = { name: "openingListings", of: (turn) => turn.openingListings, round: round1 };
+var CALLS_BEFORE_TARGET = { name: "callsBeforeTarget", of: (turn) => turn.callsBeforeTarget, round: round1 };
+var FAILED_CALLS = { name: "failedCalls", of: (turn) => turn.failedCalls, round: round1 };
+var armOfValues = (values) => {
+  if (values.length === 0) {
+    return { turns: 0, mean: 0, variance: 0 };
+  }
+  const mean = values.reduce((sum2, value) => sum2 + value, 0) / values.length;
+  const variance = values.length < 2 ? 0 : values.reduce((sum2, value) => sum2 + (value - mean) ** 2, 0) / (values.length - 1);
+  return { turns: values.length, mean, variance };
+};
+var RESOLVING_MARGIN_PCT = 10;
+var controlTurnsNeededFor = (offTurns, marginPct) => {
+  if (marginPct <= RESOLVING_MARGIN_PCT) {
+    return void 0;
+  }
+  return Math.ceil(offTurns * (marginPct / RESOLVING_MARGIN_PCT) ** 2) - offTurns;
+};
+var readingOfArms = (on, off, metric, claimRealizedSaving) => {
+  const arms = {
+    metric: metric.name,
+    on: { turns: on.turns, mean: metric.round(on.mean) },
+    off: { turns: off.turns, mean: metric.round(off.mean) }
+  };
+  if (on.turns < MIN_ARM_TURNS || off.turns < MIN_ARM_TURNS || off.mean === 0) {
+    return arms;
+  }
+  const standardError = Math.sqrt(on.variance / on.turns + off.variance / off.turns);
+  const deltaPct = round1((on.mean - off.mean) / off.mean * 100);
+  const marginPct = round1(Z_95 * standardError / off.mean * 100);
+  if (Math.abs(deltaPct) <= marginPct) {
+    const controlTurnsNeeded = controlTurnsNeededFor(off.turns, marginPct);
+    return { ...arms, marginPct, ...controlTurnsNeeded !== void 0 ? { controlTurnsNeeded } : {} };
+  }
+  return {
+    ...arms,
+    marginPct,
+    deltaPct,
+    ...claimRealizedSaving ? { saved: metric.round((off.mean - on.mean) * on.turns) } : {}
+  };
+};
+var meanOfTurns = (turns, metric) => {
+  const measured = turns.map(metric.of).filter((value) => value !== void 0);
+  return measured.length === 0 ? void 0 : measured.reduce((sum2, value) => sum2 + value, 0) / measured.length;
+};
+var openingTurn = (turns, metric) => {
+  const opening = turns.filter((turn) => turn.turnIndex === 0).toSorted((left, right) => left.at - right.at)[0];
+  return opening === void 0 ? void 0 : metric.of(opening);
+};
+var MECHANISMS = {
+  // The search teaching rides every turn, so every turn is evidence.
+  search: { metrics: [SEARCH_CALLS, OPENING_SEARCHES], sampleUnit: "conversations", sample: meanOfTurns },
+  // The map is sent once and judged on the turn it was sent to; `callsBeforeTarget` exists only on turns that edited.
+  map: { metrics: [ROOT_LISTINGS, CALLS_BEFORE_TARGET], sampleUnit: "opening turns", sample: openingTurn },
+  // The brief rides the whole session, so turn 40 is as much evidence as turn 1.
+  notes: { metrics: [FAILED_CALLS, CALLS_BEFORE_TARGET], sampleUnit: "conversations", sample: meanOfTurns },
+  // Judged on what the long form was written to prevent: calls that fail, and calls spent before reaching the work.
+  guidance: { metrics: [FAILED_CALLS, CALLS_BEFORE_TARGET], sampleUnit: "conversations", sample: meanOfTurns }
+};
+var measureExperiment = (turns, design) => {
+  const latest = turns.filter((turn) => design.arm(turn) !== void 0 && design.cohort(turn) !== void 0).toSorted((left, right) => right.at - left.at)[0];
+  const cohort = latest === void 0 ? void 0 : design.cohort(latest);
+  const cohortTurns = cohort === void 0 ? turns.filter((turn) => design.cohort(turn) === void 0) : turns.filter((turn) => design.cohort(turn) === cohort);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const turn of cohortTurns) {
+    const arm = design.arm(turn);
+    if (turn.conversationId === void 0 || arm === void 0) {
+      continue;
+    }
+    const current = grouped.get(turn.conversationId);
+    if (current === void 0) {
+      grouped.set(turn.conversationId, { arm, valid: true, turns: [turn] });
+    } else {
+      current.valid &&= current.arm === arm;
+      current.turns.push(turn);
+    }
+  }
+  const samples = [...grouped.values()].filter((entry) => entry.valid).map((entry) => ({ arm: entry.arm, turns: entry.turns }));
+  if (samples.length === 0) {
+    return void 0;
+  }
+  const reading = (metric) => {
+    const values = (arm) => samples.flatMap((sample) => {
+      const value = sample.arm === arm ? design.sample(sample.turns, metric) : void 0;
+      return value === void 0 ? [] : [value];
+    });
+    return readingOfArms(armOfValues(values(true)), armOfValues(values(false)), metric, false);
+  };
+  const [headline, ...rest] = design.metrics;
+  return {
+    metrics: [reading(headline), ...rest.map(reading)],
+    minTurns: MIN_ARM_TURNS,
+    sampleUnit: design.sampleUnit,
+    ...cohort !== void 0 ? { cohort } : {}
+  };
+};
+
+// ../agent-context/src/claude-transcript.ts
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+// ../agent-context/src/tool-calls.ts
+import { isAbsolute, relative } from "node:path";
+var DISPLAY_NAMES = {
+  bash: "Bash",
+  edit: "Edit",
+  write: "Write",
+  read: "Read",
+  grep: "Grep",
+  glob: "Glob",
+  list: "LS",
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+  task: "Task",
+  patch: "Edit"
+};
+var BROWSER_TOOL = /^mcp__.+__browser_(.+)$/;
+var BROWSER_VERB_NAMES = { take_screenshot: "screenshot" };
+var browserDisplayName = (raw) => {
+  const verb = BROWSER_TOOL.exec(raw)?.[1];
+  return verb === void 0 ? void 0 : `Browser ${(BROWSER_VERB_NAMES[verb] ?? verb).replaceAll("_", " ")}`;
+};
+var displayNameOf = (raw) => DISPLAY_NAMES[raw] ?? browserDisplayName(raw) ?? raw;
+var CATEGORIES = [
+  ["read", "read"],
+  ["edit", "edit"],
+  ["write", "edit"],
+  ["multiedit", "edit"],
+  ["notebookedit", "edit"],
+  ["bash", "execute"],
+  ["bashoutput", "execute"],
+  ["killshell", "execute"],
+  ["grep", "search"],
+  ["glob", "search"],
+  ["ls", "search"],
+  ["websearch", "search"],
+  ["webfetch", "fetch"],
+  ["task", "other"]
+];
+var CATEGORY_BY_NAME = new Map(CATEGORIES);
+var MCP_VERBS = [
+  ["edit", "edit"],
+  ["write", "edit"],
+  ["read", "read"],
+  ["search", "search"],
+  ["fetch", "fetch"],
+  ["delete", "delete"],
+  ["move", "move"],
+  ["run", "execute"],
+  ["exec", "execute"]
+];
+var BROWSER_VERB_KINDS = {
+  navigate: "fetch",
+  navigate_back: "fetch",
+  snapshot: "read",
+  take_screenshot: "read",
+  console_messages: "read",
+  network_requests: "read",
+  network_request: "read",
+  tabs: "read"
+};
+var toolCategoryOf = (name) => {
+  const exact = CATEGORY_BY_NAME.get(name.toLowerCase());
+  if (exact !== void 0) {
+    return exact;
+  }
+  const browserVerb = BROWSER_TOOL.exec(name)?.[1];
+  if (browserVerb !== void 0) {
+    return BROWSER_VERB_KINDS[browserVerb] ?? "execute";
+  }
+  const segment = name.includes("__") ? name.split("__").pop() : name.includes(".") ? name.split(".").pop() : void 0;
+  if (segment === void 0) {
+    return "other";
+  }
+  const verb = segment.toLowerCase();
+  for (const [suffix, kind] of MCP_VERBS) {
+    if (verb === suffix || verb.endsWith(suffix)) {
+      return kind;
+    }
+  }
+  return "other";
+};
+var SEARCH_COMMANDS = /* @__PURE__ */ new Set(["iq", "grep", "rg", "ag", "ack", "find", "fd", "fdfind", "locate", "ls", "tree"]);
+var FILE_WORK_COMMANDS = /* @__PURE__ */ new Set(["cat", "sed", "head", "tail", "less", "more", "bat", "awk"]);
+var statementsOf = (command) => command.split(/&&|\|\||;|\n/);
+var commandHeads = (command) => statementsOf(command).map((statement) => {
+  const head = statement.trim().split(/\s+/).find((word) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) ?? "";
+  return head.split("/").pop() ?? head;
+});
+var isSearchCall = (call) => {
+  if (call.category === "search") {
+    return true;
+  }
+  if (call.category !== "execute" || call.target === void 0) {
+    return false;
+  }
+  return commandHeads(call.target).some((head) => SEARCH_COMMANDS.has(head));
+};
+var LISTING_COMMANDS = /* @__PURE__ */ new Set(["ls", "tree"]);
+var LISTING_TOOLS = /* @__PURE__ */ new Set(["ls", "list"]);
+var depthBelow = (raw, root) => {
+  const path = raw.replace(/^["']|["']$/g, "").replace(/\/+$/, "");
+  if (path === "" || path === "." || path === "./") {
+    return 0;
+  }
+  const rel = isAbsolute(path) ? relative(root, path) : path.replace(/^\.\//, "");
+  if (rel === "") {
+    return 0;
+  }
+  return rel === ".." || rel.startsWith("../") ? void 0 : rel.split("/").length;
+};
+var isRootListing = (call, root) => {
+  const shallow = (path) => {
+    const depth = depthBelow(path, root);
+    return depth !== void 0 && depth <= 1;
+  };
+  if (call.name !== void 0 && LISTING_TOOLS.has(call.name.toLowerCase())) {
+    return call.target === void 0 || shallow(call.target);
+  }
+  if (call.category !== "execute" || call.target === void 0) {
+    return false;
+  }
+  return statementsOf(call.target).some((statement) => {
+    const words = (statement.split("|")[0] ?? "").trim().split(/\s+/);
+    const head = words.find((word) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(word)) ?? "";
+    if (!LISTING_COMMANDS.has(head.split("/").pop() ?? head)) {
+      return false;
+    }
+    const args = words.slice(words.indexOf(head) + 1).filter((word) => word !== "" && !word.startsWith("-"));
+    return args.length === 0 ? true : !args.some((arg) => arg.includes("*")) && args.some(shallow);
+  });
+};
+var isFileWorkCall = (call) => {
+  if (call.category === "read" || call.category === "edit") {
+    return true;
+  }
+  if (call.category !== "execute" || call.target === void 0) {
+    return false;
+  }
+  return commandHeads(call.target).some((head) => FILE_WORK_COMMANDS.has(head));
+};
+var searchPrecedesFileWork = (call) => {
+  if (call.category === "search") {
+    return true;
+  }
+  if (call.category !== "execute" || call.target === void 0) {
+    return false;
+  }
+  const heads = commandHeads(call.target);
+  const searchAt = heads.findIndex((head) => SEARCH_COMMANDS.has(head));
+  const workAt = heads.findIndex((head) => FILE_WORK_COMMANDS.has(head));
+  return searchAt !== -1 && (workAt === -1 || searchAt < workAt);
+};
+var TARGET_KEYS = ["file_path", "filePath", "notebook_path", "command", "pattern", "url", "element", "path", "query"];
+var toolTarget = (input) => {
+  if (typeof input !== "object" || input === null) {
+    return void 0;
+  }
+  const record = input;
+  for (const key of TARGET_KEYS) {
+    const value = record[key];
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return void 0;
+};
+var PATH_KEYS = ["file_path", "filePath", "notebook_path", "path"];
+var toolPathsUnder = (input, root) => {
+  if (typeof input !== "object" || input === null) {
+    return void 0;
+  }
+  const record = input;
+  for (const key of PATH_KEYS) {
+    const value = record[key];
+    if (typeof value !== "string") {
+      continue;
+    }
+    const rel = isAbsolute(value) ? relative(root, value) : value;
+    return rel === "" || rel === "." || rel === ".." || rel.startsWith("../") || isAbsolute(rel) ? void 0 : [{ path: rel.split("\\").join("/") }];
+  }
+  return void 0;
+};
+
+// ../agent-context/src/claude-transcript.ts
+var FAILURE_TEXT_CHARS = 400;
+var stampOf = (line) => {
+  const at = line.timestamp === void 0 ? Number.NaN : Date.parse(line.timestamp);
+  return Number.isNaN(at) ? void 0 : at;
+};
+var textOf = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((block) => block["type"] === "text" && typeof block["text"] === "string" ? block["text"] : "").filter((text) => text !== "").join("\n");
+};
+var parse = (raw) => {
+  if (!raw.includes(`"type":"user"`) && !raw.includes(`"type":"assistant"`)) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+};
+var isMissing = (error) => {
+  const code = typeof error === "object" && error !== null ? error.code : void 0;
+  return code === "ENOENT" || code === "ENOTDIR";
+};
+var promptOf = (line) => {
+  if (line.type !== "user" || line.isMeta === true || line.isCompactSummary === true) {
+    return void 0;
+  }
+  const content = line.message?.content;
+  if (Array.isArray(content) && content.some((block) => block["type"] === "tool_result")) {
+    return void 0;
+  }
+  const text = textOf(content);
+  return text.startsWith("<local-command-") ? void 0 : text;
+};
+var callsOf = (line, options, subagent) => {
+  const content = line.message?.content;
+  if (line.type !== "assistant" || !Array.isArray(content)) {
+    return [];
+  }
+  const locate = options.locate ?? toolPathsUnder;
+  const at = stampOf(line);
+  return content.flatMap((block, index) => {
+    const raw = block["name"];
+    if (block["type"] !== "tool_use" || typeof raw !== "string") {
+      return [];
+    }
+    const name = displayNameOf(raw);
+    const target = toolTarget(block["input"]);
+    const locations = locate(block["input"], options.root);
+    return [
+      {
+        id: typeof block["id"] === "string" ? block["id"] : `${at ?? 0}-${index}`,
+        name,
+        category: toolCategoryOf(name),
+        at,
+        subagent,
+        ...target !== void 0 ? { target } : {},
+        ...locations !== void 0 ? { locations } : {}
+      }
+    ];
+  });
+};
+var failuresOf = (line) => {
+  const content = line.message?.content;
+  if (line.type !== "user" || !Array.isArray(content)) {
+    return [];
+  }
+  return content.flatMap(
+    (block) => block["type"] === "tool_result" && block["is_error"] === true && typeof block["tool_use_id"] === "string" ? [{ id: block["tool_use_id"], text: (typeof block["content"] === "string" ? block["content"] : textOf(block["content"])).slice(0, FAILURE_TEXT_CHARS) }] : []
+  );
+};
+var readClaudeTranscript = (text, options) => {
+  const turns = [];
+  let sessionId;
+  let cwd;
+  for (const raw of text.split("\n")) {
+    const line = parse(raw);
+    if (line === void 0) {
+      continue;
+    }
+    sessionId ??= line.sessionId;
+    cwd ??= line.cwd;
+    const prompt = promptOf(line);
+    if (prompt !== void 0) {
+      turns.push({ index: turns.length, at: stampOf(line) ?? turns.at(-1)?.at ?? 0, prompt, calls: [], failures: [] });
+      continue;
+    }
+    const turn = turns.at(-1);
+    if (turn === void 0) {
+      continue;
+    }
+    turn.calls.push(...callsOf(line, options, false));
+    turn.failures.push(...failuresOf(line));
+  }
+  return { sessionId, cwd, turns };
+};
+var subagentActivity = (file, options) => {
+  const dir = join(dirname(file), basename(file, ".jsonl"), "subagents");
+  let names;
+  try {
+    names = readdirSync(dir).filter((name) => name.endsWith(".jsonl"));
+  } catch {
+    return { calls: [], failures: [] };
+  }
+  const calls = [];
+  const failures = [];
+  for (const name of names) {
+    let text;
+    try {
+      text = readFileSync(join(dir, name), "utf8");
+    } catch {
+      continue;
+    }
+    for (const raw of text.split("\n")) {
+      const line = parse(raw);
+      if (line === void 0) {
+        continue;
+      }
+      calls.push(...callsOf(line, options, true));
+      failures.push(...failuresOf(line).map((failure) => ({ ...failure, at: stampOf(line) })));
+    }
+  }
+  return { calls, failures };
+};
+var turnAt = (turns, at) => {
+  if (at === void 0) {
+    return void 0;
+  }
+  let found;
+  for (const turn of turns) {
+    if (turn.at <= at) {
+      found = turn;
+    }
+  }
+  return found;
+};
+var readClaudeSession = (file, options) => {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch (error) {
+    if (isMissing(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+  const session = readClaudeTranscript(text, options);
+  if (session.turns.length === 0) {
+    return session;
+  }
+  const activity = subagentActivity(file, options);
+  for (const call of activity.calls) {
+    turnAt(session.turns, call.at)?.calls.push(call);
+  }
+  for (const { at, ...failure } of activity.failures) {
+    turnAt(session.turns, at)?.failures.push(failure);
+  }
+  for (const turn of session.turns) {
+    turn.calls.sort((left, right) => (left.at ?? 0) - (right.at ?? 0));
+  }
+  return session;
+};
+
+// ../../_tools/base/src/outside-text.ts
+var CONTROL_TAGS = ["system-reminder", "task-notification", "command-name", "command-message", "command-args", "local-command-stdout"];
+var CONTROL = new RegExp(String.raw`<\s*/?\s*(?:${CONTROL_TAGS.join("|")})\b[^>]*>`, "gi");
+
+// ../../_tools/constants/src/hosted-tiers.ts
+var HOSTED_TIERS = [
+  { id: "free", name: "Free", cpuKind: "shared", cpus: 4, memoryMb: 4096, volumeGb: 10, monthlyHours: 40, priceUsd: 0, flyHourUsd: 0.0329 },
+  { id: "standard", name: "Standard", cpuKind: "shared", cpus: 8, memoryMb: 8192, volumeGb: 25, monthlyHours: 220, priceUsd: 20, flyHourUsd: 0.0657 },
+  { id: "max", name: "Max", cpuKind: "shared", cpus: 8, memoryMb: 16384, volumeGb: 50, monthlyHours: 320, priceUsd: 50, flyHourUsd: 0.1234 }
+];
+var FREE_TIER = HOSTED_TIERS[0];
+var PAID_TIERS = HOSTED_TIERS.filter((tier) => tier.priceUsd > 0);
+
+// ../../_tools/constants/src/index.ts
+var STATE_DIR = ".intentic";
+var GOOGLE_CLIENT_ID = "481795963975-cq9msl6higcd91joidrfp8mjlkuq5fk3.apps.googleusercontent.com";
+var GOOGLE_TOKEN_STORAGE_KEY = `intentic.gid.${GOOGLE_CLIENT_ID}`;
+
+// ../fileq/src/lib/sidecar.ts
+var DERIVED_DIR = `${STATE_DIR}/local/cache/derived`;
+
+// ../agent-context/src/turn-metrics.ts
+var createTurnMetrics = (root) => {
+  let calls = 0;
+  let searchCalls = 0;
+  let openingSearches = 0;
+  let openingListings = 0;
+  let reachedTheWork = false;
+  const failed = /* @__PURE__ */ new Set();
+  const firstTouch = /* @__PURE__ */ new Map();
+  const noteTouches = (locations) => {
+    for (const { path } of locations ?? []) {
+      firstTouch.set(path, firstTouch.get(path) ?? calls - 1);
+    }
+  };
+  return {
+    call: (call) => {
+      calls += 1;
+      const searched = isSearchCall(call);
+      if (searched) {
+        searchCalls += 1;
+      }
+      if (searched && !reachedTheWork && searchPrecedesFileWork(call)) {
+        openingSearches += 1;
+      }
+      if (!reachedTheWork && isRootListing(call, root)) {
+        openingListings += 1;
+      }
+      noteTouches(call.locations);
+      if (isFileWorkCall(call)) {
+        reachedTheWork = true;
+      }
+    },
+    failed: (id) => {
+      failed.add(id);
+    },
+    calls: () => calls,
+    reading: (edited) => {
+      const reached = edited.map((path) => firstTouch.get(path)).filter((at) => at !== void 0);
+      return {
+        searchCalls,
+        openingSearches,
+        openingListings,
+        failedCalls: failed.size,
+        ...reached.length > 0 ? { callsBeforeTarget: Math.min(...reached) } : {}
+      };
+    }
+  };
+};
+
+// ../output-cleaners/src/filter-stats.mjs
+var sum = (rows, key) => rows.reduce((total, row) => total + (row[key] ?? 0), 0);
+var tokens = (bytes) => Math.round(bytes / 4);
+var READ_VERBS = /* @__PURE__ */ new Set(["cat", "bat", "sed", "awk", "head", "tail", "less", "more"]);
+var isPrefixWord = (word, previous) => /^[A-Za-z_]\w*=/.test(word) || word === "sudo" || word === "timeout" || previous === "timeout" && /^\d+[smhd]?$/.test(word);
+var SHELL_NOISE = /* @__PURE__ */ new Set(["cd", "echo", "true", "set", "export", "source", "time", "for", "do", "done", "while", "until", "if", "then", "else", "elif", "fi", "case", "esac"]);
+var SUBCOMMAND_VERBS = /* @__PURE__ */ new Set(["git", "pnpm", "npm", "npx", "yarn", "docker", "cargo", "go", "gh", "kubectl", "systemctl", "apt", "apt-get", "pip", "poetry"]);
+var segmentVerb = (segment) => {
+  const words = segment.trim().split(/\s+/);
+  let index = 0;
+  while (index < words.length && isPrefixWord(words[index], words[index - 1])) {
+    index++;
+  }
+  const word = (words[index] ?? "").replace(/^[({]+/, "");
+  const verb = word.slice(word.lastIndexOf("/") + 1);
+  if (verb === "" || SHELL_NOISE.has(verb)) {
+    return "";
+  }
+  const next = words[index + 1];
+  return SUBCOMMAND_VERBS.has(verb) && next !== void 0 && /^[a-z][\w-]*$/.test(next) ? `${verb} ${next}` : verb;
+};
+var commandSignature = (command) => {
+  for (const segment of String(command).split(/[|;&]+/)) {
+    const verb = segmentVerb(segment);
+    if (verb !== "") {
+      return verb;
+    }
+  }
+  return "";
+};
+var sortedBytes = (rows, key) => rows.map((row) => row[key] ?? 0).toSorted((a, b) => a - b);
+var median = (sorted) => sorted[sorted.length >> 1] ?? 0;
+var mannWhitneyZ = (first, second) => {
+  const n1 = first.length;
+  const n2 = second.length;
+  const total = n1 + n2;
+  if (n1 === 0 || n2 === 0) {
+    return 0;
+  }
+  const merged = [...first.map((value) => ({ value, isFirst: true })), ...second.map((value) => ({ value, isFirst: false }))].toSorted(
+    (left, right) => left.value - right.value
+  );
+  let rankSum = 0;
+  let tieCorrection = 0;
+  let start = 0;
+  let firstsInGroup = 0;
+  let previous;
+  const closeGroup = (end) => {
+    const tied = end - start;
+    if (tied > 1) {
+      tieCorrection += tied ** 3 - tied;
+    }
+    rankSum += firstsInGroup * ((start + end + 1) / 2);
+  };
+  merged.forEach((entry, position) => {
+    if (previous !== void 0 && entry.value !== previous) {
+      closeGroup(position);
+      start = position;
+      firstsInGroup = 0;
+    }
+    previous = entry.value;
+    if (entry.isFirst) {
+      firstsInGroup++;
+    }
+  });
+  closeGroup(total);
+  const u = rankSum - n1 * (n1 + 1) / 2;
+  const deviation = Math.sqrt(n1 * n2 / 12 * (total + 1 - tieCorrection / (total * (total - 1))));
+  return deviation === 0 ? 0 : (u - n1 * n2 / 2) / deviation;
+};
+var MIN_HELD_COMMANDS = 30;
+var Z_952 = 1.96;
+var GAP_MIN_BYTES = 2e3;
+var summarizeGaps = (cleaned) => {
+  const byCommand = /* @__PURE__ */ new Map();
+  for (const row of cleaned) {
+    if (row.matched !== void 0 && row.matched.length > 0 || (row.emittedBytes ?? 0) <= GAP_MIN_BYTES) {
+      continue;
+    }
+    const signature = commandSignature(String(row.command ?? ""));
+    if (READ_VERBS.has(signature)) {
+      continue;
+    }
+    const current = byCommand.get(signature) ?? { commands: 0, bytes: 0 };
+    byCommand.set(signature, { commands: current.commands + 1, bytes: current.bytes + (row.emittedBytes ?? 0) });
+  }
+  return [...byCommand.entries()].map(([command, entry]) => ({ command, commands: entry.commands, tokens: tokens(entry.bytes) })).toSorted((a, b) => b.tokens - a.tokens).slice(0, 15);
+};
+var summarizeStats = (rows) => {
+  const cleaned = rows.filter((row) => row.heldOut !== true);
+  const held = rows.filter((row) => row.heldOut === true);
+  const cleanedRaw = sum(cleaned, "rawBytes");
+  const cleanedEmitted = sum(cleaned, "emittedBytes");
+  const savedPct = cleanedRaw === 0 ? 0 : Math.round((cleanedRaw - cleanedEmitted) / cleanedRaw * 100);
+  const stages = /* @__PURE__ */ new Map();
+  for (const row of cleaned) {
+    for (const [id, bytes] of Object.entries(row.stageBytes ?? {})) {
+      const current = stages.get(id) ?? { commands: 0, bytes: 0 };
+      stages.set(id, { commands: current.commands + 1, bytes: current.bytes + bytes });
+    }
+  }
+  const perCleaner = [...stages.entries()].map(([id, entry]) => ({ id, commands: entry.commands, savedTokens: tokens(entry.bytes) })).toSorted((a, b) => b.savedTokens - a.savedTokens);
+  const heldRaw = sortedBytes(held, "rawBytes");
+  const cleanedEmittedSorted = sortedBytes(cleaned, "emittedBytes");
+  const measurable = held.length >= MIN_HELD_COMMANDS && median(heldRaw) > 0 && Math.abs(mannWhitneyZ(cleanedEmittedSorted, heldRaw)) > Z_952;
+  const measuredSavedPct = measurable ? Math.round((1 - median(cleanedEmittedSorted) / median(heldRaw)) * 100) : void 0;
+  return {
+    commands: rows.length,
+    rawTokens: tokens(sum(rows, "rawBytes")),
+    emittedTokens: tokens(sum(rows, "emittedBytes")),
+    savedPct,
+    perCleaner,
+    holdout: { cleaned: cleaned.length, heldOut: held.length, ...measuredSavedPct !== void 0 ? { measuredSavedPct } : {} },
+    gaps: summarizeGaps(cleaned)
+  };
+};
+var parseStatsFile = (text) => text.split("\n").filter((line) => line.trim() !== "").flatMap((line) => {
+  try {
+    return [JSON.parse(line)];
+  } catch {
+    return [];
+  }
+});
+
+// src/features.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+
+// src/runtime.ts
+var isMissing2 = (error) => {
+  const code = typeof error === "object" && error !== null ? error.code : void 0;
+  return code === "ENOENT" || code === "ENOTDIR";
+};
+var projectSlug = (project) => project.replace(/[^a-zA-Z0-9]/g, "-");
+
+// src/features.ts
+var OPTIONS = {
+  output_cleaners: {
+    type: "boolean",
+    title: "Trim Bash output",
+    description: "Clean what a successful command printed before Claude reads it (progress bars, install chatter, repeated lines, the middle of huge logs), keep the full text retrievable with `retrieve-output`, and ledger what each cleaner saved.",
+    default: true
+  },
+  cleaners: {
+    type: "string",
+    title: "Cleaners",
+    description: "Which cleaners run, as the sandbox spells it: empty for all, `-cap,-wide` to switch some off, `git,pnpm` to allow only those. `/intentic:stats` lists them by what they saved.",
+    default: ""
+  },
+  output_holdout: {
+    type: "number",
+    title: "Untrimmed share",
+    description: "Share of commands left untrimmed, so the saving can be measured against a real comparison and not only computed. 0 turns the comparison off; the exact per-command saving is reported either way.",
+    default: 0,
+    min: 0,
+    max: 0.5
+  },
+  project_map: {
+    type: "boolean",
+    title: "Project map",
+    description: "Open each session with a map of the project it starts in: its areas, what each is for, and where Claude is standing. Worked out from the tree every time, never stored, so it cannot go stale.",
+    default: true
+  },
+  field_notes: {
+    type: "boolean",
+    title: "Field notes",
+    description: "Open each session with this project's field notes: the traps past sessions hit and the commands that really verify. Written by `/intentic:field-notes` from your own sessions here; nothing is sent until you run it once.",
+    default: true
+  },
+  iq: {
+    type: "boolean",
+    title: "iq search",
+    description: "Teach Claude the `iq` code search CLI and recall past sessions on a matching prompt. Needs `npm i -g @intentic/iq`; without it this switch does nothing and says so once.",
+    default: true
+  },
+  fileq: {
+    type: "boolean",
+    title: "fileq",
+    description: "Let Claude read documents, PDFs, spreadsheets, slides, notebooks, images, audio and archives as markdown with the bundled `fileq` CLI. Off makes the command refuse; its one-line skill description stays listed, since a plugin cannot hide its own skills.",
+    default: true
+  },
+  shadows: {
+    type: "boolean",
+    title: "Document shadows",
+    description: "Keep a markdown rendering of every document in the project up to date in the background (a sweep at session start and every ten minutes, and each binary file Claude writes), so a read finds one ready. Costs background CPU on a document-heavy project.",
+    default: false
+  },
+  holdout: {
+    type: "number",
+    title: "Measured share",
+    description: "Share of sessions opened without the map, the field notes and the iq teaching, so `/intentic:stats` can show what each changed. 0 sends them to every session and measures nothing.",
+    default: 0.1,
+    min: 0,
+    max: 0.5
+  }
+};
+var asBoolean = (raw, fallback) => {
+  const value = raw?.trim().toLowerCase();
+  if (value === "true" || value === "1" || value === "yes" || value === "on") {
+    return true;
+  }
+  if (value === "false" || value === "0" || value === "no" || value === "off") {
+    return false;
+  }
+  return fallback;
+};
+var asShare = (raw, option) => {
+  const value = raw === void 0 || raw.trim() === "" ? Number.NaN : Number(raw);
+  return Number.isFinite(value) ? Math.min(option.max, Math.max(option.min, value)) : option.default;
+};
+var optionEnvName = (key) => `CLAUDE_PLUGIN_OPTION_${key.toUpperCase()}`;
+var readOptions = (env = process.env) => {
+  const entries = Object.keys(OPTIONS).map((key) => {
+    const option = OPTIONS[key];
+    const raw = env[optionEnvName(key)];
+    if (option.type === "boolean") {
+      return [key, asBoolean(raw, option.default)];
+    }
+    if (option.type === "number") {
+      return [key, asShare(raw, option)];
+    }
+    return [key, raw ?? option.default];
+  });
+  return Object.fromEntries(entries);
+};
+var optionsFile = (data) => join2(data, "options.json");
+var loadOptions = (data) => {
+  let text;
+  try {
+    text = readFileSync2(optionsFile(data), "utf8");
+  } catch (error) {
+    if (isMissing2(error)) {
+      return readOptions({});
+    }
+    throw error;
+  }
+  let saved;
+  try {
+    saved = JSON.parse(text);
+  } catch {
+    saved = {};
+  }
+  const values = typeof saved === "object" && saved !== null ? saved : {};
+  return readOptions(Object.fromEntries(Object.keys(OPTIONS).flatMap((key) => key in values ? [[optionEnvName(key), String(values[key])]] : [])));
+};
+
+// src/post-bash.ts
+import { join as join6 } from "node:path";
+
+// ../output-cleaners/src/cleaners.mjs
+import { createHash } from "node:crypto";
+import { closeSync, fstatSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+var ANSI = /\x1b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)|[@-Z\\-_])/g;
+var collapseCr = (line) => {
+  const frames = line.split("\r");
+  for (let i = frames.length - 1; i >= 0; i--) {
+    if (frames[i] !== "") {
+      return frames[i];
+    }
+  }
+  return "";
+};
+var strip = (id, match, patterns) => ({
+  id,
+  match,
+  apply: (lines) => lines.filter((line) => !patterns.some((re) => re.test(line)))
+});
+var invocation = (word) => new RegExp(String.raw`(?<![\w.\-/])(?:${word})(?![\w.-])`);
+var bodyBytes = (lines) => lines.length === 0 ? 0 : lines.reduce((sum2, line) => sum2 + line.length, 0) + lines.length - 1;
+var humanSize = (bytes) => bytes >= 1048576 ? `${(bytes / 1048576).toFixed(1)}M` : bytes >= 1024 ? `${(bytes / 1024).toFixed(1)}K` : `${bytes}B`;
+var EXECUTABLE = /* @__PURE__ */ new Set(["x", "s", "t"]);
+var permsToOctal = (perms) => {
+  const triad = (read, write, exec) => (perms[read] === "r" ? 4 : 0) + (perms[write] === "w" ? 2 : 0) + (EXECUTABLE.has(perms[exec]) ? 1 : 0);
+  const special = ("sS".includes(perms[3]) ? 4 : 0) + ("sS".includes(perms[6]) ? 2 : 0) + ("tT".includes(perms[9]) ? 1 : 0);
+  const mode = `${triad(1, 2, 3)}${triad(4, 5, 6)}${triad(7, 8, 9)}`;
+  return special > 0 ? `${special}${mode}` : mode;
+};
+var LS_DATE = /\s(?:(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}\s+(?:\d{4}|\d{1,2}:\d{2})|\d{4}-\d{2}-\d{2}\s+\d{1,2}:\d{2})\s/;
+var LS_MODE = /^[-dlbcps][rwxSsTt-]{9}[.+@]?$/;
+var parseListingLine = (line) => {
+  const date = LS_DATE.exec(line);
+  if (date === null) {
+    return void 0;
+  }
+  const head = line.slice(0, date.index).split(/\s+/).filter((token) => token !== "");
+  if (head.length < 4 || !LS_MODE.test(head[0])) {
+    return void 0;
+  }
+  const size = head.reduceRight((found, token) => found === void 0 && /^\d+$/.test(token) ? Number(token) : found, void 0);
+  return { mode: permsToOctal(head[0]), directory: head[0].startsWith("d"), size, name: line.slice(date.index + date[0].length) };
+};
+var compactListing = (lines) => {
+  let parsed = 0;
+  const out = lines.flatMap((line) => {
+    if (/^total \d+$/.test(line)) {
+      return [];
+    }
+    const entry = parseListingLine(line);
+    if (entry === void 0) {
+      return [line];
+    }
+    parsed++;
+    if (entry.name === "." || entry.name === "..") {
+      return [];
+    }
+    if (entry.directory) {
+      return [`${entry.mode} ${entry.name}/`];
+    }
+    return [`${entry.mode} ${entry.name}${entry.size === void 0 ? "" : `  ${humanSize(entry.size)}`}`];
+  });
+  return parsed === 0 ? lines : out;
+};
+var PATH_RUN_MIN = 10;
+var PATH_RUN_DIRS = 60;
+var PATH_RUN_NAMES = 40;
+var isPathLine = (line) => line !== "" && !/\s/.test(line) && !/:\d/.test(line) && line.length < 300;
+var sharedRoot = (directories) => {
+  if (directories.length < 2) {
+    return "";
+  }
+  let prefix = directories[0];
+  for (const directory of directories) {
+    while (prefix !== "" && !directory.startsWith(prefix)) {
+      const shorter = prefix.slice(0, prefix.lastIndexOf("/", prefix.length - 2) + 1);
+      prefix = shorter === prefix ? "" : shorter;
+    }
+  }
+  return prefix;
+};
+var foldPaths = (run) => {
+  if (run.filter((line) => line.includes("/")).length * 5 < run.length * 3) {
+    return run;
+  }
+  const byDirectory = /* @__PURE__ */ new Map();
+  for (const path of run) {
+    const cut = path.lastIndexOf("/");
+    const directory = cut === -1 ? "./" : path.slice(0, cut + 1);
+    const names = byDirectory.get(directory);
+    if (names === void 0) {
+      byDirectory.set(directory, [path.slice(cut + 1)]);
+    } else {
+      names.push(path.slice(cut + 1));
+    }
+  }
+  const root = sharedRoot([...byDirectory.keys()]);
+  const trim = root.length > 8 ? root.length : 0;
+  const folded = [`${run.length} paths in ${byDirectory.size} directories${trim === 0 ? "" : ` under ${root}`}:`];
+  let shown = 0;
+  for (const [directory, names] of [...byDirectory].slice(0, PATH_RUN_DIRS)) {
+    const kept = names.slice(0, PATH_RUN_NAMES);
+    shown += kept.length;
+    folded.push(`${directory.slice(trim) === "" ? "./" : directory.slice(trim)} ${kept.join(" ")}`);
+  }
+  if (shown < run.length) {
+    folded.push(`\u2026 ${run.length - shown} more paths elided`);
+  }
+  return bodyBytes(folded) < bodyBytes(run) ? folded : run;
+};
+var foldPathRuns = (lines) => {
+  const out = [];
+  for (let i = 0; i < lines.length; ) {
+    let j = i;
+    while (j < lines.length && isPathLine(lines[j])) {
+      j++;
+    }
+    if (j === i) {
+      out.push(lines[i]);
+      i++;
+      continue;
+    }
+    out.push(...j - i >= PATH_RUN_MIN ? foldPaths(lines.slice(i, j)) : lines.slice(i, j));
+    i = j;
+  }
+  return out;
+};
+var HIT_LINE = /^([^\s:][^:]{0,240}):(\d+):(?:(\d+):)?(.*)$/;
+var HIT_RUN_MIN = 6;
+var isHitKey = (key) => key.includes("/") || key.includes(".");
+var parseHit = (line) => {
+  const match = HIT_LINE.exec(line);
+  return match !== null && isHitKey(match[1]) ? match : void 0;
+};
+var foldHitRun = (run) => {
+  const folded = [];
+  for (let start = 0; start < run.length; ) {
+    const file = parseHit(run[start])[1];
+    folded.push(run[start]);
+    let next = start + 1;
+    while (next < run.length && parseHit(run[next])[1] === file) {
+      const hit = parseHit(run[next]);
+      folded.push(`  ${hit[2]}${hit[3] === void 0 ? "" : `:${hit[3]}`}:${hit[4]}`);
+      next++;
+    }
+    start = next;
+  }
+  return bodyBytes(folded) < bodyBytes(run) ? folded : run;
+};
+var foldHitRuns = (lines) => {
+  const out = [];
+  for (let i = 0; i < lines.length; ) {
+    let end = i;
+    while (end < lines.length && parseHit(lines[end]) !== void 0) {
+      end++;
+    }
+    const stop = Math.max(end, i + 1);
+    out.push(...end - i >= HIT_RUN_MIN ? foldHitRun(lines.slice(i, end)) : lines.slice(i, stop));
+    i = stop;
+  }
+  return out;
+};
+var GENERATED_PATH = /(?:^|\/)(?:[^/]*\.lock(?:\.json)?|[^/]*-lock\.json|pnpm-lock\.yaml|go\.sum|[^/]*\.min\.(?:js|css|mjs)|[^/]*\.map)$/;
+var DIFF_HEADER = /^diff --git a\/(\S+) b\/(\S+)$/;
+var isAdded = (line) => line.startsWith("+") && !line.startsWith("+++");
+var isRemoved = (line) => line.startsWith("-") && !line.startsWith("---");
+var foldGeneratedDiffs = (lines) => {
+  const out = [];
+  let folding = false;
+  let added = 0;
+  let removed = 0;
+  let dropped = 0;
+  const flush = () => {
+    if (folding && dropped > 0) {
+      out.push(`\u2026 ${dropped} lines of generated-file diff elided (+${added} \u2212${removed}) \u2026`);
+    }
+    folding = false;
+    added = 0;
+    removed = 0;
+    dropped = 0;
+  };
+  for (const line of lines) {
+    const header = DIFF_HEADER.exec(line);
+    if (header !== null) {
+      flush();
+      folding = GENERATED_PATH.test(header[2]);
+      out.push(line);
+      continue;
+    }
+    if (!folding) {
+      out.push(line);
+      continue;
+    }
+    dropped++;
+    added += isAdded(line) ? 1 : 0;
+    removed += isRemoved(line) ? 1 : 0;
+  }
+  flush();
+  return bodyBytes(out) < bodyBytes(lines) ? out : lines;
+};
+var COMMAND_CLEANERS = [
+  strip("pnpm", invocation(String.raw`pnpm`), [
+    /^\s*Progress: /,
+    /^Packages: [+-]/,
+    /^Downloading /,
+    /^\s*[.+]+\s*$/,
+    /^Virtual store is at/,
+    /^Lockfile is up to date/
+  ]),
+  // `apt-get` before `apt`: ordered alternation, or the guard rejects the longer spelling at its hyphen.
+  strip("apt", invocation(String.raw`apt-get|apt`), [
+    /^(?:Get:|Hit:|Ign:|Fetched |Selecting |Preparing to unpack|Unpacking |Setting up |Processing triggers)/
+  ]),
+  // Test runners: on a passing run (exit 0) per-test PASS lines are noise, dropped, keeping the summary. Failures skip
+  // all command cleaners, so failing tests survive verbatim.
+  strip("test", invocation(String.raw`bun\s+test|suites|vitest|jest|pytest|rspec|mocha|phpunit|go\s+test|cargo\s+test`), [
+    /^\s*[✓√]\s/,
+    // per-test pass (vitest/jest/mocha)
+    /^\(pass\)\s/,
+    // bun test per-test pass
+    /^--- PASS:/,
+    // go test per-test
+    /^\s*test .+\.\.\. ok$/,
+    // cargo test per-test
+    /^PASS\s+\S/,
+    // jest per-file PASS header
+    /^\s*[.·]+\s*$/
+    // pytest/mocha dot progress
+  ]),
+  // `diff` reads the whole output's structure, the three after it read runs of lines; folding the generated hunks away
+  // first keeps those three from ever looking inside one.
+  { id: "diff", apply: foldGeneratedDiffs },
+  { id: "ls", apply: compactListing },
+  { id: "files", apply: foldPathRuns },
+  { id: "hits", apply: foldHitRuns }
+];
+var CLEANERS = [...COMMAND_CLEANERS.map((cleaner) => cleaner.id), "dedup", "wide", "cap", "redact", "cache"];
+var dedupeRuns = (lines) => {
+  const out = [];
+  for (let i = 0; i < lines.length; ) {
+    let j = i + 1;
+    while (j < lines.length && lines[j] === lines[i]) {
+      j++;
+    }
+    const run = j - i;
+    out.push(lines[i]);
+    if (run >= 3) {
+      out.push(`  \u2026 (${run - 1} more identical lines)`);
+    } else {
+      for (let k = 1; k < run; k++) {
+        out.push(lines[i]);
+      }
+    }
+    i = j;
+  }
+  return out;
+};
+var WIDE_RUN = 400;
+var WIDE_HEAD = 240;
+var WIDE_TAIL = 80;
+var elideRun = (run) => `${run.slice(0, WIDE_HEAD)}\u2026 ${run.length - WIDE_HEAD - WIDE_TAIL} chars elided \u2026${run.slice(-WIDE_TAIL)}`;
+var WIDE_PATTERN = new RegExp(String.raw`\S{${WIDE_RUN + 1},}`, "g");
+var elideWideRuns = (lines) => lines.map((line) => line.length > WIDE_RUN ? line.replaceAll(WIDE_PATTERN, elideRun) : line);
+var SECRET_NAME = String.raw`[A-Za-z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API[_-]?KEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY)[A-Za-z0-9_]*`;
+var ASSIGN = String.raw`["']?\s*[:=](?![=>])\s*`;
+var QUOTED_VALUE = String.raw`(["'\x60])([^"'\x60\n]{6,})\2`;
+var BARE_VALUE = String.raw`[\w+/=~-]{6,}(?![\w+/=~(-])`;
+var ISSUER_PREFIX = /^(?:sk-|pk-|rk-|ghp_|gho_|ghu_|ghs_|ghr_|github_pat_|xox[abposr]-|AKIA|ASIA|eyJ|AIza|ya29\.|glpat-|dop_v1_|shpat_|SG\.|npm_)/;
+var NUMERIC_VALUE = /^[\d_,.]+$/;
+var STRUCTURAL_VALUE = /[\s/\\${}]/;
+var ENV_NAME_VALUE = /^[A-Z0-9_]+$/;
+var ENTROPIC_VALUE = /^(?=[^\n]*\d)(?=[^\n]*[A-Za-z])/;
+var HANDWRITTEN_MAX = 12;
+var looksLikeCredential = (value) => ISSUER_PREFIX.test(value) || value.length > HANDWRITTEN_MAX && ENTROPIC_VALUE.test(value) && !NUMERIC_VALUE.test(value) && !STRUCTURAL_VALUE.test(value) && !ENV_NAME_VALUE.test(value);
+var SECRET_PATTERNS = [
+  [
+    new RegExp(`\\b(${SECRET_NAME}${ASSIGN})(?:${QUOTED_VALUE}|(${BARE_VALUE}))`, "gi"),
+    // Quoted and bare arrive in different groups because only the quoted one has a quote to put back.
+    (match, assignment, quote, quoted, bare) => looksLikeCredential(quoted ?? bare) ? `${assignment}${quote ?? ""}***${quote ?? ""}` : match
+  ],
+  [/\bAKIA[0-9A-Z]{16}\b/g, "***"],
+  // Same rule for a bearer value: prose about tokens carries no digit, every real bearer token does.
+  [/\b(Bearer\s+)(?=[\w.-]*\d)[\w.-]{8,}/gi, "$1***"],
+  [/\b(https?:\/\/[^:@\s/]+:)[^@\s]+@/gi, "$1***@"]
+];
+var SECRET_VALUE_MIN = 12;
+var secretValueCache = /* @__PURE__ */ new Map();
+var readIfChanged = (path, name) => {
+  try {
+    const descriptor = openSync(path, "r");
+    try {
+      const { mtimeMs, size } = fstatSync(descriptor);
+      const stamp = `${mtimeMs}:${size}`;
+      const cached = secretValueCache.get(path);
+      if (cached?.stamp === stamp) {
+        return cached.values;
+      }
+      const values = harvest(readFileSync3(descriptor, "utf8"), path, name);
+      secretValueCache.set(path, { stamp, values });
+      return values;
+    } finally {
+      closeSync(descriptor);
+    }
+  } catch {
+    return [];
+  }
+};
+var surfaceForms = (value) => {
+  const forms = [value];
+  const jsonEscaped = JSON.stringify(value).slice(1, -1);
+  if (jsonEscaped !== value) {
+    forms.push(jsonEscaped);
+  }
+  try {
+    const encoded = encodeURIComponent(value);
+    if (encoded !== value) {
+      forms.push(encoded);
+    }
+  } catch {
+  }
+  return forms;
+};
+var harvest = (text, path, name) => {
+  const named = [];
+  if (path.endsWith("capability-secrets.json")) {
+    for (const [id, entry] of Object.entries(JSON.parse(text))) {
+      if (entry === null || typeof entry !== "object") {
+        continue;
+      }
+      for (const [field, value] of Object.entries(entry)) {
+        if (typeof value === "string") {
+          named.push([name(id, field), value]);
+        }
+      }
+    }
+  } else if (path.endsWith(".json")) {
+    for (const [key, value] of Object.entries(JSON.parse(text))) {
+      if (typeof value === "string") {
+        named.push([name(key), value]);
+      }
+    }
+  } else {
+    for (const line of text.split("\n")) {
+      const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+      if (match !== null) {
+        named.push([name(match[1]), (match[2] ?? "").trim().replace(/^(["'])([\s\S]*)\1$/, "$2")]);
+      }
+    }
+  }
+  const byTarget = /* @__PURE__ */ new Map();
+  const add = (target, replacement) => {
+    const trimmed = target.trim();
+    if (trimmed.length >= SECRET_VALUE_MIN && !byTarget.has(trimmed)) {
+      byTarget.set(trimmed, { target: trimmed, replacement });
+    }
+  };
+  for (const [reference, value] of named) {
+    for (const form of surfaceForms(value.trim())) {
+      add(form, `{{secret:${reference}}}`);
+    }
+    if (value.includes("\n")) {
+      for (const line of value.split("\n")) {
+        add(line, "***");
+      }
+    }
+  }
+  return [...byTarget.values()].toSorted((a, b) => b.target.length - a.target.length);
+};
+var secretValues = (env = process.env) => {
+  const authRoot = env.AGENT_AUTH_DIR !== void 0 && env.AGENT_AUTH_DIR !== "" ? env.AGENT_AUTH_DIR : join3(env.WORKSPACE_ROOT ?? "/work", ".intentic/secrets/auth");
+  const repo = join3(env.WORKSPACE_ROOT ?? "/work", "desired-state");
+  return [
+    ...readIfChanged(join3(authRoot, "capability-secrets.json"), (id, field) => `${id}/${field}`),
+    ...readIfChanged(join3(repo, ".env"), (key) => key),
+    ...readIfChanged(join3(repo, ".secrets.json"), (key) => key)
+  ].toSorted((a, b) => b.target.length - a.target.length);
+};
+var redactText = (text, values = []) => text.split("\n").map((line) => redactLine(line, values)).join("\n");
+var redactLine = (line, values = []) => {
+  let masked = line;
+  for (const { target, replacement } of values) {
+    if (masked.includes(target)) {
+      masked = masked.split(target).join(replacement);
+    }
+  }
+  return SECRET_PATTERNS.reduce((acc, [pattern, replacement]) => acc.replace(pattern, replacement), masked);
+};
+var parseCleaners = (spec) => {
+  if (spec === void 0 || spec.trim() === "") {
+    return new Set(CLEANERS);
+  }
+  const tokens3 = spec.split(",").map((token) => token.trim()).filter((token) => token !== "" && CLEANERS.includes(token.replace(/^-/, "")));
+  if (tokens3.length === 0) {
+    return new Set(CLEANERS);
+  }
+  const allowList = tokens3.some((token) => !token.startsWith("-"));
+  if (allowList) {
+    return new Set(tokens3.filter((token) => !token.startsWith("-")));
+  }
+  const disabled = new Set(tokens3.map((token) => token.slice(1)));
+  return new Set(CLEANERS.filter((cleaner) => !disabled.has(cleaner)));
+};
+var HEAD = 30;
+var TAIL = 50;
+var MAX = 100;
+var FAIL_TAIL = 500;
+var LOG_MAX_BYTES = 16e3;
+var READ_MAX_BYTES = 96e3;
+var BYTE_HEAD_SHARE = 0.375;
+var READ_MAX = 2e3;
+var GIT_OPTIONS = String.raw`(?:(?:-[Cc]|--(?:git-dir|work-tree|namespace|exec-path|super-prefix))\s+\S+\s+|-\S+\s+)*`;
+var READ_COMMAND = new RegExp(
+  String.raw`(?<![\w.-])(?:cat|bat|sed\s+-n|awk|git\s+${GIT_OPTIONS}(?:diff|show)\b|git\s+${GIT_OPTIONS}log\s+(?:[^;&|]*\s)?-p)\b`
+);
+var takeWithinBudget = (source, budget) => {
+  const kept = [];
+  let spent = 0;
+  for (const line of source) {
+    spent += line.length + 1;
+    if (spent > budget) {
+      break;
+    }
+    kept.push(line);
+  }
+  return kept;
+};
+var byteBudget = (command) => READ_COMMAND.test(command) ? READ_MAX_BYTES : LOG_MAX_BYTES;
+var capOutput = (lines, command) => {
+  const isRead = READ_COMMAND.test(command);
+  const maxLines = isRead ? READ_MAX : MAX;
+  const maxBytes = byteBudget(command);
+  if (lines.length > maxLines) {
+    return isRead ? [...lines.slice(0, maxLines), `\u2026 ${lines.length - maxLines} more lines elided: narrow the range or use the Read tool \u2026`] : [...lines.slice(0, HEAD), `\u2026 ${lines.length - HEAD - TAIL} lines elided \u2026`, ...lines.slice(-TAIL)];
+  }
+  if (bodyBytes(lines) <= maxBytes) {
+    return lines;
+  }
+  if (isRead) {
+    const head2 = takeWithinBudget(lines, maxBytes);
+    return [...head2, `\u2026 ${lines.length - head2.length} more lines elided (${bodyBytes(lines)} bytes): narrow the range or use the Read tool \u2026`];
+  }
+  const head = takeWithinBudget(lines, Math.round(maxBytes * BYTE_HEAD_SHARE));
+  const tail = takeWithinBudget(lines.toReversed(), maxBytes - bodyBytes(head)).toReversed();
+  if (head.length === 0 && tail.length === 0) {
+    return [`${lines[0].slice(0, maxBytes)}\u2026 line truncated at ${maxBytes} bytes \u2026`];
+  }
+  return [...head, `\u2026 ${lines.length - head.length - tail.length} lines elided (${bodyBytes(lines)} bytes) \u2026`, ...tail];
+};
+var cleanSucceeded = (lines, command, enabled, ran) => {
+  let out = lines;
+  for (const cleaner of COMMAND_CLEANERS) {
+    if (enabled.has(cleaner.id) && (cleaner.match === void 0 || cleaner.match.test(command))) {
+      out = ran(cleaner.id, cleaner.apply(out));
+    }
+  }
+  if (enabled.has("dedup")) {
+    out = ran("dedup", dedupeRuns(out));
+  }
+  if (enabled.has("wide") && bodyBytes(out) > byteBudget(command)) {
+    out = ran("wide", elideWideRuns(out));
+  }
+  if (enabled.has("cap")) {
+    const capped = capOutput(out, command);
+    if (capped !== out) {
+      out = ran("cap", capped);
+    }
+  }
+  return out;
+};
+var cleanFailed = (lines, enabled, ran) => {
+  const out = enabled.has("dedup") ? ran("dedup", dedupeRuns(lines)) : lines;
+  return out.length > FAIL_TAIL ? (
+    // Own id, never `cap`: this fires regardless of the spec, so `cap`'s toggle shouldn't get credit for it.
+    ran("failtail", [`\u2026 ${out.length - FAIL_TAIL} earlier lines elided \u2026`, ...out.slice(-FAIL_TAIL)])
+  ) : out;
+};
+var cleanLines = (lines, { command, exitCode, enabled, values = [] }) => {
+  const stages = [];
+  let bytes = bodyBytes(lines);
+  const ran = (id, next) => {
+    const after = bodyBytes(next);
+    stages.push({ id, saved: bytes - after });
+    bytes = after;
+    return next;
+  };
+  let out = exitCode === "0" ? cleanSucceeded(lines, command, enabled, ran) : cleanFailed(lines, enabled, ran);
+  if (enabled.has("redact")) {
+    out = ran(
+      "redact",
+      out.map((line) => redactLine(line, values))
+    );
+  }
+  return { lines: out, stages };
+};
+var matchedCleaners = (command, enabled) => COMMAND_CLEANERS.filter((cleaner) => cleaner.match !== void 0 && enabled.has(cleaner.id) && cleaner.match.test(command)).map(
+  (cleaner) => cleaner.id
+);
+var CACHE_MARKER = "(output identical to ";
+var CACHE_MIN_BYTES = 512;
+var CACHE_COMMAND_MAX = 120;
+var hashText = (text) => createHash("sha1").update(text).digest("hex");
+var sessionKeyFromLog = (logPath) => {
+  if (logPath === void 0 || logPath === "") {
+    return void 0;
+  }
+  const base = logPath.split("/").pop() ?? "";
+  const match = base.match(/^(.*)-[^-]+\.log$/);
+  return match !== null && match[1] !== "" ? match[1] : void 0;
+};
+var openCacheStore = (logsDir, sessionKey) => {
+  const file = join3(logsDir, "output-cache", `${sessionKey}.json`);
+  let map;
+  try {
+    map = new Map(Object.entries(JSON.parse(readFileSync3(file, "utf8"))));
+  } catch {
+    map = /* @__PURE__ */ new Map();
+  }
+  return {
+    lookup: (key) => map.get(key),
+    record: (key, value) => {
+      map.set(key, value);
+      try {
+        mkdirSync2(dirname2(file), { recursive: true });
+        writeFileSync2(file, JSON.stringify(Object.fromEntries(map)));
+      } catch {
+      }
+    }
+  };
+};
+var collapseCached = (body, command, store, retain = () => void 0) => {
+  if (body.length < CACHE_MIN_BYTES) {
+    return { body, cached: false };
+  }
+  const commandHash = `c:${hashText(command)}`;
+  const bodyKey = `b:${hashText(body)}`;
+  const bodyHash = hashText(body);
+  const handle = () => {
+    const path = retain();
+    return path === void 0 ? "" : ` \xB7 retrieve-output ${path}`;
+  };
+  if (store.lookup(commandHash) === bodyHash) {
+    return { body: `${CACHE_MARKER}a previous run this session${handle()})`, cached: true };
+  }
+  const earlier = store.lookup(bodyKey);
+  if (earlier !== void 0 && earlier !== command) {
+    const named = earlier.length > CACHE_COMMAND_MAX ? `${earlier.slice(0, CACHE_COMMAND_MAX)}\u2026` : earlier;
+    return { body: `${CACHE_MARKER}the output of \`${named}\` earlier this session${handle()})`, cached: true };
+  }
+  store.record(commandHash, bodyHash);
+  if (earlier === void 0) {
+    store.record(bodyKey, command);
+  }
+  return { body, cached: false };
+};
+
+// ../output-cleaners/src/agent-output-filter.mjs
+import { appendFileSync, mkdirSync as mkdirSync3, readdirSync as readdirSync2, rmSync, statSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename2, join as join4 } from "node:path";
+var RETRIEVAL_MIN_DROPPED = 20;
+var SIGPIPE_STATUS = "141";
+var maskedFailure = (exitCode, pipeline) => {
+  const statuses = pipeline.trim() === "" ? [] : pipeline.trim().split(/\s+/);
+  if (exitCode !== "0" || statuses.length < 2 || !statuses.every((status) => /^\d+$/.test(status))) {
+    return void 0;
+  }
+  return statuses.slice(0, -1).some((status) => status !== "0" && status !== SIGPIPE_STATUS) ? statuses.join(" ") : void 0;
+};
+var RG_REPLACE_CLUSTER = /(?<![\w.\-/])rg\s(?:[^;&|\n]*?\s)?(-[a-zA-Z]*r[a-zA-Z]*)(?=[\s;&|]|$)/;
+var commandNotes = (command, raw) => {
+  const cluster = RG_REPLACE_CLUSTER.exec(command)?.[1];
+  return cluster !== void 0 && cluster.length > 2 && raw.trim() !== "" ? [`--- note: \`${cluster}\` is not recursive in rg: -r is --replace, so matched text above was rewritten (rg recurses by default)`] : [];
+};
+var filterOutput = (raw, { command = "", exitCode = "0", durationS = "0", retain, enabled = new Set(CLEANERS), cacheStore, values = [], pipeline = "" }) => {
+  const input = raw.replaceAll(ANSI, "").split("\n").map(collapseCr);
+  if (input.at(-1) === "") {
+    input.pop();
+  }
+  const keep = () => retain?.(input.join("\n"));
+  const rawCount = input.length;
+  const stages = [{ id: "ansi", saved: raw.length - bodyBytes(input) }];
+  const cleaned = cleanLines(input, { command, exitCode, enabled, values });
+  const lines = cleaned.lines;
+  stages.push(...cleaned.stages);
+  let body = lines.join("\n");
+  if (exitCode === "0" && body.trim() === "" && raw.trim() !== "") {
+    body = "(no notable output)";
+  }
+  const masked = maskedFailure(exitCode, pipeline);
+  const exit = masked === void 0 ? `exit ${exitCode}` : `exit ${exitCode} (pipeline: ${masked} \u2014 an earlier stage failed)`;
+  const emitted = (text, id, footed) => {
+    stages.push({ id, saved: bodyBytes(lines) - text.length });
+    let out = text;
+    if (text.length > raw.length) {
+      stages.push({ id: "guard", saved: text.length - raw.length });
+      out = raw;
+    }
+    const extra = [...masked === void 0 || footed && out === text ? [] : [`--- [${exit}, ${durationS}s]`], ...commandNotes(command, raw)];
+    if (extra.length === 0) {
+      return { out, stages };
+    }
+    const noted = `${out === "" || out.endsWith("\n") ? out : `${out}
+`}${extra.join("\n")}
+`;
+    stages.push({ id: "notes", saved: out.length - noted.length });
+    return { out: noted, stages };
+  };
+  if (exitCode === "0" && enabled.has("cache") && cacheStore !== void 0 && body !== "" && body !== "(no notable output)") {
+    const collapsed = collapseCached(body, command, cacheStore, keep);
+    if (collapsed.cached) {
+      return emitted(`${collapsed.body}
+`, "cache", false);
+    }
+  }
+  const kept = body === "(no notable output)" ? 0 : lines.length;
+  const dropped = Math.max(0, rawCount - kept);
+  const cut = stages.find((stage) => stage.id === "wide")?.saved ?? 0;
+  if (dropped === 0 && cut <= 0) {
+    return emitted(body === "" ? body : `${body}
+`, "footer", false);
+  }
+  const retained = dropped >= RETRIEVAL_MIN_DROPPED || cut > 0 ? keep() : void 0;
+  const handle = retained === void 0 ? "" : ` \xB7 full: retrieve-output ${retained} [pattern]`;
+  const summary = dropped > 0 ? `${rawCount} lines filtered to ${kept}` : "long runs cut inside lines";
+  const withFooter = `${body}
+--- [${exit}, ${durationS}s] ${summary}${handle}
+`;
+  return withFooter.length <= raw.length ? emitted(withFooter, "footer", true) : emitted(`${body}
+`, "footer", false);
+};
+var RETAIN_FILES = 30;
+var RETAIN_MAX_CHARS = 2e6;
+var retainIn = (dir, name, values) => (text) => {
+  try {
+    mkdirSync3(dir, { recursive: true });
+    const file = join4(dir, name);
+    writeFileSync3(file, redactText(text.length > RETAIN_MAX_CHARS ? text.slice(-RETAIN_MAX_CHARS) : text, values));
+    const aged = readdirSync2(dir).flatMap((entry) => {
+      try {
+        return [{ entry, at: statSync(join4(dir, entry)).mtimeMs }];
+      } catch {
+        return [];
+      }
+    });
+    for (const { entry } of aged.toSorted((a, b) => b.at - a.at).slice(RETAIN_FILES)) {
+      rmSync(join4(dir, entry), { force: true });
+    }
+    return file;
+  } catch {
+    return void 0;
+  }
+};
+var filterRun = (raw, {
+  command = "",
+  exitCode = "0",
+  durationS = "0",
+  pipeline = "",
+  enabled = new Set(CLEANERS),
+  holdout = 0,
+  logsDir,
+  runName,
+  sessionKey,
+  values = [],
+  tags = {},
+  random = Math.random,
+  now = Date.now
+} = {}) => {
+  let out = raw;
+  let stages = [];
+  let heldOut = false;
+  try {
+    heldOut = holdout > 0 && random() < holdout;
+    const cacheStore = !heldOut && enabled.has("cache") && logsDir !== void 0 && sessionKey !== void 0 ? openCacheStore(logsDir, sessionKey) : void 0;
+    if (!heldOut) {
+      const retain = logsDir !== void 0 && runName !== void 0 && runName !== "" ? retainIn(join4(logsDir, "raw-output"), runName, values) : void 0;
+      const filtered = filterOutput(raw, { command, exitCode, durationS, retain, enabled, cacheStore, values, pipeline });
+      out = filtered.out;
+      stages = filtered.stages;
+    }
+  } catch {
+    out = raw;
+    stages = [];
+  }
+  if (logsDir !== void 0) {
+    try {
+      const matched = matchedCleaners(command, enabled);
+      const stat = {
+        ...tags,
+        ts: now(),
+        command: command.slice(0, 200),
+        exit: exitCode,
+        durationS: Number(durationS),
+        rawBytes: raw.length,
+        emittedBytes: out.length,
+        cleaners: [...enabled],
+        matched: out.startsWith(CACHE_MARKER) ? [...matched, "cache"] : matched,
+        heldOut,
+        stageBytes: Object.fromEntries(stages.map((stage) => [stage.id, stage.saved]))
+      };
+      mkdirSync3(logsDir, { recursive: true });
+      appendFileSync(join4(logsDir, "filter-stats.jsonl"), `${JSON.stringify(stat)}
+`);
+    } catch {
+    }
+  }
+  try {
+    out = redactText(out, values);
+  } catch {
+  }
+  return { out, heldOut, stages };
+};
+var main = async () => {
+  const [command = "", exitCode = "0", durationS = "0", logPath = "", pipeline = ""] = process.argv.slice(2);
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  let values = [];
+  try {
+    values = secretValues();
+  } catch {
+    values = [];
+  }
+  const terminalsDir = process.env["INTENTIC_TERMINAL_LOGS_DIR"];
+  const { out } = filterRun(raw, {
+    command,
+    exitCode,
+    durationS,
+    pipeline,
+    enabled: parseCleaners(process.env["INTENTIC_OUTPUT_CLEANERS"]),
+    holdout: Number(process.env["INTENTIC_OUTPUT_HOLDOUT"] ?? "0"),
+    logsDir: terminalsDir !== void 0 && terminalsDir !== "" ? join4(terminalsDir, "..") : void 0,
+    // Named after the pane log, which is unique per command: one window, one pane id.
+    runName: logPath === "" ? void 0 : basename2(logPath),
+    // Every command of a session runs in a new pane, so the session is the pane log's name minus the pane.
+    sessionKey: sessionKeyFromLog(logPath),
+    values
+  });
+  process.stdout.write(out);
+};
+if (process.argv[1]?.endsWith("agent-output-filter") || process.argv[1]?.endsWith("agent-output-filter.mjs")) {
+  await main();
+}
+
+// src/hook-io.ts
+import { homedir } from "node:os";
+import { join as join5 } from "node:path";
+var readStdin = async () => {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+};
+var parseHookInput = (text) => {
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null ? value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var runHook = async (handle) => {
+  try {
+    const raw = await readStdin();
+    const input = parseHookInput(raw);
+    if (input === void 0) {
+      return;
+    }
+    const answer = await handle(input, raw);
+    if (typeof answer === "string") {
+      process.stdout.write(answer);
+    } else if (answer !== void 0) {
+      process.stdout.write(`${JSON.stringify(answer)}
+`);
+    }
+  } catch (error) {
+    process.stderr.write(`intentic: ${error instanceof Error ? error.message : String(error)}
+`);
+  }
+};
+var dataDir = (env = process.env) => env["CLAUDE_PLUGIN_DATA"] ?? join5(env["CLAUDE_CONFIG_DIR"] ?? join5(homedir(), ".claude"), "plugins", "data", "intentic-intentic");
+var projectDir = (input, env = process.env) => env["CLAUDE_PROJECT_DIR"] ?? input.cwd ?? process.cwd();
+
+// src/post-bash.ts
+var outputDir = (data) => join6(data, "output");
+var OWN_REPORTS = /(?:^|[\s/])intentic-(?:stats|notes-evidence)(?:\s|$)/;
+var rawOf = (response) => {
+  if (typeof response.stdout !== "string" || response.interrupted === true || response.isImage === true || response.backgroundTaskId !== void 0) {
+    return void 0;
+  }
+  const stderr = typeof response.stderr === "string" ? response.stderr : "";
+  return stderr === "" ? response.stdout : `${response.stdout}${response.stdout === "" || response.stdout.endsWith("\n") ? "" : "\n"}${stderr}`;
+};
+var postBash = (input, env = process.env) => {
+  const options = readOptions(env);
+  const command = input.tool_input?.["command"];
+  const response = input.tool_response;
+  if (!options.output_cleaners || typeof command !== "string" || OWN_REPORTS.test(command) || typeof response !== "object" || response === null) {
+    return void 0;
+  }
+  const raw = rawOf(response);
+  if (raw === void 0 || raw === "") {
+    return void 0;
+  }
+  const session = input.session_id ?? "session";
+  const { out } = filterRun(raw, {
+    command,
+    exitCode: "0",
+    durationS: String(Math.round((input.duration_ms ?? 0) / 1e3)),
+    enabled: parseCleaners(options.cleaners),
+    holdout: options.output_holdout,
+    logsDir: outputDir(dataDir(env)),
+    // One file per call, named so a person can tell which session it came from.
+    runName: `${session}-${input.tool_use_id ?? Date.now().toString(36)}.log`,
+    sessionKey: session,
+    values: [],
+    tags: { project: projectDir(input, env), session }
+  });
+  if (out === raw) {
+    return void 0;
+  }
+  return { hookSpecificOutput: { hookEventName: "PostToolUse", updatedToolOutput: { ...response, stdout: out, stderr: "" } } };
+};
+if (process.argv[1]?.endsWith("post-bash.mjs")) {
+  await runHook((input) => postBash(input));
+}
+
+// src/sessions.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname3, join as join7 } from "node:path";
+var sessionsFile = (data) => join7(data, "sessions.jsonl");
+var readSessions = (data) => {
+  let text;
+  try {
+    text = readFileSync4(sessionsFile(data), "utf8");
+  } catch (error) {
+    if (isMissing2(error)) {
+      return [];
+    }
+    throw error;
+  }
+  const byId = /* @__PURE__ */ new Map();
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    try {
+      const row = JSON.parse(line);
+      if (typeof row.session === "string" && typeof row.project === "string") {
+        byId.set(row.session, row);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return [...byId.values()];
+};
+
+// src/stats.ts
+var MAX_SESSIONS = 150;
+var tokens2 = (count) => {
+  if (count >= 1e6) {
+    return `${(count / 1e6).toFixed(1)}M`;
+  }
+  if (count >= 1e4) {
+    return `${Math.round(count / 1e3)}k`;
+  }
+  return count >= 1e3 ? `${(count / 1e3).toFixed(1)}k` : String(count);
+};
+var counted = (count, noun) => `${count} ${noun}${count === 1 ? "" : "s"}`;
+var readText = (path) => {
+  try {
+    return readFileSync5(path, "utf8");
+  } catch (error) {
+    if (isMissing2(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+};
+var cleanerLines = (summary, options) => {
+  if (summary.commands === 0) {
+    return [options.output_cleaners ? "No commands have been trimmed yet." : "Switched off (`output_cleaners` in /config)."];
+  }
+  const cleaned = summary.holdout.cleaned;
+  const lines = [
+    `${counted(cleaned, "command")} trimmed: ${tokens2(summary.rawTokens)} tokens of output became ${tokens2(summary.emittedTokens)} (${summary.savedPct}% saved, exact per command).`
+  ];
+  const stages = summary.perCleaner.filter((stage) => stage.savedTokens > 0).slice(0, 6);
+  if (stages.length > 0) {
+    lines.push(`Biggest cleaners: ${stages.map((stage) => `${stage.id} ${tokens2(stage.savedTokens)} (${counted(stage.commands, "command")})`).join(", ")}.`);
+  }
+  const { heldOut, measuredSavedPct } = summary.holdout;
+  if (measuredSavedPct !== void 0) {
+    lines.push(`Against ${counted(heldOut, "untrimmed command")}, the median output is ${measuredSavedPct}% smaller.`);
+  } else if (heldOut > 0) {
+    lines.push(`The untrimmed comparison has ${counted(heldOut, "command")}; it reports once it is large enough and the difference is clear.`);
+  } else {
+    lines.push("No commands are left untrimmed (`output_holdout` is 0), so the saving is exact per command but has no control group.");
+  }
+  const gaps = summary.gaps.slice(0, 3);
+  if (gaps.length > 0) {
+    lines.push(`Untouched and still costly: ${gaps.map((gap) => `\`${gap.command}\` ${tokens2(gap.tokens)} over ${gap.commands}`).join(", ")}.`);
+  }
+  return lines;
+};
+var turnsOf = (row) => {
+  if (row.transcript === void 0) {
+    return [];
+  }
+  const session = readClaudeSession(row.transcript, { root: row.project });
+  return (session?.turns ?? []).map((turn) => {
+    const metrics = createTurnMetrics(row.project);
+    const edited = [];
+    for (const call of turn.calls) {
+      metrics.call(call);
+      if (call.category === "edit") {
+        edited.push(...(call.locations ?? []).map((location) => location.path));
+      }
+    }
+    for (const failure of turn.failures) {
+      metrics.failed(failure.id);
+    }
+    return {
+      conversationId: row.session,
+      at: turn.at,
+      turnIndex: turn.index,
+      ...metrics.reading(edited),
+      mapArm: row.arms.map,
+      notesArm: row.arms.notes,
+      iqArm: row.arms.iq,
+      notesCohort: row.notesRevision
+    };
+  });
+};
+var DESIGNS = [
+  { title: "Project map", option: "project_map", design: { ...MECHANISMS.map, arm: (turn) => turn.mapArm, cohort: () => void 0 }, reads: "root listings in the opening turn" },
+  {
+    title: "Field notes",
+    option: "field_notes",
+    design: { ...MECHANISMS.notes, arm: (turn) => turn.notesArm, cohort: (turn) => turn.notesCohort },
+    reads: "failed tool calls per turn"
+  },
+  { title: "iq teaching", option: "iq", design: { ...MECHANISMS.search, arm: (turn) => turn.iqArm, cohort: () => void 0 }, reads: "search calls per turn" }
+];
+var readingLine = (reading, unit) => {
+  const arms = `${reading.on.mean} with it vs ${reading.off.mean} without, over ${reading.on.turns} and ${reading.off.turns} ${unit}`;
+  if (reading.deltaPct !== void 0 && reading.marginPct !== void 0) {
+    return `${reading.deltaPct > 0 ? "+" : ""}${reading.deltaPct}% \xB1${reading.marginPct}pp (95%): ${arms}.`;
+  }
+  if (reading.marginPct !== void 0) {
+    return `no difference yet beyond \xB1${reading.marginPct}pp (95%): ${arms}.`;
+  }
+  return `measuring, ${Math.min(reading.on.turns, reading.off.turns)} of ${MIN_ARM_TURNS} ${unit} in the smaller arm: ${arms}.`;
+};
+var mechanismLine = (title, reads, on, experiment, holdout) => {
+  if (!on) {
+    return `${title}: switched off.`;
+  }
+  if (holdout === 0) {
+    return `${title}: on for every session; nothing is held out (\`holdout\` is 0), so there is nothing to compare.`;
+  }
+  if (experiment === void 0) {
+    return `${title}: no measured sessions yet.`;
+  }
+  return `${title}, ${reads}: ${readingLine(experiment.metrics[0], experiment.sampleUnit ?? "conversations")}`;
+};
+var countShadows = (dir) => {
+  let count = 0;
+  const walk = (current) => {
+    let entries;
+    try {
+      entries = readdirSync3(current, { withFileTypes: true });
+    } catch (error) {
+      if (isMissing2(error)) {
+        return;
+      }
+      throw error;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        walk(join8(current, entry.name));
+      } else if (entry.name.endsWith(".md")) {
+        count += 1;
+      }
+    }
+  };
+  walk(dir);
+  return count;
+};
+var lastSweep = (data, project) => {
+  const text = readText(join8(data, "shadows", `${projectSlug(project)}.sweep.log`));
+  try {
+    const summary = JSON.parse(text ?? "");
+    return typeof summary.derived === "number" && typeof summary.fresh === "number" ? ` (last sweep: ${summary.derived} derived, ${summary.fresh} already fresh${typeof summary.pruned === "number" && summary.pruned > 0 ? `, ${summary.pruned} pruned` : ""})` : "";
+  } catch {
+    return "";
+  }
+};
+var shadowLine = (args) => {
+  if (!args.options.shadows) {
+    return "Document shadows: switched off.";
+  }
+  if (args.project === void 0) {
+    return "Document shadows: reported per project.";
+  }
+  const count = countShadows(join8(args.project, DERIVED_DIR));
+  return `Document shadows: ${count} documents have a markdown shadow${lastSweep(args.data, args.project)}. Nothing measures what they save yet.`;
+};
+var inScope = (args, project) => args.project === void 0 || project === args.project;
+var statsReport = (args) => {
+  const rows = parseStatsFile(readText(join8(outputDir(args.data), "filter-stats.jsonl")) ?? "").filter((row) => inScope(args, row.project));
+  const sessions = readSessions(args.data).filter((row) => inScope(args, row.project)).toSorted((left, right) => right.ts - left.ts).slice(0, MAX_SESSIONS);
+  const turns = sessions.flatMap(turnsOf);
+  const switches = Object.keys(OPTIONS).map((key) => `${key}=${String(args.options[key])}`).join(" ");
+  return [
+    `# intentic: what the plugin saved`,
+    ``,
+    `Scope: ${args.project === void 0 ? "every project" : `\`${args.project}\``} \xB7 ${sessions.length} recorded sessions \xB7 switches as the last session opened: ${switches}`,
+    ``,
+    `## Bash output`,
+    ...cleanerLines(summarizeStats(rows), args.options),
+    ``,
+    `## Session context`,
+    ...DESIGNS.map(
+      ({ title, option, design, reads }) => mechanismLine(title, reads, args.options[option] === true, measureExperiment(turns, design), args.options.holdout)
+    ),
+    ``,
+    shadowLine(args),
+    ``
+  ].join("\n");
+};
+var parseStatsArgs = (argv) => {
+  let data = "";
+  let project;
+  let all = false;
+  const overrides = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index] ?? "";
+    if (arg === "--data") {
+      data = argv[index += 1] ?? "";
+    } else if (arg === "--project") {
+      project = argv[index += 1];
+    } else if (arg === "--option") {
+      const [key, ...value] = (argv[index += 1] ?? "").split("=");
+      overrides[optionEnvName(key ?? "")] = value.join("=");
+    } else if (arg === "all") {
+      all = true;
+    }
+  }
+  const saved = loadOptions(data);
+  const env = Object.fromEntries(Object.keys(OPTIONS).map((key) => [optionEnvName(key), String(saved[key])]));
+  return { data, project: all ? void 0 : project, options: readOptions({ ...env, ...overrides }) };
+};
+if (process.argv[1]?.endsWith("stats.mjs")) {
+  process.stdout.write(statsReport(parseStatsArgs(process.argv.slice(2))));
+}
+export {
+  parseStatsArgs,
+  statsReport,
+  turnsOf
+};