harnery 0.32.0 → 0.34.0

package/src/lib/browser/tiling.ts

@@ -0,0 +1,164 @@
+// Content-aware band placement for the vision critique tiler.
+//
+// Fixed-height bands cut whatever sits at the boundary — half a heading, a
+// sliced table row, the middle of an image — and the critique rubric then has
+// to tell the model to ignore slice-edge clipping, which costs sensitivity on
+// every tile. This module snaps each cut into nearby content gaps instead:
+// the caller extracts "visual atoms" (text line boxes, replaced elements,
+// small bordered boxes) from the live page, and `snappedBandRects` places
+// each seam at the cheapest cut inside a bounded search window above the
+// fixed target. A clean seam (nothing straddles it) needs only a token
+// overlap; a dirty seam (unavoidable content, e.g. an element taller than
+// the band) keeps the caller's full overlap so the rubric mitigation still
+// applies there.
+//
+// Measured on a mixed fixture (prose, cards, 60-row table, an 1800px chart):
+// hard-atom slices per page dropped 9 → 1 on desktop and 4 → 2 on mobile at
+// an unchanged tile count, with every band height within [50%, 100%] of the
+// budget. The remaining slice was inside the over-tall chart, where no clean
+// cut exists — exactly the case the dirty-seam fallback covers.
+//
+// Pure math, no DOM access: atoms come in as plain rect spans so the module
+// stays testable and portable. Atom extraction lives on the browser client.
+
+export interface VisualAtom {
+  /** hard: cutting through it visibly breaks content. soft: looks untidy. */
+  kind: "text-line" | "replaced" | "box";
+  /** Document-space vertical span (CSS px scaled to image px by the caller). */
+  top: number;
+  bottom: number;
+}
+
+export interface SnapSeam {
+  /** Document-space y of the cut. */
+  y: number;
+  /** Weighted atoms the cut passes through; 0 = clean. */
+  cost: number;
+  /** Hard atoms (text lines, replaced elements) the cut passes through. */
+  hard: number;
+  clean: boolean;
+}
+
+export interface SnapOptions {
+  bandHeight: number;
+  /** Overlap applied below a dirty seam (the legacy constant, e.g. 120). */
+  overlap: number;
+  /** Overlap applied below a clean seam. Default 16. */
+  cleanOverlap?: number;
+  /** Fraction of bandHeight the seam may move up from its target. Default 0.3. */
+  slackRatio?: number;
+  /** Minimum band height as a fraction of bandHeight. Default 0.5. */
+  minBandRatio?: number;
+}
+
+const HARD_WEIGHT = 10;
+const SOFT_WEIGHT = 1;
+const EDGE_MARGIN = 4; // grazing an atom edge this closely counts as crossing
+const CANDIDATE_STEP = 2; // px between scored cut candidates
+
+/** Weighted cost of a horizontal cut at document-space y. */
+export function cutCost(atoms: VisualAtom[], y: number): { cost: number; hard: number } {
+  let cost = 0;
+  let hard = 0;
+  for (const a of atoms) {
+    if (y > a.top - EDGE_MARGIN && y < a.bottom + EDGE_MARGIN) {
+      if (a.kind === "box") {
+        cost += SOFT_WEIGHT;
+      } else {
+        cost += HARD_WEIGHT;
+        hard++;
+      }
+    }
+  }
+  return { cost, hard };
+}
+
+/**
+ * Cut the vertical span [top, bottom) into bands whose seams snap into
+ * content gaps. Seams only move UP from their fixed target (never down), so
+ * band height is bounded by `bandHeight` above and `minBandRatio` below.
+ * Returns full-width rects in the caller's coordinate space plus the seam
+ * record for logging/telemetry.
+ */
+export function snappedBandRects(
+  top: number,
+  bottom: number,
+  x: number,
+  width: number,
+  atoms: VisualAtom[],
+  opts: SnapOptions,
+): {
+  rects: Array<{ index: number; x: number; y: number; width: number; height: number }>;
+  seams: SnapSeam[];
+} {
+  const rects: Array<{ index: number; x: number; y: number; width: number; height: number }> = [];
+  const seams: SnapSeam[] = [];
+  const span = bottom - top;
+  if (span <= 0 || width <= 0) return { rects, seams };
+
+  const cleanOverlap = opts.cleanOverlap ?? 16;
+  const slack = Math.round(opts.bandHeight * (opts.slackRatio ?? 0.3));
+  const minBand = Math.round(opts.bandHeight * (opts.minBandRatio ?? 0.5));
+
+  let bandTop = top;
+  let index = 0;
+  while (bandTop + opts.bandHeight < bottom) {
+    const target = bandTop + opts.bandHeight;
+    const lo = Math.max(bandTop + minBand, target - slack);
+
+    // Score candidates, find the minimal cost in the window.
+    const costs: Array<{ y: number; cost: number; hard: number }> = [];
+    let minCost = Number.POSITIVE_INFINITY;
+    for (let y = lo; y <= target; y += CANDIDATE_STEP) {
+      const c = cutCost(atoms, y);
+      costs.push({ y, ...c });
+      if (c.cost < minCost) minCost = c.cost;
+    }
+
+    // Snap to the center of the widest minimal-cost run; ties resolve toward
+    // the target (later run wins on >=) so bands stay as tall as possible.
+    let runStart = -1;
+    let best = { start: 0, end: costs.length - 1, len: 0 };
+    for (let i = 0; i <= costs.length; i++) {
+      const inRun = i < costs.length && costs[i].cost === minCost;
+      if (inRun && runStart === -1) runStart = i;
+      if (!inRun && runStart !== -1) {
+        const len = i - runStart;
+        if (len >= best.len) best = { start: runStart, end: i - 1, len };
+        runStart = -1;
+      }
+    }
+    const pick = costs[Math.floor((best.start + best.end) / 2)];
+    const clean = pick.cost === 0;
+    seams.push({ y: pick.y, cost: pick.cost, hard: pick.hard, clean });
+    rects.push({ index, x, y: bandTop, width, height: pick.y - bandTop });
+    index++;
+    bandTop = pick.y - (clean ? cleanOverlap : opts.overlap);
+  }
+  rects.push({ index, x, y: bandTop, width, height: bottom - bandTop });
+  return { rects, seams };
+}
+
+/**
+ * Split one element rect into internally-banded sub-rects when it is taller
+ * than the band budget. Selector-mode tiles previously shipped over-tall
+ * elements as one giant tile that the vision provider downscales; banding
+ * inside the element keeps every sub-tile at full resolution. Elements within
+ * 1.25x of the budget stay whole — a slightly-over tile beats a degenerate
+ * split.
+ */
+export function bandOversizedRect(
+  rect: { label: string; x: number; y: number; width: number; height: number },
+  atoms: VisualAtom[],
+  opts: SnapOptions,
+): Array<{ label: string; x: number; y: number; width: number; height: number }> {
+  if (rect.height <= opts.bandHeight * 1.25) return [rect];
+  const { rects } = snappedBandRects(rect.y, rect.y + rect.height, rect.x, rect.width, atoms, opts);
+  return rects.map((r, i) => ({
+    label: `${rect.label} (${i + 1}/${rects.length})`,
+    x: r.x,
+    y: r.y,
+    width: r.width,
+    height: r.height,
+  }));
+}

