@hawkeyexl/manni 4.5.0 → 4.7.0

package/dist/chunk-CU57HT2E.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import {
+  TracevalsError
+} from "./chunk-UKZNLVJW.js";
+
+// src/tracevals/judge/redact.ts
+var SECRET_NAME = "(?:(?:[A-Za-z0-9]+[_\\-.])*(?:api[_\\-.]?key|access[_\\-.]?key|secret[_\\-.]?key|auth[_\\-.]?token|access[_\\-.]?token|refresh[_\\-.]?token|client[_\\-.]?secret|session[_\\-.]?token|key|token|secret|password|passwd|passphrase|credentials?|authorization)|AWS_[A-Za-z0-9_]+)";
+var REDACTION_PATTERNS = [
+  {
+    label: "private-key",
+    pattern: /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+    replacement: "[redacted:private-key]"
+  },
+  {
+    // `sk-`, `sk-ant-…`, `pk-`, `rk-`: the OpenAI/Anthropic/Stripe family.
+    label: "api-key",
+    pattern: /\b[sprk]k-(?:[A-Za-z0-9]+-)*[A-Za-z0-9_-]{16,}/g,
+    replacement: "[redacted:api-key]"
+  },
+  {
+    label: "aws-access-key-id",
+    pattern: /\b(?:AKIA|ASIA|AROA|AIDA)[0-9A-Z]{16}\b/g,
+    replacement: "[redacted:aws-access-key-id]"
+  },
+  {
+    label: "github-token",
+    pattern: /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g,
+    replacement: "[redacted:github-token]"
+  },
+  {
+    label: "slack-token",
+    pattern: /\bxox[abeoprs]-[A-Za-z0-9-]{10,}/g,
+    replacement: "[redacted:slack-token]"
+  },
+  {
+    label: "google-api-key",
+    pattern: /\bAIza[0-9A-Za-z_-]{35}\b/g,
+    replacement: "[redacted:google-api-key]"
+  },
+  {
+    label: "jwt",
+    pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+    replacement: "[redacted:jwt]"
+  },
+  {
+    // `Authorization: Bearer …`, `Basic …`, `Token …`. The scheme is kept so
+    // the judge can still see that authentication happened.
+    //
+    // Deliberately *not* case-insensitive as a whole: `basic` and `token` are
+    // ordinary English words, and `/i` would redact "basic configuration" as an
+    // auth header. `bearer` is not, so it gets both spellings.
+    label: "auth-token",
+    pattern: /\b([Bb]earer|Basic|Token)\s+[A-Za-z0-9\-._~+/]{12,}={0,2}/g,
+    replacement: "$1 [redacted:auth-token]"
+  },
+  {
+    // JSON member — the shape a tool input renders as.
+    label: "secret-member",
+    pattern: new RegExp(`("${SECRET_NAME}"\\s*:\\s*)"[^"]*"`, "gi"),
+    replacement: '$1"[redacted:secret-value]"'
+  },
+  {
+    // Shell / `.env` assignment. The variable name is kept: knowing that a
+    // secret was set, and which one, is often the adherence question.
+    label: "secret-assignment",
+    pattern: new RegExp(
+      `\\b(${SECRET_NAME})(\\s*=\\s*)(?:"[^"\\n]*"|'[^'\\n]*'|[^\\s"'\\n]+)`,
+      "gi"
+    ),
+    replacement: "$1$2[redacted:secret-value]"
+  }
+];
+var CUSTOM_PLACEHOLDER = "[redacted]";
+function makeRedactor(extra = []) {
+  const custom = compileRedactPatterns(extra).map(
+    (pattern) => [pattern, CUSTOM_PLACEHOLDER]
+  );
+  const all = [
+    ...REDACTION_PATTERNS.map(
+      ({ pattern, replacement }) => [pattern, replacement]
+    ),
+    ...custom
+  ];
+  return (text) => {
+    let out = text;
+    for (const [pattern, replacement] of all) {
+      out = out.replace(pattern, replacement);
+    }
+    return out;
+  };
+}
+function compileRedactPatterns(sources) {
+  return sources.map((source) => {
+    try {
+      return new RegExp(source, "g");
+    } catch (err) {
+      throw new TracevalsError(
+        `invalid config: judge.redact pattern ${JSON.stringify(source)} is not a valid regular expression: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  });
+}
+
+// src/tracevals/capture/types.ts
+var MANIFEST_VERSION = 1;
+var DEFAULT_CAPTURE_DIR = ".manni/tracevals/sessions";
+
+export {
+  REDACTION_PATTERNS,
+  CUSTOM_PLACEHOLDER,
+  makeRedactor,
+  compileRedactPatterns,
+  MANIFEST_VERSION,
+  DEFAULT_CAPTURE_DIR
+};
+//# sourceMappingURL=chunk-CU57HT2E.js.map

package/dist/chunk-CU57HT2E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tracevals/judge/redact.ts","../src/tracevals/capture/types.ts"],"sourcesContent":["/**\n * Redaction for the judge digest (ADR 01020).\n *\n * `renderTrace` builds the only trace-derived text that leaves this machine,\n * and a session transcript routinely carries credentials: a `Bash` input with\n * an `Authorization` header, an `.env` file echoed into a message, a key pasted\n * into a prompt. Every block that enters the digest is filtered through here\n * first.\n *\n * This is **best-effort pattern matching, not a guarantee.** It recognizes\n * shapes — vendor key prefixes, auth schemes, secret-looking assignment names —\n * so it catches the common accidents and cannot catch an arbitrary secret that\n * looks like ordinary prose. `--deterministic-only` is the only setting that\n * guarantees nothing leaves the machine.\n *\n * Two properties the rest of the system leans on:\n *\n *  - **Stable output.** A given input always redacts to the same text, so\n *    `sha256(renderedTrace)` stays a usable judge cache key.\n *  - **Idempotent.** Placeholders contain no `=`, no `:` inside quotes, and no\n *    vendor prefix, so redacting redacted text is a no-op.\n */\nimport { TracevalsError } from \"../types.js\";\n\nexport interface RedactionPattern {\n  /** Kebab name; appears in the placeholder so a reader knows what went. */\n  label: string;\n  pattern: RegExp;\n  /** Replacement template; `$1`-style references into `pattern` are allowed. */\n  replacement: string;\n}\n\n/**\n * Names that mark a value as secret, in the shapes they appear in shell\n * assignments and in JSON object members (tool inputs render as JSON).\n *\n * The whole name must match, which is what keeps `monkey` out of the `key`\n * alternative: the `(?:[A-Za-z0-9]+[_\\-.])*` prefix only consumes segments that\n * end in a separator. `api[_\\-.]?key` covers `apiKey` and `API_KEY` alike under\n * the `i` flag.\n */\nconst SECRET_NAME =\n  \"(?:(?:[A-Za-z0-9]+[_\\\\-.])*(?:api[_\\\\-.]?key|access[_\\\\-.]?key|secret[_\\\\-.]?key|auth[_\\\\-.]?token|access[_\\\\-.]?token|refresh[_\\\\-.]?token|client[_\\\\-.]?secret|session[_\\\\-.]?token|key|token|secret|password|passwd|passphrase|credentials?|authorization)|AWS_[A-Za-z0-9_]+)\";\n\n/**\n * Applied in order. Broad structural shapes first (a private key block spans\n * lines and would otherwise be chewed up by the narrower rules), then vendor\n * prefixes, then name-driven assignment forms.\n */\nexport const REDACTION_PATTERNS: readonly RedactionPattern[] = [\n  {\n    label: \"private-key\",\n    pattern:\n      /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\\s\\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,\n    replacement: \"[redacted:private-key]\",\n  },\n  {\n    // `sk-`, `sk-ant-…`, `pk-`, `rk-`: the OpenAI/Anthropic/Stripe family.\n    label: \"api-key\",\n    pattern: /\\b[sprk]k-(?:[A-Za-z0-9]+-)*[A-Za-z0-9_-]{16,}/g,\n    replacement: \"[redacted:api-key]\",\n  },\n  {\n    label: \"aws-access-key-id\",\n    pattern: /\\b(?:AKIA|ASIA|AROA|AIDA)[0-9A-Z]{16}\\b/g,\n    replacement: \"[redacted:aws-access-key-id]\",\n  },\n  {\n    label: \"github-token\",\n    pattern: /\\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\\b/g,\n    replacement: \"[redacted:github-token]\",\n  },\n  {\n    label: \"slack-token\",\n    pattern: /\\bxox[abeoprs]-[A-Za-z0-9-]{10,}/g,\n    replacement: \"[redacted:slack-token]\",\n  },\n  {\n    label: \"google-api-key\",\n    pattern: /\\bAIza[0-9A-Za-z_-]{35}\\b/g,\n    replacement: \"[redacted:google-api-key]\",\n  },\n  {\n    label: \"jwt\",\n    pattern: /\\beyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}/g,\n    replacement: \"[redacted:jwt]\",\n  },\n  {\n    // `Authorization: Bearer …`, `Basic …`, `Token …`. The scheme is kept so\n    // the judge can still see that authentication happened.\n    //\n    // Deliberately *not* case-insensitive as a whole: `basic` and `token` are\n    // ordinary English words, and `/i` would redact \"basic configuration\" as an\n    // auth header. `bearer` is not, so it gets both spellings.\n    label: \"auth-token\",\n    pattern: /\\b([Bb]earer|Basic|Token)\\s+[A-Za-z0-9\\-._~+/]{12,}={0,2}/g,\n    replacement: \"$1 [redacted:auth-token]\",\n  },\n  {\n    // JSON member — the shape a tool input renders as.\n    label: \"secret-member\",\n    pattern: new RegExp(`(\"${SECRET_NAME}\"\\\\s*:\\\\s*)\"[^\"]*\"`, \"gi\"),\n    replacement: '$1\"[redacted:secret-value]\"',\n  },\n  {\n    // Shell / `.env` assignment. The variable name is kept: knowing that a\n    // secret was set, and which one, is often the adherence question.\n    label: \"secret-assignment\",\n    pattern: new RegExp(\n      `\\\\b(${SECRET_NAME})(\\\\s*=\\\\s*)(?:\"[^\"\\\\n]*\"|'[^'\\\\n]*'|[^\\\\s\"'\\\\n]+)`,\n      \"gi\",\n    ),\n    replacement: \"$1$2[redacted:secret-value]\",\n  },\n];\n\n/** Placeholder used for a pattern the config supplied; it has no label. */\nexport const CUSTOM_PLACEHOLDER = \"[redacted]\";\n\nexport type Redactor = (text: string) => string;\n\n/**\n * Build the redactor for a run. Configured patterns are applied **after** the\n * built-ins and never replace them: a project adding one pattern of its own\n * must not silently lose the whole floor, which is the same reasoning that\n * makes `--require` additive (ADR 01017).\n *\n * A pattern that will not compile is an operational error raised here, not a\n * throw from inside the judge and never a silent skip — a dropped pattern is a\n * silent leak.\n */\nexport function makeRedactor(extra: readonly string[] = []): Redactor {\n  // Compiled once and reused across every block of a render. Safe with a `g`\n  // regex because `String.prototype.replace` sets `lastIndex` to 0 before it\n  // starts and leaves it at 0 — unlike `exec`/`test`, where the shared instance\n  // state would make a reused pattern skip matches.\n  const custom = compileRedactPatterns(extra).map(\n    (pattern) => [pattern, CUSTOM_PLACEHOLDER] as const,\n  );\n  const all: ReadonlyArray<readonly [RegExp, string]> = [\n    ...REDACTION_PATTERNS.map(\n      ({ pattern, replacement }) => [pattern, replacement] as const,\n    ),\n    ...custom,\n  ];\n  return (text) => {\n    let out = text;\n    for (const [pattern, replacement] of all) {\n      out = out.replace(pattern, replacement);\n    }\n    return out;\n  };\n}\n\n/**\n * Compile configured pattern sources, or say which one is unusable. Exported so\n * `parseConfig()` can reject a bad pattern at load time rather than at the\n * moment a digest is about to be sent.\n */\nexport function compileRedactPatterns(sources: readonly string[]): RegExp[] {\n  return sources.map((source) => {\n    try {\n      return new RegExp(source, \"g\");\n    } catch (err) {\n      throw new TracevalsError(\n        `invalid config: judge.redact pattern ${JSON.stringify(source)} is not a valid regular expression: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      );\n    }\n  });\n}\n","/**\n * The session manifest: what the project's instruction artifacts said, and\n * which commit they said it at, **when the session started** (ADR 01024).\n *\n * ADR 01016 established that the availability roster — what the session was\n * offered — is recoverable from the transcript itself, retroactively and on any\n * machine. Two things are not: the artifact **bodies** and the **git SHA**. The\n * transcript injects skill instructions into the model's context without ever\n * recording their text, so \"the SKILL.md says X now; did it say X then?\" has no\n * answer inside the trace. ADR 01021 answers it with mtime, which is a\n * heuristic that a `git checkout` defeats wholesale.\n *\n * A manifest closes that gap by recording, at session start, a sha256 per\n * instruction artifact. `run` then compares — and a mismatch is exact where\n * mtime was a guess.\n *\n * **A manifest is a claim, not proof.** It is written by the capturing device\n * and travels with the repository, so it is evidence *about that device*. It\n * never reaches an eval outcome, never moves the exit code, and never turns a\n * `skipped` into a `pass`; the only thing it may quiet is the mtime warning,\n * whose own question it answers exactly.\n *\n * Types and constants only, with no dependency of its own beyond\n * `ArtifactType` — `artifacts/resolve.ts` consumes a manifest and\n * `capture/build.ts` produces one from `artifacts/discover.ts`, so anything\n * shared has to sit below both or the two would import each other.\n */\nimport type { ArtifactType } from \"../artifacts/types.js\";\n\n/**\n * Manifest format version. Bumped when the *shape* changes incompatibly; a\n * manifest from a higher version is ignored rather than half-read, because a\n * partial read of an evidence file is worse than no evidence.\n */\nexport const MANIFEST_VERSION = 1;\n\n/** Default directory, under the state directory the judge cache already uses. */\nexport const DEFAULT_CAPTURE_DIR = \".manni/tracevals/sessions\";\n\nexport interface ManifestArtifact {\n  /** Reference name, spelled as the coverage table spells it. */\n  name: string;\n  type: ArtifactType;\n  /**\n   * Path relative to `root`, with POSIX separators — never absolute, so the\n   * manifest still joins after the repository is checked out somewhere else.\n   */\n  path: string;\n  /** Lowercase hex sha256 of the file's bytes at capture time. */\n  sha256: string;\n  bytes: number;\n}\n\n/** What `git` could answer about the project at capture time. */\nexport interface ManifestGit {\n  /** The commit the session ran against. */\n  sha: string;\n  branch?: string;\n  /** Tracked files differed from the commit, so `sha` alone is incomplete. */\n  dirty: boolean;\n}\n\nexport interface SessionManifest {\n  version: number;\n  sessionId: string;\n  /** When `capture` ran, ISO-8601. */\n  capturedAt: string;\n  /** The hook that supplied the payload, or `manual` for a direct run. */\n  hookEvent: string;\n  /** How the session started or why it ended, when the payload said so. */\n  reason?: string;\n  /** Where the session file will be written. A correlation key, never read. */\n  transcriptPath?: string;\n  /** Project root the artifact paths are relative to. */\n  root: string;\n  git?: ManifestGit;\n  /**\n   * Which machine captured this. An opaque digest rather than the hostname:\n   * the question a reader has is \"same machine or not\", and that does not need\n   * the name of the machine to answer.\n   */\n  device: { id: string; platform: string };\n  tool: { name: string; version: string };\n  artifacts: ManifestArtifact[];\n  /** The resolved `tracevals:` section, redacted. Recorded, not consumed. */\n  config: unknown;\n}\n\nexport type ContentCheckStatus = \"match\" | \"mismatch\" | \"skipped\";\n\n/**\n * Whether an artifact still says what the manifest recorded. Three-valued on\n * purpose: `skipped` is not a shade of `match`, and collapsing them would let\n * an absent manifest read as a clean bill of health.\n */\nexport interface ContentCheck {\n  status: ContentCheckStatus;\n  /** Why no comparison was possible. Present only on `skipped`. */\n  reason?: string;\n  /** The digest recorded at capture time. */\n  expected?: string;\n  /** The digest of the file as it is now. */\n  actual?: string;\n}\n\n/** The manifest `run` consulted, summarised for the report. */\nexport interface ManifestReport {\n  /** Where it was read from. */\n  path: string;\n  sessionId: string;\n  capturedAt: string;\n  /** The commit the session ran against, when git could answer. */\n  gitSha?: string;\n  /** Coverage rows the manifest could speak to, and what it said. */\n  matched: number;\n  changed: number;\n  /** Rows it had nothing to say about; those keep the mtime heuristic. */\n  unrecorded: number;\n}\n"],"mappings":";;;;;;AAyCA,IAAM,cACJ;AAOK,IAAM,qBAAkD;AAAA,EAC7D;AAAA,IACE,OAAO;AAAA,IACP,SACE;AAAA,IACF,aAAa;AAAA,EACf;AAAA,EACA;AAAA;AAAA,IAEE,OAAO;AAAA,IACP,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AAAA,EACA;AAAA,IACE,OAAO;AAAA,IACP,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AAAA,EACA;AAAA,IACE,OAAO;AAAA,IACP,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AAAA,EACA;AAAA,IACE,OAAO;AAAA,IACP,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AAAA,EACA;AAAA,IACE,OAAO;AAAA,IACP,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AAAA,EACA;AAAA,IACE,OAAO;AAAA,IACP,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOE,OAAO;AAAA,IACP,SAAS;AAAA,IACT,aAAa;AAAA,EACf;AAAA,EACA;AAAA;AAAA,IAEE,OAAO;AAAA,IACP,SAAS,IAAI,OAAO,KAAK,WAAW,sBAAsB,IAAI;AAAA,IAC9D,aAAa;AAAA,EACf;AAAA,EACA;AAAA;AAAA;AAAA,IAGE,OAAO;AAAA,IACP,SAAS,IAAI;AAAA,MACX,OAAO,WAAW;AAAA,MAClB;AAAA,IACF;AAAA,IACA,aAAa;AAAA,EACf;AACF;AAGO,IAAM,qBAAqB;AAc3B,SAAS,aAAa,QAA2B,CAAC,GAAa;AAKpE,QAAM,SAAS,sBAAsB,KAAK,EAAE;AAAA,IAC1C,CAAC,YAAY,CAAC,SAAS,kBAAkB;AAAA,EAC3C;AACA,QAAM,MAAgD;AAAA,IACpD,GAAG,mBAAmB;AAAA,MACpB,CAAC,EAAE,SAAS,YAAY,MAAM,CAAC,SAAS,WAAW;AAAA,IACrD;AAAA,IACA,GAAG;AAAA,EACL;AACA,SAAO,CAAC,SAAS;AACf,QAAI,MAAM;AACV,eAAW,CAAC,SAAS,WAAW,KAAK,KAAK;AACxC,YAAM,IAAI,QAAQ,SAAS,WAAW;AAAA,IACxC;AACA,WAAO;AAAA,EACT;AACF;AAOO,SAAS,sBAAsB,SAAsC;AAC1E,SAAO,QAAQ,IAAI,CAAC,WAAW;AAC7B,QAAI;AACF,aAAO,IAAI,OAAO,QAAQ,GAAG;AAAA,IAC/B,SAAS,KAAK;AACZ,YAAM,IAAI;AAAA,QACR,wCAAwC,KAAK,UAAU,MAAM,CAAC,uCAC5D,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CACjD;AAAA,MACF;AAAA,IACF;AAAA,EACF,CAAC;AACH;;;ACzIO,IAAM,mBAAmB;AAGzB,IAAM,sBAAsB;","names":[]}

package/dist/chunk-CWXZ2MRT.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+// src/tracevals/graders/util.ts
+function finding(plan, message) {
+  return {
+    evalName: plan.evalName,
+    artifact: plan.artifact.path,
+    message,
+    severity: plan.severity
+  };
+}
+function fail(plan, message) {
+  return { findings: [finding(plan, message)] };
+}
+var pass = { findings: [] };
+function optionsError(kind, message) {
+  return { findings: [], error: `${kind}: ${message}` };
+}
+function firstError(...checks) {
+  return checks.find((check) => check !== void 0);
+}
+function requiredString(options, key) {
+  const value = options[key];
+  if (typeof value !== "string" || value.length === 0) {
+    return `options.${key} is required`;
+  }
+  return void 0;
+}
+function optionalString(options, key) {
+  const value = options[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length === 0) {
+    return `options.${key} must be a non-empty string`;
+  }
+  return void 0;
+}
+function optionalEnum(options, key, allowed) {
+  const value = options[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    return `options.${key} must be one of: ${allowed.join(", ")}`;
+  }
+  return void 0;
+}
+function optionalNumber(options, key, bounds = {}) {
+  const value = options[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return `options.${key} must be a finite number`;
+  }
+  if (bounds.integer === true && !Number.isInteger(value)) {
+    return `options.${key} must be a whole number`;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) {
+    return `options.${key} must be at least ${bounds.min}`;
+  }
+  return void 0;
+}
+function optionalBoolean(options, key) {
+  if (options[key] !== void 0 && typeof options[key] !== "boolean") {
+    return `options.${key} must be a boolean`;
+  }
+  return void 0;
+}
+function orderedBounds(options, minKey, maxKey) {
+  const min = options[minKey];
+  const max = options[maxKey];
+  if (typeof min === "number" && typeof max === "number" && min > max) {
+    return `options.${maxKey} must be greater than or equal to options.${minKey}`;
+  }
+  return void 0;
+}
+function requireOneOf(options, keys) {
+  if (keys.some((key) => options[key] !== void 0)) return void 0;
+  return `at least one of ${keys.map((k) => `options.${k}`).join(" or ")} is required`;
+}
+function windowFor(trace, plan) {
+  return windowOf(trace, plan.artifact);
+}
+function windowOf(trace, artifact) {
+  const { name, type } = artifact;
+  if (type === "skill") return skillWindow(trace, name);
+  if (type === "agent") return agentWindow(trace, name);
+  if (type === "slash-command") return slashCommandWindow(trace, name);
+  return {
+    scope: "session",
+    label: "whole session",
+    empty: false,
+    events: trace.events,
+    toolCalls: trace.toolCalls,
+    fileAccesses: trace.fileAccesses,
+    skillInvocations: trace.skillInvocations,
+    userMessages: trace.userMessages,
+    assistantTexts: trace.assistantTexts,
+    turnCount: trace.turnCount
+  };
+}
+function skippedWindow(window) {
+  return { findings: [], skipped: window.reason ?? "the artifact governed no turns" };
+}
+function skillWindow(trace, name) {
+  return injectionWindow(trace, "skill", `skill "${name}"`, (s) => s.name === name);
+}
+function slashCommandWindow(trace, name) {
+  return injectionWindow(
+    trace,
+    "slash-command",
+    `slash command "/${name}"`,
+    (s) => s.name === name && s.via === "command-injection"
+  );
+}
+function injectionWindow(trace, scope, label, opensHere) {
+  const opens = trace.skillInvocations.filter(opensHere).map((s) => s.index);
+  if (opens.length === 0) {
+    return emptyWindow(
+      scope,
+      label,
+      `${label} was never invoked in this trace, so it governed no turns`
+    );
+  }
+  const chainOf = (index) => trace.events[index]?.branchId;
+  const own = new Set(opens.map(chainOf));
+  const boundaries = trace.skillInvocations.filter((s) => own.has(chainOf(s.index))).map((s) => s.index).sort((a, b) => a - b);
+  const spans = opens.map((start) => ({
+    start,
+    end: boundaries.find((b) => b > start) ?? Number.POSITIVE_INFINITY
+  }));
+  return materialize(trace, scope, label, spans, void 0, own);
+}
+function agentWindow(trace, name) {
+  const label = `agent "${name}"`;
+  const mine = trace.subagentBranches.filter((b) => b.agentType === name);
+  if (mine.length === 0) {
+    const spawned = trace.agentSpawns.some((a) => a.subagentType === name);
+    return emptyWindow(
+      "agent",
+      label,
+      spawned ? `${label} was spawned but recorded no subagent turns (no inline sidechain records and no sidecar transcript), so it governed no turns` : `${label} was never spawned in this trace, so it governed no turns`
+    );
+  }
+  const branchIds = new Set(mine.map((b) => b.branchId));
+  for (const branch of trace.subagentBranches) {
+    if (branchIds.has(branch.branchId)) continue;
+    const nested = mine.some(
+      (m) => m.startIndex <= branch.startIndex && branch.endIndex <= m.endIndex
+    );
+    if (nested) branchIds.add(branch.branchId);
+  }
+  const spans = mine.map((b) => ({ start: b.startIndex, end: b.endIndex }));
+  return materialize(
+    trace,
+    "agent",
+    label,
+    spans,
+    branchIds,
+    new Set(mine.map((b) => b.branchId))
+  );
+}
+function emptyWindow(scope, label, reason) {
+  return {
+    scope,
+    label,
+    empty: true,
+    reason,
+    events: [],
+    toolCalls: [],
+    fileAccesses: [],
+    skillInvocations: [],
+    userMessages: [],
+    assistantTexts: [],
+    turnCount: 0
+  };
+}
+function materialize(trace, scope, label, spans, branchIds, own) {
+  const inSpan = (index) => spans.some((s) => index >= s.start && index < s.end);
+  const excluded = /* @__PURE__ */ new Set();
+  if (branchIds !== void 0) {
+    for (const event of trace.events) {
+      if (!inSpan(event.index)) continue;
+      if (event.branchId === void 0 || !branchIds.has(event.branchId)) {
+        excluded.add(event.index);
+      }
+    }
+  }
+  const inWindow = (index) => inSpan(index) && !excluded.has(index);
+  const events = trace.events.filter((e) => inWindow(e.index));
+  const textOf = (kind) => events.filter((e) => e.kind === kind && own.has(e.branchId) && e.text).map((e) => e.text);
+  const userMessages = textOf("user");
+  return {
+    scope,
+    label,
+    empty: false,
+    events,
+    toolCalls: trace.toolCalls.filter((c) => inWindow(c.index)),
+    fileAccesses: trace.fileAccesses.filter((a) => inWindow(a.index)),
+    skillInvocations: trace.skillInvocations.filter((s) => inWindow(s.index)),
+    userMessages,
+    assistantTexts: textOf("assistant"),
+    turnCount: userMessages.length
+  };
+}
+
+export {
+  finding,
+  fail,
+  pass,
+  optionsError,
+  firstError,
+  requiredString,
+  optionalString,
+  optionalEnum,
+  optionalNumber,
+  optionalBoolean,
+  orderedBounds,
+  requireOneOf,
+  windowFor,
+  windowOf,
+  skippedWindow,
+  emptyWindow,
+  materialize
+};
+//# sourceMappingURL=chunk-CWXZ2MRT.js.map

package/dist/chunk-CWXZ2MRT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tracevals/graders/util.ts"],"sourcesContent":["/** Shared helpers for deterministic graders. */\nimport type { EvalPlan } from \"../core/plan.js\";\nimport type {\n  FileAccess,\n  SkillInvocation,\n  ToolCall,\n  Trace,\n  TraceEvent,\n} from \"../trace/types.js\";\nimport type { Finding, GradeResult } from \"./types.js\";\n\nexport function finding(plan: EvalPlan, message: string): Finding {\n  return {\n    evalName: plan.evalName,\n    artifact: plan.artifact.path,\n    message,\n    severity: plan.severity,\n  };\n}\n\nexport function fail(plan: EvalPlan, message: string): GradeResult {\n  return { findings: [finding(plan, message)] };\n}\n\nexport const pass: GradeResult = { findings: [] };\n\nexport function optionsError(kind: string, message: string): GradeResult {\n  return { findings: [], error: `${kind}: ${message}` };\n}\n\n/** An option-validation outcome: a message when invalid, undefined when fine. */\nexport type OptionCheck = string | undefined;\n\nexport type Options = Record<string, unknown>;\n\n/** First failing check, so callers read as a flat list of constraints. */\nexport function firstError(...checks: OptionCheck[]): OptionCheck {\n  return checks.find((check) => check !== undefined);\n}\n\nexport function requiredString(options: Options, key: string): OptionCheck {\n  const value = options[key];\n  if (typeof value !== \"string\" || value.length === 0) {\n    return `options.${key} is required`;\n  }\n  return undefined;\n}\n\nexport function optionalString(options: Options, key: string): OptionCheck {\n  const value = options[key];\n  if (value === undefined) return undefined;\n  if (typeof value !== \"string\" || value.length === 0) {\n    return `options.${key} must be a non-empty string`;\n  }\n  return undefined;\n}\n\nexport function optionalEnum(\n  options: Options,\n  key: string,\n  allowed: readonly string[],\n): OptionCheck {\n  const value = options[key];\n  if (value === undefined) return undefined;\n  if (typeof value !== \"string\" || !allowed.includes(value)) {\n    return `options.${key} must be one of: ${allowed.join(\", \")}`;\n  }\n  return undefined;\n}\n\nexport function optionalNumber(\n  options: Options,\n  key: string,\n  bounds: { min?: number; integer?: boolean } = {},\n): OptionCheck {\n  const value = options[key];\n  if (value === undefined) return undefined;\n  // Number.isFinite also rejects NaN and both infinities.\n  if (typeof value !== \"number\" || !Number.isFinite(value)) {\n    return `options.${key} must be a finite number`;\n  }\n  if (bounds.integer === true && !Number.isInteger(value)) {\n    return `options.${key} must be a whole number`;\n  }\n  if (bounds.min !== undefined && value < bounds.min) {\n    return `options.${key} must be at least ${bounds.min}`;\n  }\n  return undefined;\n}\n\nexport function optionalBoolean(options: Options, key: string): OptionCheck {\n  if (options[key] !== undefined && typeof options[key] !== \"boolean\") {\n    return `options.${key} must be a boolean`;\n  }\n  return undefined;\n}\n\n/** Rejects min > max once both are present and already known to be numbers. */\nexport function orderedBounds(\n  options: Options,\n  minKey: string,\n  maxKey: string,\n): OptionCheck {\n  const min = options[minKey];\n  const max = options[maxKey];\n  if (typeof min === \"number\" && typeof max === \"number\" && min > max) {\n    return `options.${maxKey} must be greater than or equal to options.${minKey}`;\n  }\n  return undefined;\n}\n\n/**\n * Rejects a criterion that configures no bound at all. Such a criterion can\n * never fail, so it reads as coverage while asserting nothing.\n */\nexport function requireOneOf(options: Options, keys: string[]): OptionCheck {\n  if (keys.some((key) => options[key] !== undefined)) return undefined;\n  return `at least one of ${keys.map((k) => `options.${k}`).join(\" or \")} is required`;\n}\n\n// ── Scoped grading ───────────────────────────────────────────────\n\n/**\n * The slice of a trace an artifact was actually governing (ADR 01015). The\n * window is derived from the artifact's *type*, never declared: a skill governs\n * from its invocation until the next skill takes over, an agent governs its own\n * branch, and project rules govern the whole session.\n */\nexport interface TraceWindow {\n  /**\n   * Which rule produced this window. `turn` is the last turn of a session or\n   * a subagent's whole run, cut by `rules/turn.ts` (proposal 0079).\n   */\n  scope: \"session\" | \"skill\" | \"agent\" | \"slash-command\" | \"turn\";\n  /** Names the window in reasons and in the judge digest. */\n  label: string;\n  /**\n   * True when the artifact governed no turn at all. Graders must report\n   * `skipped` on an empty window — never a pass, which would be a verdict\n   * about turns the artifact had no part in.\n   */\n  empty: boolean;\n  /** Why the window is empty; set only when `empty`. */\n  reason?: string;\n  events: TraceEvent[];\n  toolCalls: ToolCall[];\n  fileAccesses: FileAccess[];\n  skillInvocations: SkillInvocation[];\n  /** Prompts on the window's own chain; nested subagent turns are excluded. */\n  userMessages: string[];\n  assistantTexts: string[];\n  turnCount: number;\n}\n\n/** Half-open ordinal range over `trace.events`; `end` may be Infinity. */\nexport interface Span {\n  start: number;\n  end: number;\n}\n\nexport function windowFor(trace: Trace, plan: EvalPlan): TraceWindow {\n  return windowOf(trace, plan.artifact);\n}\n\n/** `windowFor` keyed on the artifact alone, for callers with no eval plan. */\nexport function windowOf(\n  trace: Trace,\n  artifact: Pick<EvalPlan[\"artifact\"], \"name\" | \"type\">,\n): TraceWindow {\n  const { name, type } = artifact;\n  if (type === \"skill\") return skillWindow(trace, name);\n  if (type === \"agent\") return agentWindow(trace, name);\n  if (type === \"slash-command\") return slashCommandWindow(trace, name);\n  // Project rules govern everything, so the window is the trace itself —\n  // handed back by reference, so a session-scoped eval grades exactly what it\n  // graded before scoping existed.\n  return {\n    scope: \"session\",\n    label: \"whole session\",\n    empty: false,\n    events: trace.events,\n    toolCalls: trace.toolCalls,\n    fileAccesses: trace.fileAccesses,\n    skillInvocations: trace.skillInvocations,\n    userMessages: trace.userMessages,\n    assistantTexts: trace.assistantTexts,\n    turnCount: trace.turnCount,\n  };\n}\n\n/** A grader's response to an empty window: a stated skip, never a verdict. */\nexport function skippedWindow(window: TraceWindow): GradeResult {\n  return { findings: [], skipped: window.reason ?? \"the artifact governed no turns\" };\n}\n\nfunction skillWindow(trace: Trace, name: string): TraceWindow {\n  // A skill loads either way: through the `Skill` tool, or by someone typing\n  // its slash form.\n  return injectionWindow(trace, \"skill\", `skill \"${name}\"`, (s) => s.name === name);\n}\n\n/**\n * A slash command's window is a skill's window, because the mechanism is the\n * same one: an instruction set injected at a point in the session, in force\n * until the next injection takes over (ADR 01023). Only the opening differs —\n * a `Skill` tool call is not the slash-command mechanism, so it can close a\n * command's window but never open it.\n */\nfunction slashCommandWindow(trace: Trace, name: string): TraceWindow {\n  return injectionWindow(\n    trace,\n    \"slash-command\",\n    `slash command \"/${name}\"`,\n    (s) => s.name === name && s.via === \"command-injection\",\n  );\n}\n\n/**\n * The window an injected instruction set governed: from each of its own\n * injections until the next injection of any kind — including another of its\n * own, which simply reopens the window — or to the end of the session.\n */\nfunction injectionWindow(\n  trace: Trace,\n  scope: \"skill\" | \"slash-command\",\n  label: string,\n  opensHere: (invocation: SkillInvocation) => boolean,\n): TraceWindow {\n  const opens = trace.skillInvocations.filter(opensHere).map((s) => s.index);\n  if (opens.length === 0) {\n    return emptyWindow(\n      scope,\n      label,\n      `${label} was never invoked in this trace, so it governed no turns`,\n    );\n  }\n  // An instruction set injected inside a subagent branch governs that branch's\n  // chain; one injected on the main chain governs the main chain.\n  const chainOf = (index: number): string | undefined =>\n    trace.events[index]?.branchId;\n  const own = new Set<string | undefined>(opens.map(chainOf));\n  // **Boundaries are drawn from the opening chain only** (ADR 01015: the next\n  // invocation *on the same chain*). Drawn from every invocation, a subagent\n  // that loaded a skill of its own closed the parent's window at the spawn —\n  // so a `not-used` eval passed on turns it never saw, and the judge digest\n  // stopped where the subagent started.\n  const boundaries = trace.skillInvocations\n    .filter((s) => own.has(chainOf(s.index)))\n    .map((s) => s.index)\n    .sort((a, b) => a - b);\n  const spans = opens.map((start) => ({\n    start,\n    end: boundaries.find((b) => b > start) ?? Number.POSITIVE_INFINITY,\n  }));\n  return materialize(trace, scope, label, spans, undefined, own);\n}\n\nfunction agentWindow(trace: Trace, name: string): TraceWindow {\n  const label = `agent \"${name}\"`;\n  const mine = trace.subagentBranches.filter((b) => b.agentType === name);\n  if (mine.length === 0) {\n    const spawned = trace.agentSpawns.some((a) => a.subagentType === name);\n    return emptyWindow(\n      \"agent\",\n      label,\n      spawned\n        ? `${label} was spawned but recorded no subagent turns (no inline ` +\n            `sidechain records and no sidecar transcript), so it governed no turns`\n        : `${label} was never spawned in this trace, so it governed no turns`,\n    );\n  }\n  // A branch's span already covers everything nested under it (ADR 01014), so\n  // one containment pass reaches subagents at any depth.\n  const branchIds = new Set(mine.map((b) => b.branchId));\n  for (const branch of trace.subagentBranches) {\n    if (branchIds.has(branch.branchId)) continue;\n    const nested = mine.some(\n      (m) => m.startIndex <= branch.startIndex && branch.endIndex <= m.endIndex,\n    );\n    if (nested) branchIds.add(branch.branchId);\n  }\n  const spans = mine.map((b) => ({ start: b.startIndex, end: b.endIndex }));\n  return materialize(\n    trace,\n    \"agent\",\n    label,\n    spans,\n    branchIds,\n    new Set<string | undefined>(mine.map((b) => b.branchId)),\n  );\n}\n\nexport function emptyWindow(\n  scope: TraceWindow[\"scope\"],\n  label: string,\n  reason: string,\n): TraceWindow {\n  return {\n    scope,\n    label,\n    empty: true,\n    reason,\n    events: [],\n    toolCalls: [],\n    fileAccesses: [],\n    skillInvocations: [],\n    userMessages: [],\n    assistantTexts: [],\n    turnCount: 0,\n  };\n}\n\n/**\n * Cut every derived list to the spans. `branchIds`, when given, additionally\n * drops events that fall inside an *inline* branch's bounding range without\n * belonging to it — a sidecar branch is contiguous and loses nothing here, but\n * an inline one can enclose interleaved main-chain turns (ADR 01014).\n *\n * `own` names the chain the window is anchored to. Prompts and assistant text\n * are taken from that chain alone, so a subagent spawned inside the window\n * contributes tool calls and file accesses but not turns.\n */\nexport function materialize(\n  trace: Trace,\n  scope: TraceWindow[\"scope\"],\n  label: string,\n  spans: Span[],\n  branchIds: Set<string> | undefined,\n  own: Set<string | undefined>,\n): TraceWindow {\n  const inSpan = (index: number): boolean =>\n    spans.some((s) => index >= s.start && index < s.end);\n  const excluded = new Set<number>();\n  if (branchIds !== undefined) {\n    for (const event of trace.events) {\n      if (!inSpan(event.index)) continue;\n      if (event.branchId === undefined || !branchIds.has(event.branchId)) {\n        excluded.add(event.index);\n      }\n    }\n  }\n  const inWindow = (index: number): boolean =>\n    inSpan(index) && !excluded.has(index);\n\n  const events = trace.events.filter((e) => inWindow(e.index));\n  const textOf = (kind: TraceEvent[\"kind\"]): string[] =>\n    events\n      .filter((e) => e.kind === kind && own.has(e.branchId) && e.text)\n      .map((e) => e.text as string);\n  const userMessages = textOf(\"user\");\n\n  return {\n    scope,\n    label,\n    empty: false,\n    events,\n    toolCalls: trace.toolCalls.filter((c) => inWindow(c.index)),\n    fileAccesses: trace.fileAccesses.filter((a) => inWindow(a.index)),\n    skillInvocations: trace.skillInvocations.filter((s) => inWindow(s.index)),\n    userMessages,\n    assistantTexts: textOf(\"assistant\"),\n    turnCount: userMessages.length,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-D2LBN44V.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+import {
+  palette
+} from "./chunk-RNVYGWIC.js";
+
+// src/tracevals/rules/local.ts
+import {
+  ensureModel,
+  fits,
+  modelState,
+  nodeLlamaCppStatus
+} from "@hawkeyexl/inference";
+function libraryLocalModels(connections) {
+  const modelsDir = connections["llama-cpp"]?.modelsDir;
+  const options = modelsDir === void 0 ? {} : { modelsDirectory: modelsDir };
+  return {
+    runtimePresent: async () => (await nodeLlamaCppStatus()).state === "present",
+    state: (model) => modelState(model, options),
+    fits: (model) => fits(model, options),
+    ensure: (model) => ensureModel(model, options)
+  };
+}
+var GB = 1024 ** 3;
+
+// src/tracevals/reporters/conformance.ts
+var count = (n, one, many) => `${String(n)} ${n === 1 ? one : many}`;
+function renderCheck(report, opts = {}) {
+  const pc = palette(opts.color === true);
+  const lines = [];
+  for (const source of report.sources) {
+    const findings = report.findings.filter((f) => f.source === source.path);
+    if (findings.length === 0) continue;
+    lines.push(source.path);
+    for (const f of findings) {
+      const mark = f.outcome !== "fail" ? pc.yellow("?") : f.severity === "error" ? pc.red("\u2716") : pc.yellow("!");
+      lines.push(`  ${mark} ${f.rule}  ${f.text}`);
+      lines.push(`      ${pc.dim(`${f.observed} (${f.confidence.toFixed(2)})`)}`);
+    }
+  }
+  lines.push(...sessionSoFar(report));
+  for (const warning of report.warnings) lines.push(`${pc.yellow("!")} ${warning}`);
+  if (lines.length > 0) lines.push("");
+  lines.push(closing(report));
+  return lines.join("\n");
+}
+function sessionSoFar(report) {
+  const rules = report.session?.rules ?? [];
+  if (rules.length === 0) return [];
+  const flagged = rules.filter((r) => r.broken > 0 || r.needsReview > 0);
+  const lines = flagged.map((r) => {
+    const counts = [
+      ["broken", r.broken],
+      ["repaired", r.repaired],
+      ["needs review", r.needsReview],
+      ["followed", r.followed]
+    ];
+    const said = counts.filter(([, n]) => n > 0).map(([word, n]) => `${word} ${String(n)}`);
+    return `  ${r.source}#${r.rule}  ${said.join(", ")}`;
+  });
+  const held = rules.length - flagged.length;
+  if (held > 0) {
+    lines.push(`  ${count(held, "rule", "rules")} held every turn ${held === 1 ? "it" : "they"} applied to.`);
+  }
+  return ["Session so far", ...lines];
+}
+function closing(report) {
+  const head = `Last turn of ${report.sessionId.slice(0, 8)}:`;
+  const { summary } = report;
+  const scope = `${count(summary.rules, "rule", "rules")} from ${count(summary.sources, "source", "sources")}`;
+  switch (report.skipped) {
+    case "empty-turn":
+      return `${head} nothing happened after the last prompt.`;
+    case "no-sources":
+      return `${head} no rule sources governed it.`;
+    case "not-applicable":
+      return `${head} ${scope}, none apply to this turn.`;
+    case null: {
+      const broken = summary.fail > 0 ? `${String(summary.fail)} broken` : "None broken";
+      const review = summary.needsReview > 0 ? `, ${String(summary.needsReview)} needs review` : "";
+      const reported = summary.reported > 0 ? `, ${String(summary.reported)} reported` : "";
+      return `${head} ${scope}. ${broken}${review}${reported}.`;
+    }
+  }
+}
+var NOT_SET_UP = "tracevals conformance is not set up; nothing to prepare.";
+function renderPrepare(report) {
+  const lines = [];
+  const said = /* @__PURE__ */ new Set();
+  for (const m of report.models) {
+    if (m.state === "hosted" || said.has(m.model)) continue;
+    said.add(m.model);
+    const name = `${m.model} (${m.provider})`;
+    lines.push(
+      m.state === "downloaded" ? `${name} downloaded, ${((m.bytes ?? 0) / GB).toFixed(2)} GB.` : `${name} is ${m.state}.`
+    );
+  }
+  const ex = report.extraction;
+  if (ex !== null) {
+    const files = (n) => `${count(n, "file", "files")} that ${n === 1 ? "applies" : "apply"} to every session`;
+    if (ex.extracted > 0) {
+      lines.push(
+        `Extracted ${count(ex.rules, "rule", "rules")} from ${files(ex.extracted)}.` + (ex.cached > 0 ? ` ${String(ex.cached)} more ${ex.cached === 1 ? "was" : "were"} cached.` : "")
+      );
+    } else if (ex.cached > 0) {
+      lines.push(`${files(ex.cached)} ${ex.cached === 1 ? "is" : "are"} cached. Nothing to extract.`);
+    } else {
+      lines.push("No file applies to every session. Nothing to extract.");
+    }
+  }
+  for (const warning of report.warnings) lines.push(warning);
+  return lines.join("\n");
+}
+var NO_HOST = "No model host is running.";
+function renderRelease(report) {
+  if (!report.hostStopped && report.released.length === 0 && report.unloaded.length === 0) {
+    return NO_HOST;
+  }
+  const unloaded = report.unloaded.length > 0 ? `Unloaded ${report.unloaded.join(", ")}` : "";
+  const stopped = report.hostStopped ? "stopped the model host" : "";
+  const action = [unloaded, stopped].filter((s) => s !== "").join(" and ");
+  const held = count(report.released.length, "session", "sessions");
+  return `${action === "" ? "Released the lease" : action}. ${held} held it.`;
+}
+
+export {
+  libraryLocalModels,
+  GB,
+  renderCheck,
+  NOT_SET_UP,
+  renderPrepare,
+  NO_HOST,
+  renderRelease
+};
+//# sourceMappingURL=chunk-D2LBN44V.js.map

package/dist/chunk-D2LBN44V.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tracevals/rules/local.ts","../src/tracevals/reporters/conformance.ts"],"sourcesContent":["/**\n * What tracevals asks of a local model without loading it (proposal 0079,\n * gates 5, 8 and 9, and `prepare`). The inference library owns every answer;\n * this is the one seam, so a test can say \"downloading\" without a runtime.\n */\nimport {\n  ensureModel,\n  fits,\n  modelState,\n  nodeLlamaCppStatus,\n  type EnsureModelResult,\n  type FitsResult,\n  type LlamaModelState,\n} from \"@hawkeyexl/inference\";\nimport type { ProviderConnections } from \"../../shared/providers.js\";\n\nexport interface LocalModels {\n  /** Whether the llama.cpp binding is importable now, installing nothing. */\n  runtimePresent(): Promise<boolean>;\n  /** `ready`, `downloading` or `missing`, read without loading or fetching. */\n  state(model: string): Promise<LlamaModelState>;\n  /** The memory probe `auto` tiering uses. */\n  fits(model: string): Promise<FitsResult>;\n  /** Fetch the runtime and the weights, without loading either. */\n  ensure(model: string): Promise<EnsureModelResult>;\n}\n\n/** The library's lifecycle calls, pointed at the family's models directory. */\nexport function libraryLocalModels(connections: ProviderConnections): LocalModels {\n  const modelsDir = connections[\"llama-cpp\"]?.modelsDir;\n  const options = modelsDir === undefined ? {} : { modelsDirectory: modelsDir };\n  return {\n    runtimePresent: async () => (await nodeLlamaCppStatus()).state === \"present\",\n    state: (model) => modelState(model, options),\n    fits: (model) => fits(model, options),\n    ensure: (model) => ensureModel(model, options),\n  };\n}\n\n/** Bytes in a gigabyte as the messages count them. */\nexport const GB = 1024 ** 3;\n","/**\n * Pretty output for `check`, `prepare` and `release` (proposal 0079). JSON is\n * each report as it stands, so only prose lives here. Colour is the caller's\n * decision, made once by `colorFor`.\n */\nimport { palette } from \"../../shared/color.js\";\nimport type { CheckReport } from \"../commands/check.js\";\nimport type { PrepareReport } from \"../commands/prepare.js\";\nimport type { ReleaseReport } from \"../commands/release.js\";\nimport { GB } from \"../rules/local.js\";\n\nconst count = (n: number, one: string, many: string): string =>\n  `${String(n)} ${n === 1 ? one : many}`;\n\n/** Findings grouped under their source, then the closing line. */\nexport function renderCheck(report: CheckReport, opts: { color?: boolean } = {}): string {\n  const pc = palette(opts.color === true);\n  const lines: string[] = [];\n  for (const source of report.sources) {\n    const findings = report.findings.filter((f) => f.source === source.path);\n    if (findings.length === 0) continue;\n    lines.push(source.path);\n    for (const f of findings) {\n      const mark =\n        f.outcome !== \"fail\" ? pc.yellow(\"?\") : f.severity === \"error\" ? pc.red(\"✖\") : pc.yellow(\"!\");\n      lines.push(`  ${mark} ${f.rule}  ${f.text}`);\n      lines.push(`      ${pc.dim(`${f.observed} (${f.confidence.toFixed(2)})`)}`);\n    }\n  }\n  lines.push(...sessionSoFar(report));\n  for (const warning of report.warnings) lines.push(`${pc.yellow(\"!\")} ${warning}`);\n  if (lines.length > 0) lines.push(\"\");\n  lines.push(closing(report));\n  return lines.join(\"\\n\");\n}\n\n/** The ledger's rules that were ever broken or sent to review, and a count of the rest. */\nfunction sessionSoFar(report: CheckReport): string[] {\n  const rules = report.session?.rules ?? [];\n  if (rules.length === 0) return [];\n  const flagged = rules.filter((r) => r.broken > 0 || r.needsReview > 0);\n  const lines = flagged.map((r) => {\n    const counts = [\n      [\"broken\", r.broken],\n      [\"repaired\", r.repaired],\n      [\"needs review\", r.needsReview],\n      [\"followed\", r.followed],\n    ] as const;\n    const said = counts.filter(([, n]) => n > 0).map(([word, n]) => `${word} ${String(n)}`);\n    return `  ${r.source}#${r.rule}  ${said.join(\", \")}`;\n  });\n  const held = rules.length - flagged.length;\n  if (held > 0) {\n    lines.push(`  ${count(held, \"rule\", \"rules\")} held every turn ${held === 1 ? \"it\" : \"they\"} applied to.`);\n  }\n  return [\"Session so far\", ...lines];\n}\n\nfunction closing(report: CheckReport): string {\n  const head = `Last turn of ${report.sessionId.slice(0, 8)}:`;\n  const { summary } = report;\n  // \"sources\", because a typed prompt is not a file (proposal 0080).\n  const scope = `${count(summary.rules, \"rule\", \"rules\")} from ${count(summary.sources, \"source\", \"sources\")}`;\n  switch (report.skipped) {\n    case \"empty-turn\":\n      return `${head} nothing happened after the last prompt.`;\n    case \"no-sources\":\n      return `${head} no rule sources governed it.`;\n    case \"not-applicable\":\n      return `${head} ${scope}, none apply to this turn.`;\n    case null: {\n      const broken = summary.fail > 0 ? `${String(summary.fail)} broken` : \"None broken\";\n      const review = summary.needsReview > 0 ? `, ${String(summary.needsReview)} needs review` : \"\";\n      const reported = summary.reported > 0 ? `, ${String(summary.reported)} reported` : \"\";\n      return `${head} ${scope}. ${broken}${review}${reported}.`;\n    }\n  }\n}\n\nexport const NOT_SET_UP = \"tracevals conformance is not set up; nothing to prepare.\";\n\nexport function renderPrepare(report: PrepareReport): string {\n  const lines: string[] = [];\n  const said = new Set<string>();\n  for (const m of report.models) {\n    if (m.state === \"hosted\" || said.has(m.model)) continue;\n    said.add(m.model);\n    const name = `${m.model} (${m.provider})`;\n    lines.push(\n      m.state === \"downloaded\"\n        ? `${name} downloaded, ${((m.bytes ?? 0) / GB).toFixed(2)} GB.`\n        : `${name} is ${m.state}.`,\n    );\n  }\n  const ex = report.extraction;\n  if (ex !== null) {\n    const files = (n: number): string =>\n      `${count(n, \"file\", \"files\")} that ${n === 1 ? \"applies\" : \"apply\"} to every session`;\n    if (ex.extracted > 0) {\n      lines.push(\n        `Extracted ${count(ex.rules, \"rule\", \"rules\")} from ${files(ex.extracted)}.` +\n          (ex.cached > 0 ? ` ${String(ex.cached)} more ${ex.cached === 1 ? \"was\" : \"were\"} cached.` : \"\"),\n      );\n    } else if (ex.cached > 0) {\n      lines.push(`${files(ex.cached)} ${ex.cached === 1 ? \"is\" : \"are\"} cached. Nothing to extract.`);\n    } else {\n      lines.push(\"No file applies to every session. Nothing to extract.\");\n    }\n  }\n  for (const warning of report.warnings) lines.push(warning);\n  return lines.join(\"\\n\");\n}\n\nexport const NO_HOST = \"No model host is running.\";\n\nexport function renderRelease(report: ReleaseReport): string {\n  if (!report.hostStopped && report.released.length === 0 && report.unloaded.length === 0) {\n    return NO_HOST;\n  }\n  const unloaded = report.unloaded.length > 0 ? `Unloaded ${report.unloaded.join(\", \")}` : \"\";\n  const stopped = report.hostStopped ? \"stopped the model host\" : \"\";\n  const action = [unloaded, stopped].filter((s) => s !== \"\").join(\" and \");\n  const held = count(report.released.length, \"session\", \"sessions\");\n  return `${action === \"\" ? \"Released the lease\" : action}. ${held} held it.`;\n}\n"],"mappings":"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","names":[]}