@hawkeyexl/manni 4.3.1 → 4.4.1

package/dist/chunk-I2AH3CJJ.js

@@ -0,0 +1,1192 @@
+#!/usr/bin/env node
+import {
+  discoverArtifacts
+} from "./chunk-QQUKGCAJ.js";
+import {
+  METADATA_KEY,
+  assertProviderSelection,
+  constructProvider,
+  graderFor,
+  keepNewerThan,
+  loadExternalEvals,
+  loadGraderPlugins,
+  parseNewerThan,
+  resolveProviderIdentity,
+  selectProvider,
+  urlManifestRefusal
+} from "./chunk-FBEQCK47.js";
+import {
+  discoverConfig
+} from "./chunk-NXV7WE2D.js";
+import {
+  discoverTraces
+} from "./chunk-4TSWU2SU.js";
+import {
+  TracevalsError
+} from "./chunk-UKZNLVJW.js";
+import {
+  TURN_BUDGET_SKIP
+} from "./chunk-LJ2RDH3F.js";
+import {
+  SEVERITIES
+} from "./chunk-77AINBYM.js";
+import {
+  externalWriteWarnings,
+  mergeMetaProvenance,
+  offerExternalHomes
+} from "./chunk-A5ULMVHQ.js";
+import {
+  keyHome,
+  marksValidator,
+  metaSection,
+  readManifestOrEmpty,
+  readManifestValue,
+  spliceManifestValue
+} from "./chunk-M3W7J6MU.js";
+import {
+  DocmetaError,
+  extractFrontmatter,
+  writeFileAtomic
+} from "./chunk-57NEQRVO.js";
+import {
+  palette
+} from "./chunk-RNVYGWIC.js";
+import {
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+
+// src/tracevals/commands/list.ts
+async function runList(options = {}) {
+  if (options.newerThan !== void 0) parseNewerThan(options.newerThan);
+  const { newerThan, ...discover } = options;
+  return { traces: keepNewerThan(await discoverTraces(discover), newerThan) };
+}
+function renderList(run, opts = {}) {
+  const pc = palette(opts.color === true);
+  const dim = pc.dim;
+  const bold = pc.bold;
+  if (run.traces.length === 0) {
+    return "No traces found. Pass --all-projects to scan every project, or --project <dir> to scope to one.";
+  }
+  const lines = [];
+  run.traces.forEach((t, i) => {
+    const when = new Date(t.mtimeMs).toISOString().slice(0, 16).replace("T", " ");
+    const size = `${Math.max(1, Math.round(t.sizeBytes / 1024))}KB`;
+    lines.push(
+      `${bold(String(i + 1).padStart(3))}. ${dim(when)}  ${t.firstPrompt ?? dim("(no prompt)")}`
+    );
+    lines.push(
+      `      ${dim(`${t.project ?? "unknown project"} \xB7 ${t.sessionId ?? "?"} \xB7 ${size}`)}`
+    );
+    lines.push(`      ${dim(t.file)}`);
+  });
+  return lines.join("\n");
+}
+
+// src/tracevals/commands/fill.ts
+import { writeFile } from "node:fs/promises";
+import { relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/tracevals/evals/write.ts
+import {
+  Document,
+  isMap,
+  isNode,
+  isScalar,
+  isSeq,
+  parseDocument
+} from "yaml";
+var BOM = "\uFEFF";
+function leadingFormat(content) {
+  const body = content.startsWith(BOM) ? content.slice(1) : content;
+  if (/^---\r?\n/.test(body)) return "yaml";
+  if (/^\+\+\+\r?\n/.test(body)) return "toml";
+  if (/^;;;\r?\n/.test(body)) return "json";
+  return void 0;
+}
+function splitYamlFrontmatter(content, path) {
+  const bom = content.startsWith(BOM) ? BOM : "";
+  const body = bom ? content.slice(1) : content;
+  const openMatch = /^---(\r?\n)/.exec(body);
+  if (!openMatch) {
+    throw new TracevalsError(`${path}: no YAML frontmatter block to edit`);
+  }
+  const eol = openMatch[1] === "\r\n" ? "\r\n" : "\n";
+  const [fence = body, ...rest] = body.split(/(?<=\n)/);
+  let offset = fence.length;
+  for (const line of rest) {
+    const stripped = line.replace(/\r?\n$/, "");
+    if (stripped === "---" || stripped === "...") {
+      return {
+        open: bom + fence,
+        block: body.slice(fence.length, offset),
+        suffix: body.slice(offset),
+        eol
+      };
+    }
+    offset += line.length;
+  }
+  throw new TracevalsError(`${path}: unterminated frontmatter block`);
+}
+function entryObject(entry) {
+  const obj = { id: entry.id };
+  if (entry.assertion !== void 0) obj.assertion = entry.assertion;
+  if (entry.type !== void 0) obj.type = entry.type;
+  if (entry.grader !== void 0) obj.grader = entry.grader;
+  if (entry.options !== void 0) obj.options = entry.options;
+  if (entry.severity !== void 0) obj.severity = entry.severity;
+  if (entry.evidence !== void 0) obj.evidence = entry.evidence;
+  if (entry.examples !== void 0) obj.examples = entry.examples;
+  return obj;
+}
+function existingIds(seq) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const item of seq.items) {
+    if (isMap(item)) {
+      const id = item.get("id");
+      if (typeof id === "string") ids.add(id);
+    }
+  }
+  return ids;
+}
+function isEmptyNode(node) {
+  return node === void 0 || node === null || isNullScalar(node);
+}
+function isNullScalar(node) {
+  return isScalar(node) && node.value === null;
+}
+function evalsSeq(doc, path) {
+  const existing = doc.getIn(["metadata", "evals"], true);
+  if (!isEmptyNode(existing)) {
+    if (isScalar(existing) && typeof existing.value === "string") {
+      throw new TracevalsError(
+        `${path}: metadata.evals is a single assertion string; expand it to a list before appending`
+      );
+    }
+    if (!isSeq(existing)) {
+      throw new TracevalsError(`${path}: metadata.evals is not a list`);
+    }
+    return existing;
+  }
+  const node = doc.getIn(["metadata"], true);
+  if (isEmptyNode(node)) {
+    doc.setIn(["metadata"], doc.createNode({}));
+  } else if (!isMap(node)) {
+    throw new TracevalsError(`${path}: metadata is not a mapping`);
+  }
+  const seq = doc.createNode([]);
+  doc.setIn(["metadata", "evals"], seq);
+  return seq;
+}
+var META_PROVENANCE_KEY = "meta-provenance";
+function mergeProvenance(doc, provenance, ids) {
+  if (ids.length === 0) return;
+  const node = doc.getIn(["metadata", META_PROVENANCE_KEY], true);
+  const held = isEmptyNode(node) ? void 0 : isNode(node) ? node.toJSON() : node;
+  const merged = mergeMetaProvenance(
+    held,
+    provenance.generatedBy,
+    "evals",
+    ids.map((id) => ({ name: id, confidence: provenance.confidence[id] ?? 0 }))
+  );
+  if (!merged) {
+    throw new TracevalsError(`metadata.${META_PROVENANCE_KEY} is not a list`);
+  }
+  doc.setIn(
+    ["metadata", META_PROVENANCE_KEY],
+    doc.createNode(merged.list)
+  );
+}
+function appendMetadataEvals(held, label, entries, provenance) {
+  const block = held === void 0 || held === null ? {} : typeof held === "object" && !Array.isArray(held) ? { ...held } : (() => {
+    throw new TracevalsError(`${label}: metadata is not a mapping`);
+  })();
+  const existing = block.evals;
+  if (typeof existing === "string") {
+    throw new TracevalsError(
+      `${label}: metadata.evals is a single assertion string; expand it to a list before appending`
+    );
+  }
+  if (existing !== void 0 && existing !== null && !Array.isArray(existing)) {
+    throw new TracevalsError(`${label}: metadata.evals is not a list`);
+  }
+  const list = Array.isArray(existing) ? [...existing] : [];
+  const taken = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+      const id = item.id;
+      if (typeof id === "string") taken.add(id);
+    }
+  }
+  for (const entry of entries) {
+    if (taken.has(entry.id)) {
+      throw new TracevalsError(
+        `${label}: eval "${entry.id}" already exists in ${METADATA_KEY}`
+      );
+    }
+    taken.add(entry.id);
+    list.push(entryObject(entry));
+  }
+  block.evals = list;
+  if (provenance !== void 0 && entries.length > 0) {
+    const merged = mergeMetaProvenance(
+      block[META_PROVENANCE_KEY],
+      provenance.generatedBy,
+      "evals",
+      entries.map((e) => ({
+        name: e.id,
+        confidence: provenance.confidence[e.id] ?? 0
+      }))
+    );
+    if (!merged) {
+      throw new TracevalsError(`${label}: metadata.${META_PROVENANCE_KEY} is not a list`);
+    }
+    block[META_PROVENANCE_KEY] = merged.list;
+  }
+  return block;
+}
+function appendArtifactEvals(content, path, entries, provenance) {
+  if (entries.length === 0) return content;
+  const format = leadingFormat(content);
+  if (format === "toml" || format === "json") {
+    throw new TracevalsError(
+      `${path}: only YAML frontmatter can be edited (found ${format} frontmatter)`
+    );
+  }
+  const bom = content.startsWith(BOM) ? BOM : "";
+  const stripped = bom ? content.slice(1) : content;
+  if (format === void 0) {
+    const eol2 = stripped.includes("\r\n") ? "\r\n" : "\n";
+    const doc2 = new Document({
+      metadata: { evals: entries.map(entryObject) }
+    });
+    if (provenance) {
+      mergeProvenance(
+        doc2,
+        provenance,
+        entries.map((e) => e.id)
+      );
+    }
+    let block2 = doc2.toString({ lineWidth: 0 });
+    if (eol2 === "\r\n") block2 = block2.replace(/(?<!\r)\n/g, "\r\n");
+    return `${bom}---${eol2}${block2}---${eol2}${stripped}`;
+  }
+  const { open, block, suffix, eol } = splitYamlFrontmatter(content, path);
+  const doc = parseDocument(block);
+  if (doc.errors.length > 0) {
+    throw new TracevalsError(
+      `${path}: cannot edit frontmatter \u2014 ${doc.errors[0]?.message ?? "parse error"}`
+    );
+  }
+  let seq;
+  try {
+    seq = evalsSeq(doc, path);
+  } catch (err) {
+    if (err instanceof TracevalsError) throw err;
+    throw new TracevalsError(
+      `${path}: cannot edit frontmatter \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const taken = existingIds(seq);
+  for (const entry of entries) {
+    if (taken.has(entry.id)) {
+      throw new TracevalsError(
+        `${path}: eval "${entry.id}" already exists in frontmatter`
+      );
+    }
+    taken.add(entry.id);
+    seq.add(doc.createNode(entryObject(entry)));
+  }
+  if (provenance) {
+    try {
+      mergeProvenance(
+        doc,
+        provenance,
+        entries.map((e) => e.id)
+      );
+    } catch (err) {
+      if (err instanceof TracevalsError) {
+        throw new TracevalsError(`${path}: ${err.message}`);
+      }
+      throw err;
+    }
+  }
+  let updated = doc.toString({ lineWidth: 0 });
+  if (eol === "\r\n") updated = updated.replace(/(?<!\r)\n/g, "\r\n");
+  return open + updated + suffix;
+}
+
+// src/tracevals/evals/write-location.ts
+import { relative, resolve } from "node:path";
+function noEntryRefusal(label, join, file) {
+  return `${label}: ${METADATA_KEY} is owned by ${file}, which joins on "${join}", and this artifact carries no ${join}.`;
+}
+var MetadataWriter = class _MetadataWriter {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  static async for(opts) {
+    const { configDir, configPath } = opts;
+    const config = configPath === void 0 ? null : await metaConfig(configPath, configDir);
+    return new _MetadataWriter({
+      // Artifact labels are absolute, and a manifest is reported relative to
+      // the config directory, the way `external.ts` reports one it read.
+      cwd: configDir,
+      base: configDir,
+      noConfig: configPath === void 0,
+      config,
+      ...configPath === void 0 ? {} : { configDir, configPath },
+      collections: opts.collections,
+      declaredCollections: opts.collections,
+      targets: opts.targets.map((t) => relative(configDir, resolve(opts.cwd, t)) || "."),
+      validator: marksValidator({ config, cwd: configDir, configDir })()
+    });
+  }
+  /** Where the `metadata` block of the artifact `label` goes. `data` is its own front matter. */
+  async homeFor(label, data) {
+    const home = await keyHome(this.ctx, label, data, METADATA_KEY);
+    if (home.kind === "url") return { kind: "url", file: home.file };
+    if (home.kind === "manifest") {
+      if (home.entry === void 0) {
+        return { kind: "no-entry", file: home.file, join: home.join };
+      }
+      return {
+        kind: "manifest",
+        file: home.file,
+        absPath: home.absPath,
+        join: home.join,
+        entry: home.entry,
+        perPage: home.perPage
+      };
+    }
+    return { kind: "page", proposed: home.home };
+  }
+  /**
+   * Ask P1 once per collection the flagged writes would be homed in. Returns
+   * true when a relocation was applied, which leaves the caller's config,
+   * artifacts and this writer stale: rebuild all three before writing.
+   */
+  async offer(writes, hooks) {
+    if (writes.length === 0) return false;
+    const applied = await offerExternalHomes(this.ctx, writes, hooks);
+    return applied.size > 0;
+  }
+  /**
+   * Replace this artifact's `metadata` block in its manifest entry with what
+   * `update` makes of the block the file holds now. The file is read just
+   * before the write, so a block another run wrote meanwhile is extended
+   * rather than lost, and no other byte of the file changes.
+   */
+  async write(home, update) {
+    let text;
+    try {
+      text = await readManifestOrEmpty(home.absPath, home.perPage);
+    } catch (e) {
+      throw new TracevalsError(`${home.file} could not be read: ${errorMessage(e)}`);
+    }
+    const at = { entry: home.entry, key: METADATA_KEY, join: home.join };
+    let spliced;
+    try {
+      spliced = spliceManifestValue(text, {
+        ...at,
+        value: update(readManifestValue(text, at)),
+        file: home.file
+      }).text;
+    } catch (e) {
+      throw new TracevalsError(errorMessage(e));
+    }
+    if (spliced !== text) {
+      await writeFileAtomic(home.absPath, spliced, { createParents: true });
+    }
+  }
+};
+async function metaConfig(configPath, configDir) {
+  try {
+    return await metaSection(configPath, configDir);
+  } catch (err) {
+    if (err instanceof DocmetaError) return null;
+    throw err;
+  }
+}
+
+// src/tracevals/fill/cache.ts
+import { JsonCache, buildCacheKey, sha256 } from "@hawkeyexl/inference";
+
+// src/tracevals/fill/prompt.ts
+import { Ajv2020 } from "ajv/dist/2020.js";
+
+// src/tracevals/fill/gate.ts
+var ALLOWED_GRADERS = {
+  skill: ["ai", "tool-usage", "file-access", "regex"],
+  "slash-command": ["ai", "tool-usage", "file-access", "regex"],
+  agent: ["ai", "tool-usage", "file-access"],
+  "project-rules": ["ai", "skill-invoked", "tool-usage"]
+};
+function isAbsoluteish(path) {
+  return path.startsWith("/") || /^[A-Za-z]:[\\/]/.test(path);
+}
+function groundingError(proposal, vocabulary) {
+  const options = proposal.options ?? {};
+  if (proposal.grader === "tool-usage") {
+    const tool = options.tool;
+    if (typeof tool === "string" && !tool.startsWith("mcp__") && !vocabulary.tools.has(tool)) {
+      return `no tool named "${tool}" is available in this project`;
+    }
+  }
+  if (proposal.grader === "skill-invoked") {
+    const skill = options.skill;
+    if (typeof skill === "string" && !vocabulary.skills.has(skill)) {
+      return `no skill named "${skill}" was found in this project`;
+    }
+  }
+  if (proposal.grader === "file-access") {
+    const path = options.path;
+    if (typeof path === "string" && isAbsoluteish(path)) {
+      return `options.path must be a repository-relative suffix, not "${path}"`;
+    }
+  }
+  return void 0;
+}
+function normalize(proposal, artifactType) {
+  if (artifactType !== "agent" || proposal.grader !== "tool-usage") {
+    return proposal;
+  }
+  return {
+    ...proposal,
+    options: { ...proposal.options ?? {}, includeSidechains: true }
+  };
+}
+function gateProposals(proposals, options) {
+  const { artifactType, threshold, maxEvals, vocabulary } = options;
+  const allowed = new Set(ALLOWED_GRADERS[artifactType]);
+  const taken = new Set(options.existingNames);
+  const rejected = [];
+  const survivors = [];
+  for (const raw of proposals) {
+    if (taken.has(raw.name)) {
+      rejected.push({ proposal: raw, reason: "duplicate-name" });
+      continue;
+    }
+    if (!allowed.has(raw.grader)) {
+      rejected.push({
+        proposal: raw,
+        reason: "grader-not-allowed",
+        detail: `${raw.grader} may not be declared on a ${artifactType} artifact`
+      });
+      continue;
+    }
+    const proposal = normalize(raw, artifactType);
+    if (proposal.grader !== "ai") {
+      const grader = graderFor(proposal.grader);
+      const validate = grader?.validateOptions;
+      if (validate === void 0) {
+        rejected.push({
+          proposal,
+          reason: "invalid-options",
+          detail: `grader ${proposal.grader} cannot validate its options`
+        });
+        continue;
+      }
+      const invalid = validate(proposal.options ?? {});
+      if (invalid !== void 0) {
+        rejected.push({ proposal, reason: "invalid-options", detail: invalid });
+        continue;
+      }
+      const ungrounded = groundingError(proposal, vocabulary);
+      if (ungrounded !== void 0) {
+        rejected.push({
+          proposal,
+          reason: "ungrounded-target",
+          detail: ungrounded
+        });
+        continue;
+      }
+    }
+    taken.add(proposal.name);
+    survivors.push(proposal);
+  }
+  const confident = [];
+  for (const proposal of survivors) {
+    if (proposal.confidence >= threshold) confident.push(proposal);
+    else rejected.push({ proposal, reason: "low-confidence" });
+  }
+  confident.sort((a, b) => b.confidence - a.confidence);
+  return {
+    accepted: confident.slice(0, maxEvals),
+    capped: confident.slice(maxEvals),
+    rejected
+  };
+}
+
+// src/tracevals/fill/prompt.ts
+var FILL_PROMPT_VERSION = 4;
+var MAX_BODY_CHARS = 6e3;
+var TYPE_GUIDANCE = {
+  skill: [
+    "This artifact is a skill: a procedure an agent follows on demand.",
+    "Its testable claims are entry criteria (what must be true before starting),",
+    "process steps (what must actually happen), and output specifications (what",
+    "the result must contain or must never contain)."
+  ].join("\n"),
+  "slash-command": [
+    "This artifact is a slash command: a procedure whose body is injected as a",
+    "prompt when a person types its name. Its testable claims are the steps it",
+    "mandates, the tools it permits or forbids, and the artifact it must leave",
+    "behind. Its `argument-hint` and `description` are harness metadata, not",
+    "assertions \u2014 do not test them."
+  ].join("\n"),
+  agent: [
+    "This artifact is an agent definition: a role with boundaries.",
+    "Its testable claims are constraints (what the agent must never do),",
+    "quality criteria (measurable standards its output must meet), and",
+    "escalation rules (conditions under which it must stop and hand off).",
+    "Its identity and persona are framing, not assertions \u2014 do not test them."
+  ].join("\n"),
+  "project-rules": [
+    "This artifact is a project rules file: standing rules for all work in the",
+    "repository. Its testable claims are process gates, quality gates, approval",
+    "requirements, and hard limits. These files are assertion-dense; prefer the",
+    "rules stated plainly over anything you would have to infer."
+  ].join("\n")
+};
+var GRADER_GUIDANCE = {
+  ai: "judgment a human would have to read the session to make",
+  "tool-usage": "a named tool was or was not used (options: tool, expect, min, max)",
+  "skill-invoked": "a named skill was or was not invoked (options: skill, expect)",
+  "file-access": "a file was or was not read/written/edited (options: path, op, expect)",
+  regex: "a pattern does or does not appear in session text (options: pattern, flags, on, expect)"
+};
+function systemPromptFor(artifactType) {
+  const allowed = ALLOWED_GRADERS[artifactType];
+  return [
+    "You extract evals from an AI agent instruction artifact.",
+    "",
+    TYPE_GUIDANCE[artifactType],
+    "",
+    "An eval is a durable claim about how a session behaved, graded against",
+    "a recorded session trace on every future run. You are extracting claims the",
+    "artifact already makes \u2014 not inventing new policy for it.",
+    "",
+    "Rules for every eval you propose:",
+    "- It must be decidable as a binary pass or fail against session evidence.",
+    "  If you cannot say precisely what would make it fail, it does not qualify.",
+    "- Quote the artifact's own intent. Never assert incidental phrasing,",
+    "  formatting, or wording that is expected to change.",
+    "- Prefer a deterministic grader whenever the claim can be checked",
+    "  mechanically; fall back to `ai` only for genuine judgment.",
+    "- Ids are short kebab-case identifiers, unique within the artifact.",
+    "- Provide examples.pass and examples.fail: one sentence each describing a",
+    "  session that satisfies or violates the eval.",
+    "- Report an honest confidence between 0 and 1 that the criterion is",
+    "  correct, checkable, and worth guarding. Do not inflate it.",
+    "- Do not restate evals the artifact already declares.",
+    "- Propose at most the requested number, fewer when the artifact offers",
+    "  little worth guarding, and none at all when nothing qualifies.",
+    "",
+    "Graders available for this artifact type:",
+    ...allowed.map((kind) => `- ${kind}: ${GRADER_GUIDANCE[kind] ?? ""}`),
+    "",
+    "Deterministic graders only work against targets that really exist. Use tool",
+    "and skill names exactly as given below; if the name you want is not listed,",
+    "use the `ai` grader instead of guessing.",
+    "",
+    "Finally, list under `needsSharpening` any instruction in the artifact that",
+    "sounds like a requirement but cannot be tested as written \u2014 an undefined",
+    "quality bar, an unmeasurable adjective, a rule with no observable outcome.",
+    "Say what makes it untestable. Do not invent a criterion to cover it."
+  ].join("\n");
+}
+var PROPOSAL_SCHEMA = {
+  type: "object",
+  required: ["evals"],
+  additionalProperties: false,
+  properties: {
+    evals: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["name", "assertion", "grader", "examples", "confidence"],
+        additionalProperties: false,
+        properties: {
+          name: { type: "string", pattern: "^[a-z0-9][a-z0-9-]*$" },
+          assertion: { type: "string", minLength: 1 },
+          grader: { type: "string" },
+          options: { type: "object" },
+          evidence: { type: "string" },
+          examples: {
+            type: "object",
+            required: ["pass", "fail"],
+            additionalProperties: false,
+            properties: {
+              pass: { type: "string" },
+              fail: { type: "string" }
+            }
+          },
+          severity: { enum: [...SEVERITIES] },
+          confidence: { type: "number", minimum: 0, maximum: 1 },
+          rationale: { type: "string" }
+        }
+      }
+    },
+    needsSharpening: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["instruction", "reason"],
+        additionalProperties: false,
+        properties: {
+          instruction: { type: "string" },
+          reason: { type: "string" },
+          suggestion: { type: "string" }
+        }
+      }
+    }
+  }
+};
+var ajv = new Ajv2020({ allErrors: true });
+var validateProposal = ajv.compile(
+  PROPOSAL_SCHEMA
+);
+function isValidProposal(value) {
+  return validateProposal(value);
+}
+function buildFillUser(options) {
+  const { artifact, existingNames, maxEvals, facts, knownSkills } = options;
+  const body = artifact.content.length > MAX_BODY_CHARS ? `${artifact.content.slice(0, MAX_BODY_CHARS)}
+\u2026(truncated)` : artifact.content;
+  const lines = [
+    "# Artifact",
+    `path: ${artifact.path}`,
+    `type: ${artifact.type}`,
+    `name: ${facts.name ?? artifact.name}`
+  ];
+  if (facts.description !== void 0) {
+    lines.push(`description: ${facts.description}`);
+  }
+  lines.push(
+    "",
+    "# Existing evals (do not restate these)",
+    existingNames.length > 0 ? existingNames.join(", ") : "(none)",
+    "",
+    "# Tools this artifact grants itself",
+    facts.declaredTools.length > 0 ? facts.declaredTools.join(", ") : "(none declared)",
+    "",
+    "# Skills that exist in this project",
+    knownSkills.length > 0 ? knownSkills.join(", ") : "(none)",
+    "",
+    "# Maximum evals to propose",
+    String(maxEvals),
+    "",
+    "# Artifact content",
+    "",
+    body
+  );
+  return lines.join("\n");
+}
+
+// src/tracevals/fill/cache.ts
+function listPart(values) {
+  return JSON.stringify([...values].sort());
+}
+function fillCacheKey(parts) {
+  return buildCacheKey([
+    parts.provider,
+    parts.model,
+    `fill-v${FILL_PROMPT_VERSION}`,
+    `t${parts.temperature}`,
+    `n${parts.maxEvals}`,
+    parts.artifactType,
+    parts.path,
+    sha256(parts.body),
+    listPart(parts.existingNames),
+    listPart(parts.knownSkills)
+  ]);
+}
+var FillCache = class {
+  store;
+  constructor(dir, enabled = true) {
+    this.store = new JsonCache(dir, enabled, "manni-tracevals");
+  }
+  get(key) {
+    const proposal = this.store.get(key);
+    if (!isValidProposal(proposal)) return void 0;
+    return proposal;
+  }
+  set(key, proposal) {
+    this.store.set(key, proposal);
+  }
+};
+
+// src/tracevals/fill/facts.ts
+function toolList(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => typeof v === "string");
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((tool) => tool.trim()).filter((tool) => tool.length > 0);
+  }
+  return [];
+}
+function artifactFacts(artifact) {
+  try {
+    const { data } = extractFrontmatter(artifact.content, "markdown");
+    const facts = { declaredTools: toolList(data.tools) };
+    if (typeof data.name === "string") facts.name = data.name;
+    if (typeof data.description === "string") {
+      facts.description = data.description;
+    }
+    return facts;
+  } catch {
+    return { declaredTools: [] };
+  }
+}
+
+// src/tracevals/fill/mock.ts
+function mockFillProposal() {
+  return {
+    json: {
+      evals: [
+        {
+          name: "reads-before-editing",
+          assertion: "The session read a source file before editing it.",
+          grader: "tool-usage",
+          options: { tool: "Read", expect: "used" },
+          examples: {
+            pass: "Read is called before the first Edit",
+            fail: "Edit is called with no prior Read"
+          },
+          confidence: 0.9
+        },
+        {
+          name: "explains-its-reasoning",
+          assertion: "The session explained why it made each change.",
+          grader: "ai",
+          examples: {
+            pass: "Each edit is accompanied by a rationale",
+            fail: "Edits land with no explanation"
+          },
+          confidence: 0.3
+        }
+      ],
+      needsSharpening: [
+        {
+          instruction: "Produce high-quality work.",
+          reason: '"high-quality" has no measurable bar, so no session could fail it',
+          suggestion: "Name the specific property that must hold, and how to observe it."
+        }
+      ]
+    }
+  };
+}
+
+// src/tracevals/fill/vocabulary.ts
+var BUILTIN_TOOLS = [
+  "Agent",
+  "AskUserQuestion",
+  "Bash",
+  "BashOutput",
+  "Edit",
+  "ExitPlanMode",
+  "Glob",
+  "Grep",
+  "KillShell",
+  "NotebookEdit",
+  "Read",
+  "Skill",
+  "SlashCommand",
+  "Task",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch",
+  "Write"
+];
+function buildVocabulary(artifacts) {
+  const tools = new Set(BUILTIN_TOOLS);
+  const skills = /* @__PURE__ */ new Set();
+  for (const discovered of artifacts) {
+    if (discovered.artifact.type === "skill") {
+      skills.add(discovered.artifact.name);
+    }
+    for (const tool of artifactFacts(discovered.artifact).declaredTools) {
+      tools.add(tool);
+    }
+  }
+  return { tools, skills };
+}
+
+// src/tracevals/commands/fill.ts
+function ownData(content) {
+  return extractFrontmatter(content, "markdown").data;
+}
+function toEvalEntry(proposed) {
+  const entry = {
+    id: proposed.name,
+    assertion: proposed.assertion,
+    // New evals start as regression: they describe behavior the artifact
+    // already asks for, not a boundary being probed.
+    type: "regression",
+    grader: proposed.grader,
+    // The vocabulary takes one anchor or a list; the model proposes one of each.
+    examples: { pass: [proposed.examples.pass], fail: [proposed.examples.fail] }
+  };
+  if (proposed.options !== void 0) entry.options = proposed.options;
+  if (proposed.evidence !== void 0) entry.evidence = proposed.evidence;
+  if (proposed.severity !== void 0) entry.severity = proposed.severity;
+  return entry;
+}
+async function runFill(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const root = resolve2(options.project ?? cwd);
+  const lookup = {
+    ...options.config === void 0 ? {} : { configPath: options.config },
+    ...options.noConfig === void 0 ? {} : { noConfig: options.noConfig }
+  };
+  const {
+    config: loaded,
+    dir: configDir,
+    path: configPath
+  } = await discoverConfig(options.configDir ?? cwd, lookup);
+  const config = {
+    ...loaded,
+    plugins: [...loaded.plugins, ...options.require ?? []]
+  };
+  const plugins = await loadGraderPlugins({
+    plugins: config.plugins,
+    configDir
+  });
+  const flags = {
+    ...options.provider !== void 0 ? { provider: options.provider } : {},
+    ...options.model !== void 0 ? { model: options.model } : {},
+    ...options.local !== void 0 ? { local: options.local } : {}
+  };
+  assertProviderSelection(selectProvider(config, flags));
+  const threshold = options.confidence ?? config.fill.confidenceThreshold;
+  const maxEvals = options.maxEvals ?? config.fill.maxEvalsPerArtifact;
+  const temperature = config.fill.temperature;
+  const maxTurns = options.maxTurns ?? config.fill.maxTurns;
+  const cache = new FillCache(
+    resolve2(configDir, config.fill.cacheDir),
+    options.noCache !== true
+  );
+  const load = async () => {
+    const { collections: collections2 } = await discoverConfig(options.configDir ?? cwd, lookup);
+    const external = await loadExternalEvals({
+      collections: collections2,
+      configDir,
+      ...configPath === void 0 ? {} : { configPath },
+      ...options.offline === void 0 ? {} : { offline: options.offline }
+    });
+    const discovery2 = await discoverArtifacts({
+      root,
+      cwd,
+      ...options.paths !== void 0 ? { paths: options.paths } : {},
+      ...options.exclude !== void 0 ? { exclude: options.exclude } : {},
+      ...external === null ? {} : {
+        metadataFor: async (artifact) => (await external.forArtifact(artifact)).extracted
+      }
+    });
+    const writer2 = await MetadataWriter.for({
+      collections: collections2,
+      configDir,
+      configPath,
+      cwd,
+      targets: options.paths ?? []
+    });
+    return { collections: collections2, discovery: discovery2, writer: writer2 };
+  };
+  let { collections, discovery, writer } = await load();
+  if (options.confirm !== void 0 && options.dryRun !== true && collections.length > 0) {
+    const flagged = [];
+    for (const { artifact, status, skip } of discovery.artifacts) {
+      if (status !== "ok" || skip || artifact.type === "project-rules") continue;
+      const home = await writer.homeFor(artifact.path, ownData(artifact.content));
+      if (home.kind === "page") {
+        flagged.push({ label: artifact.path, key: METADATA_KEY, home: home.proposed });
+      }
+    }
+    const applied = await writer.offer(flagged, {
+      confirm: options.confirm,
+      ...options.onNotice === void 0 ? {} : { onNotice: options.onNotice },
+      ...options.onRelocated === void 0 ? {} : { onRelocated: options.onRelocated }
+    });
+    if (applied) ({ collections, discovery, writer } = await load());
+  }
+  const vocabulary = buildVocabulary(discovery.artifacts);
+  const knownSkills = [...vocabulary.skills].sort();
+  const injected = options.providerInstance;
+  let resolving;
+  const resolveOnce = () => resolving ??= resolveProviderIdentity(config, flags);
+  const getIdentity = async () => injected !== void 0 ? { provider: injected.provider(), model: injected.modelName() } : resolveOnce();
+  let provider = injected;
+  const getProvider = async () => provider ??= constructProvider(config, await resolveOnce(), {
+    // The default mock response is judge-shaped and would fail this
+    // command's schema, so seed the mock seam with a proposal instead.
+    mockResponses: [mockFillProposal()]
+  });
+  let turns = 0;
+  const results = [];
+  const homeless = [];
+  for (const discovered of discovery.artifacts) {
+    results.push(await fillOne(discovered));
+  }
+  const report = {
+    results,
+    threshold,
+    dryRun: options.dryRun === true,
+    warnings: [
+      ...plugins.warnings,
+      ...discovery.warnings,
+      ...externalWriteWarnings(homeless, options.dryRun === true)
+    ],
+    exitCode: results.some((r) => r.status === "error") ? 1 : 0
+  };
+  return {
+    report,
+    rendered: renderFill(report, {
+      cwd,
+      ...options.color === void 0 ? {} : { color: options.color }
+    })
+  };
+  async function fillOne(discovered) {
+    const { artifact } = discovered;
+    const base = {
+      artifact: artifact.path,
+      type: artifact.type,
+      status: "nothing-proposed",
+      written: [],
+      rejected: [],
+      capped: [],
+      needsSharpening: [],
+      cached: false
+    };
+    if (discovered.status !== "ok") {
+      return {
+        ...base,
+        status: discovered.status === "unreadable" ? "unreadable" : "error",
+        ...discovered.error !== void 0 ? { error: discovered.error } : {}
+      };
+    }
+    if (discovered.skip) return { ...base, status: "skipped" };
+    const facts = artifactFacts(artifact);
+    const identity = await getIdentity();
+    const key = fillCacheKey({
+      provider: identity.provider,
+      model: identity.model,
+      temperature,
+      maxEvals,
+      artifactType: artifact.type,
+      path: artifact.path,
+      body: artifact.content,
+      existingNames: discovered.existingNames,
+      knownSkills
+    });
+    let raw = cache.get(key);
+    const cached = raw !== void 0;
+    if (raw === void 0) {
+      if (maxTurns !== null && turns >= maxTurns) {
+        return { ...base, status: "skipped", error: `${TURN_BUDGET_SKIP} exhausted` };
+      }
+      turns += 1;
+      try {
+        const response = await (await getProvider()).completeJSON({
+          system: systemPromptFor(artifact.type),
+          user: buildFillUser({
+            artifact,
+            existingNames: discovered.existingNames,
+            maxEvals,
+            facts,
+            knownSkills
+          }),
+          schema: PROPOSAL_SCHEMA,
+          temperature
+        });
+        if (!isValidProposal(response.json)) {
+          return {
+            ...base,
+            status: "error",
+            error: "provider returned a proposal that does not match the schema"
+          };
+        }
+        raw = response.json;
+        cache.set(key, raw);
+      } catch (err) {
+        if (err instanceof TracevalsError) throw err;
+        return {
+          ...base,
+          status: "error",
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+    const gated = gateProposals(raw.evals, {
+      artifactType: artifact.type,
+      threshold,
+      existingNames: discovered.existingNames,
+      // The cap is a ceiling on the artifact's total, not on one run's
+      // additions, so repeated fills cannot grow it without bound.
+      maxEvals: Math.max(0, maxEvals - discovered.existingNames.length),
+      vocabulary
+    });
+    const result = {
+      ...base,
+      written: gated.accepted,
+      rejected: gated.rejected,
+      capped: gated.capped,
+      needsSharpening: raw.needsSharpening ?? [],
+      cached
+    };
+    if (gated.accepted.length === 0) return result;
+    if (artifact.type === "project-rules") {
+      return { ...result, status: "propose-only" };
+    }
+    const home = await writer.homeFor(artifact.path, ownData(artifact.content));
+    if (options.dryRun !== true) {
+      if (home.kind === "url") {
+        throw new TracevalsError(urlManifestRefusal(artifact.path, home.file));
+      }
+      if (home.kind === "no-entry") {
+        throw new TracevalsError(noEntryRefusal(artifact.path, home.join, home.file));
+      }
+    }
+    const landed = home.kind === "page" ? result : { ...result, manifest: home.file };
+    if (options.dryRun === true) return { ...landed, status: "proposed" };
+    const provenance = {
+      generatedBy: identity.model || identity.provider,
+      confidence: Object.fromEntries(
+        gated.accepted.map((c) => [c.name, c.confidence])
+      )
+    };
+    try {
+      if (home.kind === "manifest") {
+        await writer.write(
+          home,
+          (current) => appendMetadataEvals(
+            current,
+            artifact.path,
+            gated.accepted.map(toEvalEntry),
+            provenance
+          )
+        );
+      } else {
+        const updated = appendArtifactEvals(
+          artifact.content,
+          artifact.path,
+          gated.accepted.map(toEvalEntry),
+          provenance
+        );
+        await writeFile(artifact.path, updated);
+        if (home.kind === "page") noteHomeless(artifact.path, home);
+      }
+    } catch (err) {
+      return {
+        ...landed,
+        status: "error",
+        written: [],
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    return { ...landed, status: "filled" };
+  }
+  function noteHomeless(label, home) {
+    if (collections.length === 0) return;
+    homeless.push({ label, key: METADATA_KEY, home: home.proposed });
+  }
+}
+var STATUS_LABEL = {
+  filled: "filled",
+  proposed: "proposed",
+  "propose-only": "proposed",
+  "nothing-proposed": "no-op",
+  skipped: "skipped",
+  unreadable: "skipped",
+  error: "error"
+};
+function names(entries) {
+  return entries.map((c) => `${c.name} ${c.confidence.toFixed(2)}`).join(", ");
+}
+function renderFill(report, opts = {}) {
+  const pc = palette(opts.color === true);
+  const from = opts.cwd ?? process.cwd();
+  const show = (path) => {
+    const rel = relative2(from, path);
+    return rel === "" || rel.startsWith("..") ? path : rel;
+  };
+  const { green, cyan, dim, red } = pc;
+  const lines = [];
+  for (const result of report.results) {
+    const label = STATUS_LABEL[result.status].padEnd(9);
+    const tag = result.cached ? dim(" [cached]") : "";
+    const where = result.manifest === void 0 ? "" : dim(` in ${result.manifest}`);
+    switch (result.status) {
+      case "filled":
+        lines.push(`${green(label)} ${show(result.artifact)}  +${result.written.length} (${names(result.written)})${where}${tag}`);
+        break;
+      case "proposed":
+        lines.push(`${cyan(label)} ${show(result.artifact)}  +${result.written.length} (${names(result.written)})${where}${tag} \u2014 dry run, not written`);
+        break;
+      case "propose-only":
+        lines.push(`${cyan(label)} ${show(result.artifact)}  +${result.written.length} (${names(result.written)})${tag} \u2014 project rules are never written; copy what you want`);
+        break;
+      case "nothing-proposed":
+        lines.push(`${dim(label)} ${show(result.artifact)}  (nothing new proposed)${tag}`);
+        break;
+      case "skipped":
+        lines.push(`${dim(label)} ${show(result.artifact)}  (${result.error ?? "metadata.evals.skip"})`);
+        break;
+      case "unreadable":
+        lines.push(`${dim(label)} ${show(result.artifact)}  (${result.error ?? "unreadable frontmatter"})`);
+        break;
+      case "error":
+        lines.push(`${red(label)} ${show(result.artifact)}: ${result.error ?? "unknown error"}`);
+        break;
+    }
+    const belowThreshold = result.rejected.filter((r) => r.reason === "low-confidence");
+    if (belowThreshold.length > 0) {
+      lines.push(dim(`          below ${report.threshold}: ${names(belowThreshold.map((r) => r.proposal))}`));
+    }
+    for (const rejection of result.rejected) {
+      if (rejection.reason === "low-confidence") continue;
+      lines.push(dim(`          ${rejection.reason}: ${rejection.proposal.name}${rejection.detail ? ` \u2014 ${rejection.detail}` : ""}`));
+    }
+    if (result.capped.length > 0) {
+      lines.push(dim(`          over per-artifact cap: ${names(result.capped)}`));
+    }
+    for (const note of result.needsSharpening) {
+      lines.push(dim(`          needs sharpening: "${note.instruction}" \u2014 ${note.reason}`));
+    }
+  }
+  if (report.results.length === 0) {
+    lines.push("No skills, agent definitions, or project rules found.");
+  }
+  for (const warning of report.warnings) lines.push(dim(`warning: ${warning}`));
+  lines.push("");
+  const total = report.results.reduce((n, r) => n + r.written.length, 0);
+  lines.push(
+    report.dryRun ? `Threshold ${report.threshold} \xB7 ${total} evals proposed, none written (dry run)` : `Threshold ${report.threshold} \xB7 ${total} evals written`
+  );
+  return lines.join("\n");
+}
+
+export {
+  runList,
+  renderList,
+  appendArtifactEvals,
+  ALLOWED_GRADERS,
+  gateProposals,
+  FILL_PROMPT_VERSION,
+  MAX_BODY_CHARS,
+  systemPromptFor,
+  PROPOSAL_SCHEMA,
+  isValidProposal,
+  buildFillUser,
+  fillCacheKey,
+  FillCache,
+  artifactFacts,
+  mockFillProposal,
+  BUILTIN_TOOLS,
+  buildVocabulary,
+  runFill,
+  renderFill
+};
+//# sourceMappingURL=chunk-I2AH3CJJ.js.map