package/src/lib/context/index.ts

@@ -1,11 +1,10 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { monorepoRoot, resolveOwner } from "../../core/agents/index.ts";
 import {
-  type Heartbeat,
-  monorepoRoot,
-  readHeartbeat,
-  resolveOwner,
-} from "../../core/agents/index.ts";
+  readLiveCoordinationRow,
+  readLiveCoordinationRows,
+} from "../../core/agents/state/live-coordination-view.ts";
 import { exec } from "../exec.ts";
 import { NO_DATA } from "../format.ts";
 
@@ -78,8 +77,6 @@ export interface SelfSection {
   instance_id: string;
   session_age_secs: number;
   task: string | null;
-  last_tool: string | null;
-  last_tool_target: string | null;
   files_held: string[];
 }
 
@@ -113,7 +110,6 @@ export interface PeersSection {
     instance_id_short: string;
     age_min: number;
     files: number;
-    last_tool: string | null;
     task: string | null;
   }[];
 }
@@ -155,19 +151,14 @@ export async function buildContext(opts: ContextOptions = {}): Promise<ContextRe
 function buildSelf(): SelfSection {
   const owner = resolveOwner();
   if (!owner) throw new Error("not in an agent session (no pid-map entry)");
-  const hb = readHeartbeat(owner);
-  // Full id, never abbreviated: this message exists to hand the reader an id to
-  // pass back (to `agents heal --owner`, say), and an 8-char prefix is not that
-  // id. Healing the truncated form writes `.harnery/active/<prefix>.json`, a
-  // heartbeat no reader ever resolves — so the session still looks unhealable
-  // and now has a junk file shadowing it. Same rule as `noHeartbeatMessage` in
-  // the agents command.
+  const root = monorepoRoot();
+  const hb = root ? readLiveCoordinationRow(root, owner) : null;
+  // Full id, never abbreviated: command surfaces pass this identity back to
+  // the authority-safe V3 coordination projection.
   if (!hb) {
-    throw new Error(
-      `pid-map resolved owner=${owner} but no heartbeat exists at .harnery/active/${owner}.json`,
-    );
+    throw new Error(`pid-map resolved owner=${owner} but no live V3 generation exists for it`);
   }
-  const startedMs = Date.parse(hb.started_at);
+  const startedMs = Date.parse(hb.started_at ?? "");
   const ageSecs = Number.isFinite(startedMs)
     ? Math.max(0, Math.floor((Date.now() - startedMs) / 1000))
     : 0;
@@ -176,8 +167,6 @@ function buildSelf(): SelfSection {
     instance_id: hb.instance_id,
     session_age_secs: ageSecs,
     task: hb.task ?? null,
-    last_tool: hb.last_tool ?? null,
-    last_tool_target: hb.last_tool_target ?? null,
     files_held: hb.files_touched ?? [],
   };
 }
