@intentic/claude-plugin 1.317.0

package/dist/notes-evidence.mjs

@@ -0,0 +1,749 @@
+import { createRequire as __intenticRequire } from 'node:module'; const require = __intenticRequire(import.meta.url);
+
+// src/notes-evidence.ts
+import { readdirSync as readdirSync2, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+
+// ../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 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;
+};
+
+// ../output-cleaners/src/cleaners.mjs
+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((sum, line) => sum + 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 WIDE_RUN = 400;
+var WIDE_PATTERN = new RegExp(String.raw`\S{${WIDE_RUN + 1},}`, "g");
+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 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 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`
+);
+
+// ../output-cleaners/src/filter-stats.mjs
+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 "";
+};
+
+// src/hook-io.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var fieldNotesFile = (project) => join2(project, ".claude", "intentic", "field-notes.toon");
+var transcriptDir = (project, env = process.env) => join2(env["CLAUDE_CONFIG_DIR"] ?? join2(homedir(), ".claude"), "projects", project.replace(/[^a-zA-Z0-9]/g, "-"));
+
+// src/runtime.ts
+var isMissing2 = (error) => {
+  const code = typeof error === "object" && error !== null ? error.code : void 0;
+  return code === "ENOENT" || code === "ENOTDIR";
+};
+
+// src/notes-evidence.ts
+var MAX_SESSIONS = 200;
+var BUDGET_CHARS = 12e3;
+var tally = (map, key) => {
+  const found = map.get(key);
+  if (found !== void 0) {
+    return found;
+  }
+  const created = { runs: 0, failures: 0, sessions: /* @__PURE__ */ new Set(), examples: /* @__PURE__ */ new Set() };
+  map.set(key, created);
+  return created;
+};
+var signatureOf = (call) => call.name === "Bash" && call.target !== void 0 ? `\`${commandSignature(call.target) || call.target.slice(0, 40)}\`` : call.name;
+var openingOf = (prompt) => {
+  const name = /<command-name>([^<]*)<\/command-name>/.exec(prompt)?.[1]?.trim();
+  if (name === void 0 || name === "") {
+    return (prompt.split("\n")[0] ?? "").slice(0, 140);
+  }
+  const args = /<command-args>([^<]*)<\/command-args>/.exec(prompt)?.[1]?.trim() ?? "";
+  return `${name.startsWith("/") ? name : `/${name}`}${args === "" ? "" : ` ${args.slice(0, 120)}`}`;
+};
+var exampleOf = (text) => {
+  const first = text.split("\n").map((line) => line.trim()).find((line) => line !== "" && !/^Exit code \d+$/.test(line)) ?? text.trim();
+  return first.length > 160 ? `${first.slice(0, 157)}\u2026` : first;
+};
+var tallyCalls = (calls, session, commands, edited) => {
+  for (const call of calls) {
+    if (call.name === "Bash") {
+      const entry = tally(commands, signatureOf(call));
+      entry.runs += 1;
+      entry.sessions.add(session);
+    }
+    for (const { path } of call.category === "edit" ? call.locations ?? [] : []) {
+      const entry = tally(edited, path);
+      entry.runs += 1;
+      entry.sessions.add(session);
+    }
+  }
+};
+var digestOf = (sessions) => {
+  const failed = /* @__PURE__ */ new Map();
+  const commands = /* @__PURE__ */ new Map();
+  const edited = /* @__PURE__ */ new Map();
+  const prompts = [];
+  let turns = 0;
+  let calls = 0;
+  let failures = 0;
+  let from;
+  let to;
+  for (const [index, session] of sessions.entries()) {
+    const id = session.sessionId ?? String(index);
+    const first = session.turns[0];
+    if (first !== void 0) {
+      from = Math.min(from ?? first.at, first.at);
+      to = Math.max(to ?? first.at, session.turns.at(-1)?.at ?? first.at);
+      prompts.push(openingOf(first.prompt));
+    }
+    for (const turn of session.turns) {
+      turns += 1;
+      calls += turn.calls.length;
+      failures += turn.failures.length;
+      const byId = new Map(turn.calls.map((call) => [call.id, call]));
+      tallyCalls(turn.calls, id, commands, edited);
+      for (const failure of turn.failures) {
+        const call = byId.get(failure.id);
+        const key = call === void 0 ? "a subagent's call" : signatureOf(call);
+        const entry = tally(failed, key);
+        entry.failures += 1;
+        entry.sessions.add(id);
+        if (entry.examples.size < 2) {
+          entry.examples.add(exampleOf(failure.text));
+        }
+        if (call?.name === "Bash") {
+          tally(commands, key).failures += 1;
+        }
+      }
+    }
+  }
+  return { sessions: sessions.length, from, to, turns, calls, failures, failed, commands, edited, prompts };
+};
+var bySessions = (map) => [...map.entries()].toSorted((left, right) => right[1].sessions.size - left[1].sessions.size || right[1].runs - left[1].runs);
+var utcDay = (at) => at === void 0 ? "?" : new Date(at).toISOString().slice(0, 10);
+var renderDigest = (digest, project, notesFile) => {
+  const head = [
+    `Corpus: ${digest.sessions} sessions of this project (${utcDay(digest.from)} to ${utcDay(digest.to)}), ${digest.turns} turns, ${digest.calls} tool calls, ${digest.failures} of them failed.`,
+    `Notes file: \`${notesFile}\` (read it first if it exists; this digest does not include it).`
+  ];
+  const sections = [
+    [
+      "Failures, by how many sessions hit them",
+      bySessions(digest.failed).slice(0, 25).map(([key, entry]) => `- ${key}: ${entry.failures} failures in ${entry.sessions.size} sessions \u2014 e.g. ${[...entry.examples].map((text) => `"${text}"`).join("; ")}`)
+    ],
+    [
+      "Commands run, with how often they failed",
+      bySessions(digest.commands).slice(0, 20).map(([key, entry]) => `- ${key}: ${entry.runs} runs in ${entry.sessions.size} sessions, ${entry.failures} failed`)
+    ],
+    ["Files edited in the most sessions", bySessions(digest.edited).slice(0, 12).map(([path, entry]) => `- ${path}: ${entry.sessions.size} sessions`)],
+    ["How recent sessions opened (first line of the first prompt)", digest.prompts.slice(0, 15).map((prompt) => `- ${prompt}`)]
+  ];
+  const lines = [...head];
+  let used = head.join("\n").length;
+  for (const [title, items] of sections) {
+    const heading = `
+### ${title}`;
+    used += heading.length;
+    lines.push(heading);
+    for (const item of items.length === 0 ? ["- none"] : items) {
+      if (used + item.length + 1 > BUDGET_CHARS) {
+        lines.push("- \u2026 cut to fit");
+        break;
+      }
+      used += item.length + 1;
+      lines.push(item);
+    }
+  }
+  return redactText(`${lines.join("\n")}
+
+Transcripts: \`${transcriptDir(project)}\` (one JSON object per line).
+`);
+};
+var sessionFiles = (dir) => {
+  let names;
+  try {
+    names = readdirSync2(dir).filter((name) => name.endsWith(".jsonl"));
+  } catch (error) {
+    if (isMissing2(error)) {
+      return [];
+    }
+    throw error;
+  }
+  return names.map((name) => {
+    try {
+      return { path: join3(dir, name), at: statSync(join3(dir, name)).mtimeMs };
+    } catch {
+      return { path: join3(dir, name), at: 0 };
+    }
+  }).toSorted((left, right) => right.at - left.at).slice(0, MAX_SESSIONS).map((entry) => entry.path);
+};
+var notesEvidence = (project) => {
+  const sessions = sessionFiles(transcriptDir(project)).flatMap((file) => {
+    const session = readClaudeSession(file, { root: project });
+    return session === void 0 || session.turns.length === 0 ? [] : [session];
+  });
+  return renderDigest(digestOf(sessions), project, fieldNotesFile(project));
+};
+if (process.argv[1]?.endsWith("notes-evidence.mjs")) {
+  const at = process.argv.indexOf("--project");
+  process.stdout.write(notesEvidence(at === -1 ? process.cwd() : process.argv[at + 1] ?? process.cwd()));
+}
+export {
+  digestOf,
+  notesEvidence,
+  openingOf,
+  renderDigest
+};