@@ -296,32 +285,19 @@ async function statusFor(name: string, cwd: string): Promise<SubmoduleStatus> {
 function buildPeers(): PeersSection {
   const root = monorepoRoot();
   if (!root) throw new Error("coord_root() returned null");
-  const activeDir = resolve(root, ".harnery", "active");
-  if (!existsSync(activeDir)) return { rows: [] };
   const myOwner = resolveOwner();
-  // No freshness filter; matches the SessionStart/UserPromptSubmit snapshot.
-  // Stale entries get swept by the SessionStart janitor on the next session start.
   const rows: PeersSection["rows"] = [];
-  for (const f of readdirSync(activeDir)) {
-    if (!f.endsWith(".json")) continue;
-    try {
-      const hb = JSON.parse(readFileSync(resolve(activeDir, f), "utf8")) as Heartbeat;
-      if (!hb || typeof hb.instance_id !== "string") continue;
-      if (hb.instance_id === myOwner) continue;
-      if ((hb.kind ?? "") === "transient") continue;
-      const startedMs = Date.parse(hb.started_at);
-      const ageMin = Number.isFinite(startedMs) ? Math.floor((Date.now() - startedMs) / 60000) : 0;
-      rows.push({
-        name: hb.name ?? "unknown",
-        instance_id_short: hb.instance_id.slice(0, 8),
-        age_min: ageMin,
-        files: hb.files_touched?.length ?? 0,
-        last_tool: hb.last_tool ?? null,
-        task: hb.task ?? null,
-      });
-    } catch {
-      // skip
-    }
+  for (const row of readLiveCoordinationRows(root)) {
+    if (row.instance_id === myOwner || row.kind === "transient") continue;
+    const startedMs = Date.parse(row.started_at ?? row.last_heartbeat);
+    const ageMin = Number.isFinite(startedMs) ? Math.floor((Date.now() - startedMs) / 60000) : 0;
+    rows.push({
+      name: row.name ?? "unknown",
+      instance_id_short: row.instance_id.slice(0, 8),
+      age_min: ageMin,
+      files: row.files_touched.length,
+      task: row.task ?? null,
+    });
   }
   // Sort: file-holders first (more activity), then by recency (younger age first).
   rows.sort((a, b) => b.files - a.files || a.age_min - b.age_min);

package/src/lib/council/index.ts

@@ -19,6 +19,7 @@ import {
 import { basename, resolve } from "node:path";
 
 import { monorepoRoot } from "../../core/agents/index.ts";
+import { readLiveCoordinationRows } from "../../core/agents/state/live-coordination-view.ts";
 import { resolveBinName } from "../../core/config.ts";
 import { ensureIdentity, lookupById as lookupIdentityById } from "../identities/index.js";
 
@@ -241,7 +242,7 @@ export function setCouncilSteward(councilId: string, steward: string | null): Co
 export interface KnownAgent {
   /** `agent-<Name>` canonical handle. */
   name: string;
-  /** `active` = currently has a heartbeat in `.harnery/active/`. `stale` =
+  /** `active` = currently has an authority-eligible V3 generation. `stale` =
    * recently ended (journal archived within the lookback window). */
   state: "active" | "stale";
   /** ISO timestamp of the most-recent signal. */
@@ -253,35 +254,22 @@ export interface KnownAgent {
 const KNOWN_AGENT_STALE_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
 
 /**
- * Active heartbeats + recently-archived journals, deduped by name.
+ * Active V3 generations + recently-archived journals, deduped by name.
  * Used by `agents council set-steward` to refuse arbitrary names;
  * pass `--allow-unknown` to bypass when bootstrapping a new agent.
  */
 export function listKnownAgents(): KnownAgent[] {
   const root = monorepoRoot();
   if (!root) return [];
-  const activeDir = resolve(root, ".harnery", "active");
   const archiveDir = resolve(root, ".harnery", "journal", "archived");
   const byName = new Map<string, KnownAgent>();
 
-  if (existsSync(activeDir)) {
-    for (const f of readdirSync(activeDir)) {
-      if (!f.endsWith(".json")) continue;
-      try {
-        const hb = JSON.parse(readFileSync(resolve(activeDir, f), "utf8")) as {
-          name?: string;
-          last_heartbeat?: string;
-        };
-        if (!hb.name) continue;
-        const name = hb.name.startsWith("agent-") ? hb.name : `agent-${hb.name}`;
-        const last_seen = hb.last_heartbeat ?? new Date().toISOString();
-        const existing = byName.get(name);
-        if (existing?.state !== "active") {
-          byName.set(name, { name, state: "active", last_seen });
-        }
-      } catch {
-        /* skip unreadable */
-      }
+  for (const row of readLiveCoordinationRows(root)) {
+    if (!row.name) continue;
+    const name = row.name.startsWith("agent-") ? row.name : `agent-${row.name}`;
+    const existing = byName.get(name);
+    if (existing?.state !== "active") {
+      byName.set(name, { name, state: "active", last_seen: row.last_heartbeat });
     }
   }
 

package/src/lib/docs-frontmatter.ts

@@ -45,85 +45,12 @@ export function parseFrontmatter(text: string): ParsedFrontmatter {
   return { data, body: text.slice(m[0].length), raw: m[1]! };
 }
 
-/**
- * Kind-independent token normalization (spacing / casing / punctuation
- * variants). Kind-specific collapses (done -> shipped vs resolved) are applied
- * in `normalizeStatus`.
- */
-const GENERIC_NORMALIZE: Record<string, string> = {
-  in_progress: "in-progress",
-  inprogress: "in-progress",
-  "in progress": "in-progress",
-  "in-progress": "in-progress",
-  wip: "in-progress",
-  "wont-fix": "wontfix",
-  wontfix: "wontfix",
-  proposed: "proposed",
-  abandoned: "abandoned",
-  open: "open",
-  resolved: "resolved",
-  shipped: "shipped",
-};
-
-// "done"-family tokens collapse to different canonical values per kind.
-const DONE_FAMILY = new Set(["done", "complete", "completed", "finished"]);
-const KIND_NORMALIZE: Record<DocKind, Record<string, string>> = {
-  plan: {
-    planning: "proposed",
-    draft: "proposed",
-    approved: "proposed",
-    plan: "proposed",
-    open: "proposed",
-    deferred: "proposed",
-    implemented: "shipped",
-    resolved: "shipped",
-    fixed: "shipped",
-    archived: "shipped",
-    shelved: "abandoned",
-  },
-  issue: {
-    "in progress": "open",
-    in_progress: "open",
-    "in-progress": "open",
-    blocked: "open",
-    mitigated: "open",
-    fixed: "resolved",
-    shipped: "resolved",
-  },
-  handoff: {
-    "in progress": "open",
-    in_progress: "open",
-    "in-progress": "open",
-    blocked: "open",
-    fixed: "resolved",
-    shipped: "resolved",
-  },
-};
 const ALLOWED_BY_KIND: Record<DocKind, ReadonlySet<string>> = {
   plan: new Set(["proposed", "in-progress", "shipped", "abandoned"]),
   issue: new Set(["open", "resolved", "wontfix"]),
   handoff: new Set(["open", "resolved", "abandoned"]),
 };
-const ALL_CANONICAL = new Set(Object.values(ALLOWED_BY_KIND).flatMap((values) => [...values]));
-
-/**
- * Normalize a raw status token to the canonical enum for its kind.
- * Returns null when the token can't be mapped (caller may fail loud).
- */
-export function normalizeStatus(raw: string, kind?: DocKind): string | null {
-  const t = raw.trim().toLowerCase();
-  if (!t) return null;
-  if (DONE_FAMILY.has(t)) {
-    // plans ship; issues/handoffs resolve. Default to "shipped" when unknown.
-    return kind === "issue" || kind === "handoff" ? "resolved" : "shipped";
-  }
-  const normalized = (kind ? KIND_NORMALIZE[kind][t] : undefined) ?? GENERIC_NORMALIZE[t];
-  if (!normalized) return null;
-  const allowed = kind ? ALLOWED_BY_KIND[kind] : ALL_CANONICAL;
-  return allowed.has(normalized) ? normalized : null;
-}
-
-/** Read and normalize a doc's YAML lifecycle status, or null when absent/invalid. */
+/** Read a canonical v2 lifecycle status, or null when absent or invalid. */
 export function readDocStatus(filePath: string, kind?: DocKind): string | null {
   let content: string;
   try {
@@ -137,11 +64,13 @@ export function readDocStatus(filePath: string, kind?: DocKind): string | null {
 /** Same as {@link readDocStatus} but from an in-memory string (testable). */
 export function readDocStatusFromText(content: string, kind?: DocKind): string | null {
   const { data } = parseFrontmatter(content);
-  const yamlStatus = data.status;
-  if (typeof yamlStatus === "string" && yamlStatus.trim()) {
-    return normalizeStatus(yamlStatus, kind);
-  }
-  return null;
+  if (data.schema !== "harnery-doc/v2") return null;
+  if (kind && data.type !== kind) return null;
+  if (typeof data.status !== "string") return null;
+  if (kind) return ALLOWED_BY_KIND[kind].has(data.status) ? data.status : null;
+  return Object.values(ALLOWED_BY_KIND).some((allowed) => allowed.has(data.status as string))
+    ? data.status
+    : null;
 }
 
 /** Whether a doc carries a non-empty status in leading YAML frontmatter. */

package/src/lib/docs-index.ts

@@ -30,6 +30,10 @@ import { readDocStatusFromText } from "./docs-frontmatter.ts";
  * Idempotent: safe to run on every commit. Reads the first ~30 lines of
  * each dated file to extract title and (for issues) status.
  *
+ * Targets: the host root, every initialized git submodule, and first-level
+ * in-tree packages that keep `docs/audits` or `docs/issues` without being
+ * git submodules. Marker rules are unchanged.
+ *
  * Preserves hand-written preambles. The command updates only the section
  * between `<!-- BEGIN INDEX -->` and `<!-- END INDEX -->` markers. If a
  * README exists without markers, the command refuses to overwrite it and
@@ -165,12 +169,38 @@ function buildNewReadme(kind: "audits" | "issues", body: string): string {
   return `${defaultPreamble(kind)}\n${BEGIN_MARKER}\n${body}${END_MARKER}\n`;
 }
 
-export async function runIndex(opts: IndexOpts): Promise<IndexResult[]> {
-  const targets: { name: string; path: string }[] = [{ name: "(root)", path: REPO_ROOT }];
+const SKIP_NESTED_DIR_NAMES = new Set(["node_modules", "dist", "target"]);
+
+function hasIndexableDocs(path: string): boolean {
+  return existsSync(join(path, "docs", "audits")) || existsSync(join(path, "docs", "issues"));
+}
+
+/** Root + initialized submodules + first-level in-tree packages with docs indexes. */
+export function collectIndexTargets(): { name: string; path: string }[] {
+  const byPath = new Map<string, { name: string; path: string }>();
+  const add = (name: string, path: string) => {
+    byPath.set(path, { name, path });
+  };
+  add("(root)", REPO_ROOT);
   for (const name of SUBMODULES) {
     if (!isSubmoduleInitialized(name)) continue;
-    targets.push({ name, path: submodulePath(name) });
+    add(name, submodulePath(name));
   }
+  if (!existsSync(REPO_ROOT)) return [...byPath.values()];
+  for (const ent of readdirSync(REPO_ROOT, { withFileTypes: true })) {
+    if (!ent.isDirectory() && !ent.isSymbolicLink()) continue;
+    if (ent.name.startsWith(".")) continue;
+    if (SKIP_NESTED_DIR_NAMES.has(ent.name)) continue;
+    if (isSubmoduleInitialized(ent.name)) continue;
+    const child = join(REPO_ROOT, ent.name);
+    if (!hasIndexableDocs(child)) continue;
+    add(ent.name, child);
+  }
+  return [...byPath.values()];
+}
+
+export async function runIndex(opts: IndexOpts): Promise<IndexResult[]> {
+  const targets = collectIndexTargets();
 
   const filter = opts.repo === "." ? "(root)" : opts.repo;
   const filtered = filter ? targets.filter((t) => t.name === filter) : targets;

package/src/lib/docs-lint.ts

@@ -1,6 +1,7 @@
 import { existsSync as __existsSyncForDocs } from "node:fs";
 import { resolve as __resolveForDocs } from "node:path";
 import { hasYamlStatus } from "./docs-frontmatter.ts";
+import { initDocsMetadataAuditContext, runDocsMetadataAudit } from "./docs-metadata-audit.ts";
 import { sh } from "./exec.ts";
 
 // Module-level docs context, initialized by initDocsContext() before any
@@ -22,6 +23,7 @@ export function initDocsContext(opts: {
   SUBMODULES = opts.submodules;
   EXTRA_EXCLUDED_PREFIXES = opts.extraExcludedPrefixes ?? [];
   DOCS_ROOT_ALLOWLIST = opts.docsRootAllowlist ?? [];
+  initDocsMetadataAuditContext({ repoRoot: opts.repoRoot, submodules: opts.submodules });
 }
 
 function submodulePath(name: string): string {
@@ -380,34 +382,6 @@ function checkChangelogNames(repoName: string, _repoPath: string, files: string[
   return violations;
 }
 
-/** Plans, issues, and handoffs must carry YAML lifecycle status (content check, slow). */
-function checkStatusHeaders(repoName: string, repoPath: string, files: string[]): Violation[] {
-  const violations: Violation[] = [];
-  const targetDirs = ["docs/plans/", "docs/issues/", "docs/handoffs/"];
-  for (const rel of files) {
-    const dirMatch = targetDirs.some((d) => rel.startsWith(d));
-    if (!dirMatch) continue;
-    const name = basename(rel);
-    if (name === "README.md") continue;
-    const full = join(repoPath, rel);
-    if (!hasStatusHeader(full)) {
-      const kind = rel.startsWith("docs/plans/")
-        ? "plan"
-        : rel.startsWith("docs/issues/")
-          ? "issue"
-          : "handoff";
-      violations.push({
-        severity: "error",
-        repo: repoName,
-        path: join(repoName === "(root)" ? "" : repoName, rel),
-        rule: "missing-status-header",
-        message: `${kind} missing status in leading YAML frontmatter`,
-      });
-    }
-  }
-  return violations;
-}
-
 /** Intentional monoliths >30KB need a declaration banner */
 function checkMonolithDeclaration(
   repoName: string,
@@ -462,10 +436,22 @@ export async function runLint(opts: LintOpts): Promise<Violation[]> {
     violations.push(...checkChangelogNames(name, path, files));
 
     if (!opts.fast) {
-      violations.push(...checkStatusHeaders(name, path, files));
       violations.push(...checkMonolithDeclaration(name, path, files));
     }
   }
 
+  const metadataRows = await runDocsMetadataAudit({ repo: opts.repo });
+  for (const row of metadataRows) {
+    for (const issue of row.issues.filter((entry) => entry.severity === "error")) {
+      violations.push({
+        severity: "error",
+        repo: row.repo,
+        path: row.path,
+        rule: `metadata-v2:${issue.code}`,
+        message: issue.field ? `${issue.field}: ${issue.message}` : issue.message,
+      });
+    }
+  }
+
   return violations;
 }