@moda-ai/cli 1.55.54 → 1.55.55

package/dist/{cli-6hdqp65a.js → cli-rtkjjf0a.js}

@@ -9,19 +9,1196 @@ import {
 import { createHash } from "node:crypto";
 import {
   existsSync,
-  lstatSync,
+  lstatSync as lstatSync2,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync3,
   writeFileSync
 } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { basename, dirname, join as join3, relative as relative3, resolve } from "node:path";
+
+// src/harness-component-status.ts
+import { closeSync, openSync, readdirSync as readdirSync2, readFileSync as readFileSync2, readSync } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join2, posix as posix2, relative as relative2 } from "node:path";
+
+// src/harness-wrangler-bindings.ts
+import { lstatSync, readdirSync, readFileSync } from "node:fs";
+import { isAbsolute, join, posix, relative } from "node:path";
+var WRANGLER_FILE = /^wrangler(\.[\w-]+)?\.jsonc?$/;
+var ANY_WRANGLER_FILE = /^wrangler(?:\.[\w-]+)?\.(?:jsonc?|toml)$/;
+var SKIPPED_DIRS = new Set(["node_modules", ".git", ".wrangler", "dist", "build", ".next", ".turbo", "vendor"]);
+var MAX_DEPTH = 4;
+var AGENT_CLASS = /Agent(?:V\d+)?$/;
+var TEST_SEGMENT = /^(?:test|tests|__tests__|test-fixtures|fixtures?|__fixtures__|e2e|mocks?)$/i;
+var TEST_TOKEN = /(?:^|[._-])(?:test|tests|spec|e2e|fixtures?|mocks?)(?:$|[._-])/i;
+function isTestWorkerConfig(input) {
+  const segments = input.path.split("/");
+  const file = segments[segments.length - 1] ?? "";
+  const variant = file.replace(/^wrangler\.?/, "").replace(/\.(?:jsonc?|toml)$/, "");
+  if (segments.slice(0, -1).some((segment) => TEST_SEGMENT.test(segment)))
+    return true;
+  if (variant && TEST_TOKEN.test(variant))
+    return true;
+  if (typeof input.name === "string" && TEST_TOKEN.test(input.name))
+    return true;
+  return (input.mains ?? []).some((main) => typeof main === "string" && main.split("/").slice(0, -1).some((segment) => TEST_SEGMENT.test(segment)));
+}
+function stripJsonc(text) {
+  let out = "";
+  let inString = false;
+  for (let i = 0;i < text.length; i += 1) {
+    const ch = text[i];
+    if (inString) {
+      out += ch;
+      if (ch === "\\") {
+        out += text[i + 1] ?? "";
+        i += 1;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+    } else if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== `
+`)
+        i += 1;
+      out += `
+`;
+    } else if (ch === "/" && text[i + 1] === "*") {
+      i += 2;
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) {
+        if (text[i] === `
+`)
+          out += `
+`;
+        i += 1;
+      }
+      i += 1;
+    } else {
+      out += ch;
+    }
+  }
+  return out.replace(/,(\s*[}\]])/g, "$1");
+}
+function findWranglerFiles(rootDir, pattern = WRANGLER_FILE) {
+  const found = [];
+  const walk = (dir, depth) => {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      const abs = join(dir, name);
+      let stat;
+      try {
+        stat = lstatSync(abs);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (depth < MAX_DEPTH && !SKIPPED_DIRS.has(name) && !name.startsWith("."))
+          walk(abs, depth + 1);
+      } else if (stat.isFile() && pattern.test(name)) {
+        found.push(abs);
+      }
+    }
+  };
+  walk(rootDir, 0);
+  return found.sort();
+}
+function lineOf(text, className) {
+  const index = text.search(new RegExp(`"class_name"\\s*:\\s*"${className.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"`));
+  return index < 0 ? undefined : text.slice(0, index).split(`
+`).length;
+}
+function workerDir(path) {
+  const slash = path.lastIndexOf("/");
+  return slash < 0 ? "" : path.slice(0, slash);
+}
+function detectBoundRuntimeClasses(rootDir) {
+  const byClass = new Map;
+  for (const abs of findWranglerFiles(rootDir)) {
+    let text;
+    let config;
+    try {
+      text = readFileSync(abs, "utf8");
+      config = JSON.parse(stripJsonc(text));
+    } catch {
+      continue;
+    }
+    if (!config || typeof config !== "object")
+      continue;
+    const path = relative(rootDir, abs).split("\\").join("/");
+    const root = config;
+    if (isTestWorkerConfig({ path, name: root.name, mains: [root.main] }))
+      continue;
+    const sections = [root, ...Object.values(root.env ?? {})];
+    for (const section of sections) {
+      if (!section || typeof section !== "object")
+        continue;
+      const s = section;
+      const durable = s.durable_objects?.bindings;
+      const entries = [
+        ...Array.isArray(durable) ? durable.map((b) => ["durable_object", b]) : [],
+        ...Array.isArray(s.workflows) ? s.workflows.map((w) => ["workflow", w]) : []
+      ];
+      for (const [kind, raw] of entries) {
+        if (!raw || typeof raw !== "object")
+          continue;
+        const entry = raw;
+        const className = typeof entry.class_name === "string" ? entry.class_name : "";
+        const scriptName = typeof entry.script_name === "string" && entry.script_name ? entry.script_name : undefined;
+        const key = `${className}|${scriptName ? "external" : `config:${path}`}`;
+        if (!className || byClass.has(key))
+          continue;
+        const binding = typeof (kind === "workflow" ? entry.binding : entry.name) === "string" ? String(kind === "workflow" ? entry.binding : entry.name) : className;
+        byClass.set(key, {
+          className,
+          kind,
+          binding,
+          ...scriptName ? { scriptName } : {},
+          path,
+          line: lineOf(text, className)
+        });
+      }
+    }
+  }
+  return [...byClass.values()];
+}
+var RUNTIME_BASES = {
+  DurableObject: "durable_object",
+  WorkflowEntrypoint: "workflow",
+  AgentWorkflow: "workflow",
+  Agent: "agent",
+  AIChatAgent: "agent",
+  Think: "agent",
+  McpAgent: "agent"
+};
+var SOURCE_FILE = /\.tsx?$/;
+var SKIPPED_SOURCE_FILE = /\.(?:test|spec)\.tsx?$|\.d\.ts$/;
+var TEST_DIR = /^(?:tests?|__tests__|__mocks__|e2e|(?:.*[-_.])?fixtures?|__fixtures__)$/i;
+var MAX_SOURCE_DEPTH = 12;
+var MAX_SOURCE_FILES = 20000;
+var MAX_SOURCE_BYTES = 1e6;
+var CLASS_DECLARATION = /^[ \t]*(export[ \t]+(?:default[ \t]+)?)?(abstract[ \t]+)?class[ \t]+([A-Za-z_$][\w$]*)(?:[ \t]*<[^\n{]*?>)?[ \t]+extends[ \t]+([A-Za-z_$][\w$]*)/gm;
+function findSourceFiles(rootDir) {
+  const found = [];
+  const walk = (dir, depth) => {
+    let entries;
+    try {
+      entries = readdirSync(dir).sort();
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (found.length >= MAX_SOURCE_FILES)
+        return;
+      const abs = join(dir, name);
+      let stat;
+      try {
+        stat = lstatSync(abs);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (depth < MAX_SOURCE_DEPTH && !SKIPPED_DIRS.has(name) && !name.startsWith(".") && !TEST_DIR.test(name))
+          walk(abs, depth + 1);
+      } else if (stat.isFile() && SOURCE_FILE.test(name) && !SKIPPED_SOURCE_FILE.test(name) && stat.size <= MAX_SOURCE_BYTES) {
+        found.push(abs);
+      }
+    }
+  };
+  walk(rootDir, 0);
+  return found;
+}
+function bindingsOfSection(section) {
+  const durable = section.durable_objects?.bindings;
+  const raw = [...Array.isArray(durable) ? durable : [], ...Array.isArray(section.workflows) ? section.workflows : []];
+  return raw.flatMap((entry) => {
+    if (!entry || typeof entry !== "object")
+      return [];
+    const { class_name: className, script_name: scriptName } = entry;
+    if (typeof className !== "string" || !className)
+      return [];
+    return [{ className, ...typeof scriptName === "string" && scriptName ? { scriptName } : {} }];
+  });
+}
+function readWranglerScope(rootDir, abs) {
+  let text;
+  try {
+    text = readFileSync(abs, "utf8");
+  } catch {
+    return;
+  }
+  const names = [];
+  const mains = [];
+  const bindings = [];
+  let topName;
+  let topMain;
+  if (abs.endsWith(".toml")) {
+    let header = "";
+    let binding;
+    for (const rawLine of text.split(`
+`)) {
+      const line = rawLine.replace(/\s+#.*$/, "").trim();
+      const table = /^\[\[?\s*([^\]]+?)\s*\]\]?$/.exec(line);
+      if (table) {
+        header = table[1];
+        binding = undefined;
+        if (/(?:^|\.)(?:durable_objects\.bindings|workflows)$/.test(header) && line.startsWith("[[")) {
+          binding = { className: "" };
+          bindings.push(binding);
+        }
+        continue;
+      }
+      const pair = /^([\w.-]+)\s*=\s*["']([^"']*)["']/.exec(line);
+      if (!pair)
+        continue;
+      const [, key, value] = pair;
+      const envSection = header === "" || /^env\.[\w-]+$/.test(header);
+      if (binding && key === "class_name")
+        binding.className = value;
+      else if (binding && key === "script_name" && value)
+        binding.scriptName = value;
+      else if (envSection && key === "name" && value) {
+        names.push(value);
+        if (header === "")
+          topName = value;
+      } else if (envSection && key === "main" && value) {
+        mains.push(value);
+        if (header === "")
+          topMain = value;
+      }
+    }
+  } else {
+    let config;
+    try {
+      config = JSON.parse(stripJsonc(text));
+    } catch {
+      return;
+    }
+    if (!config || typeof config !== "object" || Array.isArray(config))
+      return;
+    const root = config;
+    if (typeof root.name === "string")
+      topName = root.name;
+    if (typeof root.main === "string")
+      topMain = root.main;
+    for (const section of [root, ...Object.values(root.env ?? {})]) {
+      if (!section || typeof section !== "object")
+        continue;
+      const s = section;
+      if (typeof s.name === "string" && s.name)
+        names.push(s.name);
+      if (typeof s.main === "string" && s.main)
+        mains.push(s.main);
+      bindings.push(...bindingsOfSection(s));
+    }
+  }
+  const path = relative(rootDir, abs).split("\\").join("/");
+  if (isTestWorkerConfig({ path, name: topName, mains: [topMain] }))
+    return;
+  const dir = workerDir(path);
+  const dirs = [dir];
+  for (const main of mains) {
+    const mainDir = workerDir(posix.normalize(posix.join(dir || ".", main)).replace(/^\.\//, ""));
+    if (!mainDir.startsWith("..") && !inside(mainDir, dir) && !dirs.includes(mainDir))
+      dirs.push(mainDir);
+  }
+  return { dirs, names, bindings: bindings.filter((entry) => entry.className) };
+}
+function inside(path, dir) {
+  return dir === "" || dir === "." || path === dir || path.startsWith(`${dir}/`);
+}
+function boundClassResolver(rootDir) {
+  const scopes = findWranglerFiles(rootDir, ANY_WRANGLER_FILE).map((abs) => readWranglerScope(rootDir, abs)).filter((scope) => Boolean(scope));
+  const anywhere = new Set;
+  const external = new Map;
+  for (const scope of scopes) {
+    for (const binding of scope.bindings) {
+      anywhere.add(binding.className);
+      if (!binding.scriptName)
+        continue;
+      const servers = scopes.filter((other) => other.names.includes(binding.scriptName));
+      if (servers.length === 0)
+        external.set(binding.className, new Set(["*"]));
+      for (const server of servers) {
+        const set = external.get(binding.className) ?? new Set;
+        server.names.forEach((name) => set.add(name));
+        external.set(binding.className, set);
+      }
+    }
+  }
+  return (className, path) => {
+    if (!anywhere.has(className))
+      return false;
+    if (external.get(className)?.has("*"))
+      return true;
+    let nearest = -1;
+    let owners = [];
+    for (const scope of scopes) {
+      const depth = Math.max(-1, ...scope.dirs.filter((dir) => inside(path, dir)).map((dir) => dir ? dir.split("/").length : 0));
+      if (depth < 0 || depth < nearest)
+        continue;
+      if (depth > nearest)
+        owners = [];
+      nearest = depth;
+      owners.push(scope);
+    }
+    if (owners.length === 0)
+      return true;
+    const servedNames = external.get(className);
+    return owners.some((owner) => owner.bindings.some((binding) => binding.className === className && !binding.scriptName) || servedNames !== undefined && owner.names.some((name) => servedNames.has(name)));
+  };
+}
+function relativeImportStems(path, text) {
+  const stems = new Set;
+  for (const match of text.matchAll(/\bfrom\s*['"](\.{1,2}\/[^'"\n]*)['"]/g)) {
+    const joined = posix.normalize(posix.join(workerDir(path) || ".", match[1])).replace(/^\.\//, "");
+    const stem = joined.replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    stems.add(stem);
+    stems.add(`${stem}/index`);
+  }
+  return stems;
+}
+function pickBaseDeclaration(candidates, from, importsOf) {
+  if (candidates.length < 2)
+    return candidates[0];
+  const sameFile = candidates.find((candidate) => candidate.path === from.path);
+  if (sameFile)
+    return sameFile;
+  const imports = importsOf(from.path);
+  const imported = candidates.find((candidate) => imports.has(candidate.path.replace(/\.(?:[cm]?[jt]sx?)$/, "")));
+  if (imported)
+    return imported;
+  const fromDirs = workerDir(from.path).split("/");
+  const shared = (candidate) => {
+    const dirs = workerDir(candidate.path).split("/");
+    let n = 0;
+    while (n < dirs.length && n < fromDirs.length && dirs[n] === fromDirs[n] && dirs[n] !== "")
+      n += 1;
+    return n;
+  };
+  let best = candidates[0];
+  for (const candidate of candidates)
+    if (shared(candidate) > shared(best))
+      best = candidate;
+  return best;
+}
+function detectDefinedUnboundRuntimeClasses(rootDir) {
+  const declarations = [];
+  const texts = new Map;
+  for (const abs of findSourceFiles(rootDir)) {
+    let text;
+    try {
+      text = readFileSync(abs, "utf8");
+    } catch {
+      continue;
+    }
+    if (!text.includes("extends"))
+      continue;
+    const path = relative(rootDir, abs).split("\\").join("/");
+    texts.set(path, text);
+    for (const match of text.matchAll(CLASS_DECLARATION)) {
+      declarations.push({
+        className: match[3],
+        base: match[4],
+        exported: Boolean(match[1]),
+        abstract: Boolean(match[2]),
+        path,
+        line: text.slice(0, match.index).split(`
+`).length
+      });
+    }
+  }
+  const byName = new Map;
+  for (const declaration of declarations) {
+    const list = byName.get(declaration.className) ?? [];
+    list.push(declaration);
+    byName.set(declaration.className, list);
+  }
+  const importCache = new Map;
+  const importsOf = (path) => {
+    let stems = importCache.get(path);
+    if (!stems) {
+      stems = relativeImportStems(path, texts.get(path) ?? "");
+      importCache.set(path, stems);
+    }
+    return stems;
+  };
+  const kindOf = (start) => {
+    let current = start;
+    for (let depth = 0;current && depth < 8; depth += 1) {
+      const base = current.base;
+      const kind = Object.hasOwn(RUNTIME_BASES, base) ? RUNTIME_BASES[base] : undefined;
+      if (kind)
+        return kind;
+      current = pickBaseDeclaration(byName.get(base) ?? [], current, importsOf);
+    }
+    return;
+  };
+  const isBound = boundClassResolver(rootDir);
+  const seen = new Set;
+  const found = [];
+  for (const declaration of declarations) {
+    if (!declaration.exported || declaration.abstract || isBound(declaration.className, declaration.path))
+      continue;
+    const kind = kindOf(declaration);
+    const key = `${declaration.className}|${declaration.path}`;
+    if (!kind || seen.has(key))
+      continue;
+    seen.add(key);
+    found.push({ className: declaration.className, kind, path: declaration.path, line: declaration.line });
+  }
+  return found;
+}
+function definedReason(defined) {
+  const what = defined.kind === "workflow" ? "Workflow" : defined.kind === "agent" ? "Agent (Durable Object)" : "Durable Object";
+  return `${what} class defined but not bound in any wrangler config`;
+}
+function norm(value) {
+  return typeof value === "string" ? value.toLowerCase().replace(/[^a-z0-9]/g, "") : "";
+}
+function itemPaths(item) {
+  const paths = [];
+  for (const value of [item.root, item.sourcePath]) {
+    if (typeof value === "string" && value && value !== ".")
+      paths.push(value.replace(/^\.\//, ""));
+  }
+  for (const entry of Array.isArray(item.evidence) ? item.evidence : []) {
+    const path = entry && typeof entry === "object" ? entry.path : undefined;
+    if (typeof path === "string" && path)
+      paths.push(path.replace(/^\.\//, ""));
+  }
+  return paths;
+}
+function withinWorker(path, dir, otherDirs) {
+  const inside2 = (d) => d === "" || path === d || path.startsWith(`${d}/`);
+  return inside2(dir) && !otherDirs.some((other) => other.length > dir.length && inside2(other));
+}
+function namesClass(name, className) {
+  if (typeof name !== "string")
+    return false;
+  const target = norm(className);
+  const bare = name.replace(/\s*\([^)]*\)\s*$/, "");
+  return norm(bare) === target || bare.split(/[^A-Za-z0-9_]+/).some((word) => norm(word) === target);
+}
+function graphNamesClass(graph, bound, all) {
+  const named = (name) => namesClass(name, bound.className);
+  const sameName = bound.scriptName ? [bound] : all.filter((other) => other.className === bound.className && !other.scriptName);
+  const dir = workerDir(bound.path);
+  const otherDirs = sameName.map((other) => workerDir(other.path)).filter((other) => other !== dir);
+  const covers = (item) => {
+    if (!named(item.name))
+      return false;
+    if (sameName.length < 2)
+      return true;
+    return itemPaths(item).some((path) => withinWorker(path, dir, otherDirs));
+  };
+  return graph.runtimeAgents.some(covers) || graph.artifacts.some(covers);
+}
+function citedFile(rootDir, path) {
+  let rel = path.trim().replace(/\\/g, "/").replace(/:\d+(?::\d+)?$/, "");
+  if (isAbsolute(rel))
+    rel = relative(rootDir, rel).split("\\").join("/");
+  return posix.normalize(rel).replace(/^\.\//, "");
+}
+function graphNamesDeclaration(graph, defined, rootDir) {
+  const named = [...graph.runtimeAgents, ...graph.artifacts].filter((item) => namesClass(item.name, defined.className));
+  if (named.length === 0)
+    return false;
+  const target = citedFile(rootDir, defined.path);
+  const cited = named.map((item) => filePaths(item).map((path) => citedFile(rootDir, path)));
+  if (cited.every((paths) => paths.length === 0))
+    return true;
+  return cited.some((paths) => paths.includes(target));
+}
+function filePaths(item) {
+  const paths = [];
+  if (typeof item.sourcePath === "string" && item.sourcePath.trim())
+    paths.push(item.sourcePath);
+  for (const entry of Array.isArray(item.evidence) ? item.evidence : []) {
+    const path = entry && typeof entry === "object" ? entry.path : undefined;
+    if (typeof path === "string" && path.trim())
+      paths.push(path);
+  }
+  return paths;
+}
+function bindingReason(bound) {
+  const what = bound.kind === "workflow" ? "Workflow" : "Durable Object";
+  const where = bound.scriptName ? ` served by the external Worker "${bound.scriptName}"` : "";
+  return `${what} binding ${bound.binding} -> class ${bound.className}${where}`;
+}
+function uniqueId(base, taken) {
+  let id = base;
+  for (let n = 2;taken.has(id); n += 1)
+    id = `${base}-${n}`;
+  taken.add(id);
+  return id;
+}
+function mergeBoundRuntimeClasses(graph, rootDir) {
+  if (process.env.MODA_HARNESS_DETERMINISTIC_MERGE === "0")
+    return { added: 0 };
+  let bound;
+  let defined;
+  try {
+    bound = detectBoundRuntimeClasses(rootDir);
+    defined = detectDefinedUnboundRuntimeClasses(rootDir);
+  } catch {
+    return { added: 0 };
+  }
+  const taken = new Set([
+    ...graph.runtimeAgents.map((agent) => agent.id),
+    ...graph.artifacts.map((artifact) => artifact.id)
+  ]);
+  let added = 0;
+  for (const entry of bound) {
+    if (graphNamesClass(graph, entry, bound))
+      continue;
+    const evidence = [{ path: entry.path, ...entry.line ? { line: entry.line } : {}, reason: bindingReason(entry) }];
+    const slug = entry.className.replace(/[^A-Za-z0-9]+/g, "-").toLowerCase();
+    if (entry.kind === "durable_object" && AGENT_CLASS.test(entry.className) && !entry.scriptName) {
+      const agent = {
+        id: uniqueId(`agent.bound.${slug}`, taken),
+        name: entry.className,
+        kind: "runtime_agent",
+        purpose: "Agent class bound as a Durable Object.",
+        root: ".",
+        entrypointIds: [],
+        channelAdapterIds: [],
+        artifactIds: [],
+        identityNamespaceIds: [],
+        deploymentIds: [],
+        frameworkIds: [],
+        modelProviderIds: [],
+        confidence: 0.6,
+        evidence
+      };
+      graph.runtimeAgents.push(agent);
+    } else {
+      const artifact = {
+        id: uniqueId(`entrypoint.bound.${slug}`, taken),
+        type: "entrypoint",
+        name: entry.className,
+        scope: "shared",
+        sourcePath: entry.path,
+        usedByAgentIds: [],
+        confidence: 0.6,
+        evidence
+      };
+      graph.artifacts.push(artifact);
+    }
+    added += 1;
+  }
+  for (const entry of defined) {
+    if (graphNamesDeclaration(graph, entry, rootDir))
+      continue;
+    const slug = entry.className.replace(/[^A-Za-z0-9]+/g, "-").toLowerCase();
+    graph.artifacts.push({
+      id: uniqueId(`entrypoint.defined.${slug}`, taken),
+      type: "entrypoint",
+      name: entry.className,
+      scope: "shared",
+      sourcePath: entry.path,
+      usedByAgentIds: [],
+      confidence: 0.6,
+      evidence: [{ path: entry.path, line: entry.line, reason: definedReason(entry) }]
+    });
+    added += 1;
+  }
+  return { added };
+}
+
+// src/harness-component-status.ts
+var HARNESS_COMPONENT_STATUSES = new Set(["in_prod", "reachable", "defined_only"]);
+var STATUS_ALIASES = {
+  in_prod: "in_prod",
+  inprod: "in_prod",
+  prod: "in_prod",
+  production: "in_prod",
+  in_production: "in_prod",
+  deployed: "in_prod",
+  live: "in_prod",
+  reachable: "reachable",
+  defined_only: "defined_only",
+  dead: "defined_only",
+  dead_code: "defined_only",
+  unused: "defined_only",
+  unreferenced: "defined_only",
+  unreachable: "defined_only",
+  orphan: "defined_only",
+  orphaned: "defined_only"
+};
+function normalizeComponentStatus(value) {
+  if (typeof value !== "string")
+    return;
+  return STATUS_ALIASES[value.trim().toLowerCase().replace(/[\s-]+/g, "_")];
+}
+var SKIPPED_DIRS2 = new Set(["node_modules", "dist", "build", "vendor", "coverage"]);
+var NON_DEPLOY_DIR = /^(?:test|tests|__tests__|fixtures?|__fixtures__|examples?|e2e)$/;
+var WRANGLER_FILE2 = /^wrangler(?:\.([\w.-]+))?\.(?:json|jsonc|toml)$/;
+var NON_DEPLOY_VARIANT = /(?:^|[.-])(?:preview|dev|local|test|example|sample)(?:$|[.-])/i;
+var CODE_FILE = /\.(?:[cm]?[jt]sx?)$/;
+var TEST_RUNNER_FILE = /(?:^|\/)__tests__\/|\.(?:test|spec)\.[cm]?[jt]sx?$/;
+var RESOLVE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var TS_FOR_JS = { ".js": [".ts", ".tsx"], ".jsx": [".tsx"], ".mjs": [".mts"], ".cjs": [".cts"] };
+var MAX_FILES = 200000;
+var MAX_READ_BYTES = 1024 * 1024;
+var STATIC_IMPORT = /\b(?:import|export)\s+(type\s+)?([^'";]*?)\bfrom\s*['"]([^'"\n]+)['"]/g;
+var SIDE_EFFECT_IMPORT = /\bimport\s*['"]([^'"\n]+)['"]/g;
+var DYNAMIC_IMPORT = /\b(?:import|require)\s*\(\s*['"]([^'"\n]+)['"]\s*\)/g;
+var CLASS_DECL = /\bclass\s+([A-Za-z_$][\w$]*)/g;
+var SCRIPT_FILE = /(?:^|[\s;&|(])(?:bun|node|tsx)\s+((?:-{1,2}[\w-]+(?:=\S+)?\s+)*)(?:run\s+)?([^\s'"&|;()]+)/g;
+function listFiles(rootDir) {
+  const files = new Set;
+  const walk = (abs, rel) => {
+    let entries;
+    try {
+      entries = readdirSync2(abs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.size >= MAX_FILES)
+        return;
+      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !SKIPPED_DIRS2.has(entry.name))
+          walk(join2(abs, entry.name), childRel);
+      } else if (entry.isFile()) {
+        files.add(childRel);
+      }
+    }
+  };
+  walk(rootDir, "");
+  return files;
+}
+function readCapped(abs) {
+  const fd = openSync(abs, "r");
+  try {
+    const buffer = Buffer.alloc(MAX_READ_BYTES);
+    const read = readSync(fd, buffer, 0, MAX_READ_BYTES, 0);
+    return buffer.subarray(0, read).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+function readJson(rootDir, rel) {
+  try {
+    const parsed = JSON.parse(stripJsonc(readFileSync2(join2(rootDir, rel), "utf8")));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function dirOf(rel) {
+  const slash = rel.lastIndexOf("/");
+  return slash < 0 ? "" : rel.slice(0, slash);
+}
+function joinRel(dir, path) {
+  const joined = posix2.normalize(posix2.join(dir || ".", path));
+  return joined === "." ? "" : joined.replace(/^\.\//, "").replace(/\/$/, "");
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+var PREFERRED_CONDITIONS = ["import", "default", "require", "node"];
+function exportTargets(value, out = []) {
+  if (typeof value === "string")
+    out.push(value);
+  else if (Array.isArray(value))
+    value.forEach((item) => exportTargets(item, out));
+  else if (isRecord(value)) {
+    const keys = Object.keys(value).filter((key) => key !== "types" && key !== "typings");
+    const preferred = keys.filter((key) => PREFERRED_CONDITIONS.includes(key));
+    for (const key of [...preferred, ...keys.filter((key2) => !preferred.includes(key2))])
+      exportTargets(value[key], out);
+  }
+  return out;
+}
+function isTypeOnlyClause(clause) {
+  const braces = /^\{([^{}]*)\}$/.exec(clause.trim());
+  if (!braces)
+    return false;
+  const members = braces[1].split(",").map((member) => member.trim()).filter(Boolean);
+  return members.length > 0 && members.every((member) => /^type\s+(?!as\s+[\w$]+$)\S/.test(member));
+}
+function stringLeaves(value, out = []) {
+  if (typeof value === "string")
+    out.push(value);
+  else if (Array.isArray(value))
+    value.forEach((item) => stringLeaves(item, out));
+  else if (isRecord(value)) {
+    for (const [key, item] of Object.entries(value)) {
+      if (key !== "types" && key !== "typings")
+        stringLeaves(item, out);
+    }
+  }
+  return out;
+}
+function boundClassesOf(section) {
+  const durable = isRecord(section.durable_objects) ? section.durable_objects.bindings : undefined;
+  const raw = [...Array.isArray(durable) ? durable : [], ...Array.isArray(section.workflows) ? section.workflows : []];
+  return raw.filter(isRecord).flatMap((entry) => typeof entry.class_name === "string" && entry.class_name ? [{ className: entry.class_name, ...typeof entry.script_name === "string" && entry.script_name ? { scriptName: entry.script_name } : {} }] : []);
+}
+var PRODUCTION_ENV = /^(?:production|prod)$/i;
+function parseWranglerToml(text) {
+  const names = [];
+  const mains = [];
+  const otherMains = [];
+  const boundClasses = [];
+  let topName;
+  let header = "";
+  let binding;
+  for (const rawLine of text.split(`
+`)) {
+    const line = rawLine.replace(/\s+#.*$/, "").trim();
+    const table = /^\[\[?\s*([^\]]+?)\s*\]\]?$/.exec(line);
+    if (table) {
+      header = table[1];
+      binding = undefined;
+      if (/(?:^|\.)(?:durable_objects\.bindings|workflows)$/.test(header) && line.startsWith("[[")) {
+        binding = { className: "" };
+        boundClasses.push(binding);
+      }
+      continue;
+    }
+    const pair = /^([\w.-]+)\s*=\s*["']([^"']*)["']/.exec(line);
+    if (!pair)
+      continue;
+    const [, key, value] = pair;
+    const envName = /^env\.([\w-]+)$/.exec(header)?.[1];
+    const envSection = header === "" || envName !== undefined;
+    if (binding && key === "class_name")
+      binding.className = value;
+    else if (binding && key === "script_name" && value)
+      binding.scriptName = value;
+    else if (envSection && key === "name") {
+      if (header === "")
+        topName = value;
+      names.push(value);
+    } else if (envSection && key === "main") {
+      (envName === undefined || PRODUCTION_ENV.test(envName) ? mains : otherMains).push(value);
+    }
+  }
+  return { name: topName, names, mains, otherMains, boundClasses: boundClasses.filter((entry) => entry.className) };
+}
+function readWranglerWorker(rootDir, rel) {
+  const dir = dirOf(rel);
+  const fileName = rel.slice(dir ? dir.length + 1 : 0);
+  const variant = WRANGLER_FILE2.exec(fileName)?.[1] ?? "";
+  let name;
+  const names = [];
+  const mains = [];
+  const otherMains = [];
+  const boundClasses = [];
+  if (rel.endsWith(".toml")) {
+    let text;
+    try {
+      text = readFileSync2(join2(rootDir, rel), "utf8");
+    } catch {
+      return;
+    }
+    const parsed = parseWranglerToml(text);
+    name = parsed.name;
+    names.push(...parsed.names);
+    mains.push(...parsed.mains);
+    otherMains.push(...parsed.otherMains);
+    boundClasses.push(...parsed.boundClasses);
+  } else {
+    const config = readJson(rootDir, rel);
+    if (!config)
+      return;
+    name = typeof config.name === "string" && config.name ? config.name : undefined;
+    const sections = [[undefined, config], ...Object.entries(isRecord(config.env) ? config.env : {})];
+    for (const [envName, section] of sections) {
+      if (!isRecord(section))
+        continue;
+      if (typeof section.name === "string" && section.name)
+        names.push(section.name);
+      if (typeof section.main === "string" && section.main) {
+        (envName === undefined || PRODUCTION_ENV.test(envName) ? mains : otherMains).push(section.main);
+      }
+      boundClasses.push(...boundClassesOf(section));
+    }
+  }
+  const nonDeployDir = rel.split("/").slice(0, -1).some((segment) => NON_DEPLOY_DIR.test(segment));
+  return {
+    path: rel,
+    deployed: Boolean(name) && !nonDeployDir && !NON_DEPLOY_VARIANT.test(variant) && !isTestWorkerConfig({ path: rel, name, mains }),
+    names,
+    mains: [...new Set(mains)].map((main) => joinRel(dir, main)),
+    otherMains: [...new Set(otherMains)].filter((main) => !mains.includes(main)).map((main) => joinRel(dir, main)),
+    boundClasses,
+    reach: new Set
+  };
+}
+function readWorkspacePackage(rootDir, rel) {
+  const pkg = readJson(rootDir, rel);
+  if (!pkg)
+    return;
+  const dir = dirOf(rel);
+  const entries = [];
+  const subpaths = new Map;
+  const patterns = [];
+  for (const field of ["main", "module"]) {
+    if (typeof pkg[field] === "string")
+      entries.push(pkg[field]);
+  }
+  if (typeof pkg.bin === "string")
+    entries.push(pkg.bin);
+  else if (isRecord(pkg.bin))
+    entries.push(...stringLeaves(pkg.bin));
+  const exportsField = pkg.exports;
+  if (isRecord(exportsField) && Object.keys(exportsField).some((key) => key.startsWith("."))) {
+    for (const [key, value] of Object.entries(exportsField)) {
+      const targets = exportTargets(value);
+      const star = key.indexOf("*");
+      if (star >= 0) {
+        if (key.indexOf("*", star + 1) < 0)
+          patterns.push({ prefix: key.slice(0, star), suffix: key.slice(star + 1), targets });
+        continue;
+      }
+      subpaths.set(key, targets);
+      entries.push(...targets);
+    }
+    patterns.sort((a, b) => b.prefix.length - a.prefix.length || b.suffix.length - a.suffix.length);
+  } else if (exportsField !== undefined) {
+    const targets = exportTargets(exportsField);
+    subpaths.set(".", targets);
+    entries.push(...targets);
+  }
+  const scriptFiles = [];
+  if (isRecord(pkg.scripts)) {
+    for (const command of Object.values(pkg.scripts)) {
+      if (typeof command !== "string")
+        continue;
+      for (const match of command.matchAll(SCRIPT_FILE))
+        scriptFiles.push(match[2]);
+    }
+  }
+  return {
+    dir,
+    ...typeof pkg.name === "string" && pkg.name ? { name: pkg.name } : {},
+    entries: entries.filter((entry) => !entry.includes("*")),
+    subpaths,
+    patterns,
+    scriptFiles
+  };
+}
+function readPathAliases(rootDir, rel, depth = 0) {
+  const config = readJson(rootDir, rel);
+  if (!config)
+    return [];
+  const options = isRecord(config.compilerOptions) ? config.compilerOptions : {};
+  if (isRecord(options.paths)) {
+    const base = joinRel(dirOf(rel), typeof options.baseUrl === "string" ? options.baseUrl : ".");
+    return Object.entries(options.paths).flatMap(([pattern, targets]) => {
+      if (!Array.isArray(targets))
+        return [];
+      const star = pattern.indexOf("*");
+      return [{
+        prefix: star < 0 ? pattern : pattern.slice(0, star),
+        suffix: star < 0 ? "" : pattern.slice(star + 1),
+        wildcard: star >= 0,
+        targets: targets.filter((target) => typeof target === "string").map((target) => joinRel(base, target))
+      }];
+    });
+  }
+  if (depth < 3 && typeof config.extends === "string" && config.extends.startsWith(".")) {
+    const parent = joinRel(dirOf(rel), config.extends.endsWith(".json") ? config.extends : `${config.extends}.json`);
+    return readPathAliases(rootDir, parent, depth + 1);
+  }
+  return [];
+}
+function analyzeRepository(rootDir) {
+  const files = listFiles(rootDir);
+  const workers = [];
+  const packages = [];
+  for (const rel of files) {
+    const fileName = rel.slice(rel.lastIndexOf("/") + 1);
+    if (WRANGLER_FILE2.test(fileName)) {
+      const worker = readWranglerWorker(rootDir, rel);
+      if (worker)
+        workers.push(worker);
+    } else if (fileName === "package.json") {
+      const pkg = readWorkspacePackage(rootDir, rel);
+      if (pkg)
+        packages.push(pkg);
+    }
+  }
+  workers.sort((a, b) => a.path.localeCompare(b.path));
+  const packagesByName = new Map(packages.filter((pkg) => pkg.name).map((pkg) => [pkg.name, pkg]));
+  const packageDirs = new Set(packages.map((pkg) => pkg.dir));
+  const resolveFile = (base) => {
+    if (!base || base.startsWith(".."))
+      return;
+    const ext = posix2.extname(base);
+    for (const tsExt of TS_FOR_JS[ext] ?? []) {
+      const candidate = base.slice(0, -ext.length) + tsExt;
+      if (files.has(candidate))
+        return candidate;
+    }
+    if (files.has(base))
+      return base;
+    for (const candidate of RESOLVE_EXTS)
+      if (files.has(base + candidate))
+        return base + candidate;
+    for (const candidate of RESOLVE_EXTS)
+      if (files.has(`${base}/index${candidate}`))
+        return `${base}/index${candidate}`;
+    return;
+  };
+  const resolveEntry = (dir, entry) => {
+    const direct = resolveFile(joinRel(dir, entry));
+    if (direct)
+      return direct;
+    const fromSource = entry.replace(/^\.?\/?(?:dist|build|lib|out)\//, "src/").replace(/\.d\.[cm]?ts$/, ".ts");
+    return fromSource !== entry ? resolveFile(joinRel(dir, fromSource)) : undefined;
+  };
+  const aliasCache = new Map;
+  const aliasesFor = (dir) => {
+    const cached = aliasCache.get(dir);
+    if (cached)
+      return cached;
+    const tsconfig = dir ? `${dir}/tsconfig.json` : "tsconfig.json";
+    const aliases = files.has(tsconfig) ? readPathAliases(rootDir, tsconfig) : dir ? aliasesFor(dirOf(dir)) : [];
+    aliasCache.set(dir, aliases);
+    return aliases;
+  };
+  const resolvePackage = (specifier) => {
+    const parts = specifier.split("/");
+    const nameLength = specifier.startsWith("@") ? 2 : 1;
+    const name = parts.slice(0, nameLength).join("/");
+    const subpath = parts.slice(nameLength).join("/");
+    const pkg = packagesByName.get(name);
+    if (pkg) {
+      const key = subpath ? `./${subpath}` : ".";
+      let targets = pkg.subpaths.get(key);
+      if (!targets && subpath) {
+        const pattern = pkg.patterns.find((entry) => key.startsWith(entry.prefix) && key.endsWith(entry.suffix) && key.length >= entry.prefix.length + entry.suffix.length);
+        const captured = pattern ? key.slice(pattern.prefix.length, key.length - pattern.suffix.length) : "";
+        targets = pattern ? pattern.targets.map((target) => target.split("*").join(captured)) : [];
+      }
+      for (const target of targets ?? pkg.entries) {
+        const resolved = resolveEntry(pkg.dir, target);
+        if (resolved)
+          return resolved;
+      }
+      if (subpath)
+        return resolveFile(joinRel(pkg.dir, subpath)) ?? resolveFile(joinRel(pkg.dir, `src/${subpath}`));
+      return resolveFile(joinRel(pkg.dir, "src/index")) ?? resolveFile(joinRel(pkg.dir, "index"));
+    }
+    const leaf = parts[nameLength - 1];
+    for (const parent of ["packages", "apps", "libs"]) {
+      const dir = `${parent}/${leaf}`;
+      if (packageDirs.has(dir))
+        continue;
+      const resolved = subpath ? resolveFile(`${dir}/src/${subpath}`) ?? resolveFile(`${dir}/${subpath}`) : resolveFile(`${dir}/src/index`) ?? resolveFile(`${dir}/index`);
+      if (resolved)
+        return resolved;
+    }
+    return;
+  };
+  const resolveSpecifier = (raw, from) => {
+    const specifier = raw.split("?")[0];
+    if (!specifier || specifier.startsWith("node:") || specifier.startsWith("/"))
+      return;
+    if (specifier.startsWith("."))
+      return resolveFile(joinRel(dirOf(from), specifier));
+    for (const alias of aliasesFor(dirOf(from))) {
+      let captured;
+      if (!alias.wildcard && specifier === alias.prefix)
+        captured = "";
+      else if (alias.wildcard && specifier.startsWith(alias.prefix) && specifier.endsWith(alias.suffix) && specifier.length >= alias.prefix.length + alias.suffix.length) {
+        captured = specifier.slice(alias.prefix.length, specifier.length - alias.suffix.length);
+      }
+      if (captured === undefined)
+        continue;
+      for (const target of alias.targets) {
+        const resolved = resolveFile(alias.wildcard ? target.replace("*", captured) : target);
+        if (resolved)
+          return resolved;
+      }
+    }
+    return resolvePackage(specifier);
+  };
+  const classFiles = new Map;
+  const edgeCache = new Map;
+  const edgesOf = (file) => {
+    const cached = edgeCache.get(file);
+    if (cached)
+      return cached;
+    const edges = [];
+    edgeCache.set(file, edges);
+    if (!CODE_FILE.test(file))
+      return edges;
+    let text;
+    try {
+      text = readCapped(join2(rootDir, file));
+    } catch {
+      return edges;
+    }
+    text = text.replace(/^\s*\/\/.*$/gm, "");
+    const specifiers = [];
+    for (const match of text.matchAll(STATIC_IMPORT)) {
+      if (!match[1] && !isTypeOnlyClause(match[2]))
+        specifiers.push(match[3]);
+    }
+    for (const match of text.matchAll(SIDE_EFFECT_IMPORT))
+      specifiers.push(match[1]);
+    for (const match of text.matchAll(DYNAMIC_IMPORT))
+      specifiers.push(match[1]);
+    for (const specifier of new Set(specifiers)) {
+      const resolved = resolveSpecifier(specifier, file);
+      if (resolved && resolved !== file)
+        edges.push(resolved);
+    }
+    for (const match of text.matchAll(CLASS_DECL)) {
+      const list = classFiles.get(match[1]) ?? [];
+      if (!list.includes(file))
+        list.push(file);
+      classFiles.set(match[1], list);
+    }
+    return edges;
+  };
+  const walk = (starts, seen = new Set) => {
+    const queue = [...starts].filter((start) => Boolean(start) && !seen.has(start));
+    for (const start of queue)
+      seen.add(start);
+    while (queue.length > 0) {
+      const file = queue.pop();
+      for (const next of edgesOf(file)) {
+        if (!seen.has(next)) {
+          seen.add(next);
+          queue.push(next);
+        }
+      }
+    }
+    return seen;
+  };
+  const inProd = new Set;
+  for (const worker of workers) {
+    worker.reach = walk(worker.mains.map((main) => resolveEntry("", main)));
+    if (!worker.deployed)
+      continue;
+    inProd.add(worker.path);
+    for (const file of worker.reach)
+      inProd.add(file);
+  }
+  const otherStarts = workers.filter((worker) => !worker.deployed).map((worker) => worker.path);
+  for (const worker of workers) {
+    if (!worker.deployed)
+      otherStarts.push(...worker.reach);
+    otherStarts.push(...worker.otherMains.map((main) => resolveEntry("", main)));
+  }
+  for (const pkg of packages) {
+    otherStarts.push(...pkg.entries.map((entry) => resolveEntry(pkg.dir, entry)));
+    otherStarts.push(...pkg.scriptFiles.map((script) => resolveFile(joinRel(pkg.dir, script))));
+  }
+  const all = walk(otherStarts, new Set(inProd));
+  const reachable = new Set([...all].filter((file) => !inProd.has(file)));
+  return { inProd, reachable, files, workers, classFiles, resolveFile };
+}
+function norm2(value) {
+  return typeof value === "string" ? value.toLowerCase().replace(/[^a-z0-9]/g, "") : "";
+}
+function normalizeItemPath(rootDir, path) {
+  let rel = path.trim().replace(/\\/g, "/").replace(/:\d+(?::\d+)?$/, "");
+  if (isAbsolute2(rel))
+    rel = relative2(rootDir, rel).split("\\").join("/");
+  return joinRel("", rel);
+}
+function definingPath(item) {
+  if (typeof item.sourcePath === "string" && item.sourcePath.trim())
+    return item.sourcePath;
+  for (const entry of Array.isArray(item.evidence) ? item.evidence : []) {
+    const path = isRecord(entry) ? entry.path : undefined;
+    if (typeof path === "string" && path.trim())
+      return path;
+  }
+  return;
+}
+function boundClassStatus(analysis, worker, item) {
+  const wanted = new Set([norm2(item.name), norm2(typeof item.id === "string" ? item.id.split(".").pop() : "")]);
+  const bound = worker.boundClasses.find((entry) => wanted.has(norm2(entry.className)));
+  if (!bound)
+    return null;
+  const servers = bound.scriptName ? analysis.workers.filter((other) => other.names.includes(bound.scriptName)) : [worker];
+  const declared = analysis.classFiles.get(bound.className) ?? [];
+  if (servers.some((server) => server.deployed && declared.some((file) => server.reach.has(file))))
+    return "in_prod";
+  if (declared.some((file) => analysis.inProd.has(file) || analysis.reachable.has(file)))
+    return "reachable";
+  return;
+}
+function itemStatus(analysis, rootDir, item) {
+  const raw = definingPath(item);
+  if (!raw)
+    return;
+  const path = normalizeItemPath(rootDir, raw);
+  const worker = analysis.workers.find((entry) => entry.path === path);
+  if (worker) {
+    const classStatus = boundClassStatus(analysis, worker, item);
+    if (classStatus !== null)
+      return classStatus;
+    return worker.deployed ? "in_prod" : "reachable";
+  }
+  const file = analysis.files.has(path) ? path : analysis.resolveFile(path);
+  if (!file)
+    return;
+  if (analysis.inProd.has(file))
+    return "in_prod";
+  if (analysis.reachable.has(file))
+    return "reachable";
+  return CODE_FILE.test(file) && !TEST_RUNNER_FILE.test(file) ? "defined_only" : undefined;
+}
+function tagComponentStatus(graph, rootDir) {
+  if (process.env.MODA_HARNESS_DETERMINISTIC_MERGE === "0")
+    return { tagged: 0, counts: {} };
+  try {
+    const analysis = analyzeRepository(rootDir);
+    const counts = { in_prod: 0, reachable: 0, defined_only: 0, unknown: 0 };
+    let tagged = 0;
+    const items = [
+      ...Array.isArray(graph.runtimeAgents) ? graph.runtimeAgents : [],
+      ...Array.isArray(graph.artifacts) ? graph.artifacts : []
+    ];
+    for (const item of items) {
+      if (!isRecord(item))
+        continue;
+      if (item.status === undefined || !HARNESS_COMPONENT_STATUSES.has(item.status)) {
+        const status = itemStatus(analysis, rootDir, item);
+        if (status) {
+          item.status = status;
+          tagged += 1;
+        } else {
+          delete item.status;
+        }
+      }
+      counts[item.status ?? "unknown"] += 1;
+    }
+    if (isRecord(graph.scan)) {
+      graph.scan.componentStatusCounts = counts;
+    }
+    return { tagged, counts };
+  } catch {
+    return { tagged: 0, counts: {} };
+  }
+}
+
+// src/harness-report.ts
 var HARNESS_REPORT_SCHEMA_VERSION = "harness_report.v0.1";
 var HARNESS_REPORT_VALIDATION_SCHEMA_VERSION = "harness_report_validation.v0.1";
 var HARNESS_REPORT_APPROVAL_SCHEMA_VERSION = "harness_report_approval.v0.1";
-var HARNESS_REPORT_PATH = join(".moda", "harness-report.json");
-var HARNESS_REPORT_MARKDOWN_PATH = join(".moda", "HARNESS_REPORT.md");
-var HARNESS_REPORT_VALIDATION_PATH = join(".moda", "harness-report-validation.json");
-var HARNESS_REPORT_APPROVAL_PATH = join(".moda", "harness-report-approval.json");
+var HARNESS_REPORT_PATH = join3(".moda", "harness-report.json");
+var HARNESS_REPORT_MARKDOWN_PATH = join3(".moda", "HARNESS_REPORT.md");
+var HARNESS_REPORT_VALIDATION_PATH = join3(".moda", "harness-report-validation.json");
+var HARNESS_REPORT_APPROVAL_PATH = join3(".moda", "harness-report-approval.json");
 var HARNESS_ANALYZE_CONCERNS = ["topology", "tools", "prompts", "evals"];
 var HARNESS_GRAPH_ARRAY_FIELDS = [
   "agentFamilies",
@@ -300,7 +1477,7 @@ function validateHarnessReport(report, rootDir, options) {
   check("graph_present", Boolean(report?.graph?.schemaVersion), "Report must include the sanitized harness graph.");
   check("citations_present", Array.isArray(report?.citations) && report.citations.length > 0, "Report must include citations.");
   check("claims_present", Array.isArray(report?.claims) && report.claims.length > 0, "Report must include claims.");
-  const syncPlan = isRecord(report?.syncPlan) ? report.syncPlan : undefined;
+  const syncPlan = isRecord2(report?.syncPlan) ? report.syncPlan : undefined;
   check("sync_plan_present", Boolean(syncPlan), "Report must include syncPlan.");
   if (syncPlan) {
     check("sync_plan_command", typeof syncPlan.command === "string" && syncPlan.command.length > 0, "Report syncPlan must include command.");
@@ -339,7 +1516,7 @@ function validateHarnessReport(report, rootDir, options) {
   const requireLineCitations = report?.analyst?.mode === "agent";
   for (const [index, citation] of citations.entries()) {
     const label = citationLabel(citation, index);
-    if (!isRecord(citation)) {
+    if (!isRecord2(citation)) {
       errors.push(`Citation ${index + 1} must be an object.`);
       continue;
     }
@@ -366,7 +1543,7 @@ function validateHarnessReport(report, rootDir, options) {
   const claimIds = new Set;
   for (const [index, claim] of claims.entries()) {
     const label = claimLabel(claim, index);
-    if (!isRecord(claim)) {
+    if (!isRecord2(claim)) {
       errors.push(`Claim ${index + 1} must be an object.`);
       continue;
     }
@@ -437,7 +1614,7 @@ function validateHarnessReport(report, rootDir, options) {
   if (unknowns.length > 0) {
     warn("unknowns_present", `${unknowns.length} open harness question(s) require human review.`);
     for (const [index, unknown] of unknowns.entries()) {
-      if (!isRecord(unknown)) {
+      if (!isRecord2(unknown)) {
         errors.push(`Unknown ${index + 1} must be an object.`);
         continue;
       }
@@ -465,7 +1642,7 @@ function validateHarnessReport(report, rootDir, options) {
   };
 }
 function refutedToolCandidateCount(graph) {
-  const unknowns = Array.isArray(graph.unknowns) ? graph.unknowns.filter(isRecord) : [];
+  const unknowns = Array.isArray(graph.unknowns) ? graph.unknowns.filter(isRecord2) : [];
   let count = 0;
   for (const unknown of unknowns) {
     const label = `${String(unknown.id ?? "")} ${String(unknown.question ?? "")}`;
@@ -484,8 +1661,8 @@ function validateDeterministicFloor(report, floor, check, warn, concern) {
     return;
   const applyToolFloor = concern === undefined || concern === "tools";
   const applyTopologyFloors = concern === undefined || concern === "topology";
-  const graph = isRecord(report?.graph) ? report.graph : {};
-  const toolArtifactCount = Array.isArray(graph.artifacts) ? graph.artifacts.filter((artifact) => isRecord(artifact) && artifact.type === "tool").length : 0;
+  const graph = isRecord2(report?.graph) ? report.graph : {};
+  const toolArtifactCount = Array.isArray(graph.artifacts) ? graph.artifacts.filter((artifact) => isRecord2(artifact) && artifact.type === "tool").length : 0;
   const providerCount = safeArrayLength(graph.modelProviders);
   const runtimeAgentCount = safeArrayLength(graph.runtimeAgents);
   if (applyToolFloor && typeof floor.toolCandidates === "number" && floor.toolCandidates >= 5) {
@@ -534,9 +1711,9 @@ async function approveHarnessReport(options) {
     approved: true,
     approvedAt: new Date().toISOString(),
     approvedBy,
-    reportPath: normalizePath(relative(options.rootDir, options.reportPath)) || HARNESS_REPORT_PATH
+    reportPath: normalizePath(relative3(options.rootDir, options.reportPath)) || HARNESS_REPORT_PATH
   };
-  writeJson(join(options.rootDir, HARNESS_REPORT_APPROVAL_PATH), approval);
+  writeJson(join3(options.rootDir, HARNESS_REPORT_APPROVAL_PATH), approval);
   return { report, validation, approval };
 }
 function loadHarnessReportForSync(rootDir, reportPath, options) {
@@ -546,37 +1723,37 @@ function loadHarnessReportForSync(rootDir, reportPath, options) {
     throw new CliInputError("Harness report validation failed; cannot sync.", validation.errors.slice(0, 5).join(`
 `));
   }
-  const approvalPath = join(rootDir, HARNESS_REPORT_APPROVAL_PATH);
-  const approval = existsSync(approvalPath) ? JSON.parse(readFileSync(approvalPath, "utf8")) : null;
+  const approvalPath = join3(rootDir, HARNESS_REPORT_APPROVAL_PATH);
+  const approval = existsSync(approvalPath) ? JSON.parse(readFileSync3(approvalPath, "utf8")) : null;
   const approved = approval?.schemaVersion === HARNESS_REPORT_APPROVAL_SCHEMA_VERSION && approval.reportId === report.reportId && approval.reportHash === hashHarnessReport(report) && approval.approved === true;
   return { report, validation, approval, approved };
 }
 function readHarnessReport(reportPath) {
-  return normalizeHarnessReport(JSON.parse(readFileSync(reportPath, "utf8")));
+  return normalizeHarnessReport(JSON.parse(readFileSync3(reportPath, "utf8")));
 }
 function normalizeHarnessReport(value) {
   const report = cloneJson(value);
-  if (!isRecord(report.graph))
+  if (!isRecord2(report.graph))
     return report;
   const graph = report.graph;
   if (typeof graph.schemaVersion !== "string" && typeof graph.graphSchemaVersion === "string") {
     graph.schemaVersion = graph.graphSchemaVersion;
   }
-  if (typeof graph.schemaVersion !== "string" && isRecord(report.source) && typeof report.source.graphSchemaVersion === "string") {
+  if (typeof graph.schemaVersion !== "string" && isRecord2(report.source) && typeof report.source.graphSchemaVersion === "string") {
     graph.schemaVersion = report.source.graphSchemaVersion;
   }
   if (typeof graph.harnessId !== "string" && typeof report.harnessId === "string") {
     graph.harnessId = report.harnessId;
   }
-  if (!isRecord(graph.repo) && isRecord(report.repo)) {
+  if (!isRecord2(graph.repo) && isRecord2(report.repo)) {
     graph.repo = report.repo;
   }
-  if (!isRecord(graph.tenant) && isRecord(report.tenant)) {
+  if (!isRecord2(graph.tenant) && isRecord2(report.tenant)) {
     graph.tenant = report.tenant;
   }
-  if (!isRecord(graph.scan)) {
-    const source = isRecord(report.source) ? report.source : {};
-    const readPlan = isRecord(source.readPlan) ? source.readPlan : defaultHarnessReadPlan();
+  if (!isRecord2(graph.scan)) {
+    const source = isRecord2(report.source) ? report.source : {};
+    const readPlan = isRecord2(source.readPlan) ? source.readPlan : defaultHarnessReadPlan();
     graph.scan = {
       createdAt: typeof report.createdAt === "string" ? report.createdAt : new Date().toISOString(),
       scannerVersion: analystAdapter(report),
@@ -602,7 +1779,7 @@ function normalizeHarnessReport(value) {
   return report;
 }
 function normalizeHarnessSyncPlan(report) {
-  const syncPlan = isRecord(report.syncPlan) ? report.syncPlan : {};
+  const syncPlan = isRecord2(report.syncPlan) ? report.syncPlan : {};
   if (typeof syncPlan.command !== "string" || syncPlan.command.length === 0) {
     syncPlan.command = `moda harness sync --from-report ${HARNESS_REPORT_PATH}`;
   }
@@ -627,7 +1804,7 @@ function normalizeRelationshipEvidence(graph) {
     return;
   const evidenceById = graphEvidenceById(graph);
   for (const relationship of relationships) {
-    if (!isRecord(relationship))
+    if (!isRecord2(relationship))
       continue;
     if (Array.isArray(relationship.evidence) && relationship.evidence.length > 0)
       continue;
@@ -650,9 +1827,9 @@ function graphEvidenceById(graph) {
     if (!Array.isArray(collection))
       continue;
     for (const item of collection) {
-      if (!isRecord(item) || typeof item.id !== "string" || !Array.isArray(item.evidence))
+      if (!isRecord2(item) || typeof item.id !== "string" || !Array.isArray(item.evidence))
         continue;
-      const evidence = item.evidence.filter((entry) => isRecord(entry) && typeof entry.path === "string" && typeof entry.reason === "string").map((entry) => normalizeEvidenceEntry(entry));
+      const evidence = item.evidence.filter((entry) => isRecord2(entry) && typeof entry.path === "string" && typeof entry.reason === "string").map((entry) => normalizeEvidenceEntry(entry));
       if (evidence.length > 0)
         byId.set(item.id, evidence);
     }
@@ -676,7 +1853,7 @@ function normalizeEvidenceEntry(item) {
   return line ? { path: item.path, reason: item.reason, line } : { path: item.path, reason: item.reason };
 }
 function normalizeHarnessClaim(claim, graph) {
-  if (!isRecord(claim))
+  if (!isRecord2(claim))
     return claim;
   if (typeof claim.subjectId !== "string" && Array.isArray(claim.subjectIds) && typeof claim.subjectIds[0] === "string") {
     claim.subjectId = claim.subjectIds[0];
@@ -724,17 +1901,18 @@ function validateGraphItemShapes(graph, errors) {
   if (typeof graph.harnessId !== "string" || graph.harnessId.length === 0) {
     errors.push("Graph must include harnessId.");
   }
-  if (!isRecord(graph.repo)) {
+  if (!isRecord2(graph.repo)) {
     errors.push("Graph must include repo metadata.");
   }
-  if (!isRecord(graph.scan)) {
+  if (!isRecord2(graph.scan)) {
     errors.push("Graph must include scan metadata.");
   }
   validateGraphCollection(graph, errors, "runtimeAgents", {
     strings: ["id", "name", "kind", "root"],
     arrays: ["entrypointIds", "channelAdapterIds", "artifactIds", "identityNamespaceIds", "deploymentIds", "frameworkIds", "modelProviderIds", "evidence"],
     expected: { kind: "runtime_agent" },
-    confidence: true
+    confidence: true,
+    status: true
   });
   validateGraphCollection(graph, errors, "agentFamilies", {
     strings: ["id", "name"],
@@ -744,7 +1922,8 @@ function validateGraphItemShapes(graph, errors) {
   validateGraphCollection(graph, errors, "artifacts", {
     strings: ["id", "type", "name", "scope"],
     arrays: ["usedByAgentIds", "evidence"],
-    confidence: true
+    confidence: true,
+    status: true
   });
   validateGraphCollection(graph, errors, "developerAgentAdapters", {
     strings: ["id", "name", "kind", "sourcePath"],
@@ -797,7 +1976,7 @@ function validateGraphCollection(graph, errors, field, shape) {
     return;
   for (const [index, item] of collection.entries()) {
     const label = graphItemLabel(field, item, index);
-    if (!isRecord(item)) {
+    if (!isRecord2(item)) {
       errors.push(`Graph ${field} item ${index + 1} must be an object.`);
       continue;
     }
@@ -821,9 +2000,12 @@ function validateGraphCollection(graph, errors, field, shape) {
     } else if (shape.confidence && typeof item.confidence === "number" && (item.confidence < 0 || item.confidence > 1)) {
       errors.push(`Graph ${label} confidence must be between 0 and 1.`);
     }
+    if (shape.status && item.status !== undefined && (typeof item.status !== "string" || !HARNESS_COMPONENT_STATUSES.has(item.status))) {
+      errors.push(`Graph ${label} status must be one of ${[...HARNESS_COMPONENT_STATUSES].join(", ")}.`);
+    }
     if (Array.isArray(item.evidence)) {
       for (const [evidenceIndex, evidence] of item.evidence.entries()) {
-        if (!isRecord(evidence) || typeof evidence.path !== "string" || typeof evidence.reason !== "string") {
+        if (!isRecord2(evidence) || typeof evidence.path !== "string" || typeof evidence.reason !== "string") {
           errors.push(`Graph ${label} evidence ${evidenceIndex + 1} must include path and reason.`);
           continue;
         }
@@ -856,7 +2038,7 @@ function artifactHasRetrievableLocation(item) {
 }
 function validateCaptureQuality(graph, warn) {
   const scan = graph.scan;
-  if (!isRecord(scan))
+  if (!isRecord2(scan))
     return;
   if (scan.truncated === true) {
     const reasons = Array.isArray(scan.truncationReasons) && scan.truncationReasons.length > 0 ? scan.truncationReasons.map((reason) => String(reason)).join(", ") : "scan budget or upload cap reached";
@@ -871,12 +2053,12 @@ function isWholeFileArtifact(item) {
     return false;
   if (!Array.isArray(item.evidence))
     return false;
-  return item.evidence.some((entry) => isRecord(entry) && entry.path === item.sourcePath);
+  return item.evidence.some((entry) => isRecord2(entry) && entry.path === item.sourcePath);
 }
 function hasEvidenceLine(evidence) {
   if (!Array.isArray(evidence))
     return false;
-  return evidence.some((entry) => isRecord(entry) && typeof entry.path === "string" && typeof entry.reason === "string" && evidenceLine({
+  return evidence.some((entry) => isRecord2(entry) && typeof entry.path === "string" && typeof entry.reason === "string" && evidenceLine({
     path: entry.path,
     reason: entry.reason,
     line: typeof entry.line === "number" ? entry.line : undefined
@@ -905,8 +2087,15 @@ var HARNESS_ARTIFACT_TYPES = new Set([
   "unknown"
 ]);
 function normalizeGraphItemFieldAliases(collection, item) {
-  if (!isRecord(item))
+  if (!isRecord2(item))
     return;
+  if ((collection === "runtimeAgents" || collection === "artifacts") && item.status !== undefined) {
+    const status = normalizeComponentStatus(item.status);
+    if (status)
+      item.status = status;
+    else
+      delete item.status;
+  }
   if (collection === "developerAgentAdapters") {
     item.kind = "developer_agent_adapter";
     if (typeof item.sourcePath !== "string")
@@ -975,14 +2164,14 @@ function firstEvidencePath(item) {
   if (!Array.isArray(item.evidence))
     return;
   for (const evidence of item.evidence) {
-    if (isRecord(evidence) && typeof evidence.path === "string" && evidence.path.length > 0) {
+    if (isRecord2(evidence) && typeof evidence.path === "string" && evidence.path.length > 0) {
       return evidence.path;
     }
   }
   return;
 }
 function stampRemoteSnapshotTruncation(report) {
-  const scanRecord = isRecord(report.graph.scan) ? report.graph.scan : {};
+  const scanRecord = isRecord2(report.graph.scan) ? report.graph.scan : {};
   const truncationReasons = Array.isArray(scanRecord.truncationReasons) ? scanRecord.truncationReasons.map(String) : [];
   const stamped = {
     ...report,
@@ -1007,12 +2196,12 @@ function requiresGraphItemConfidence(collection) {
   return collection !== "relationships" && collection !== "unknowns";
 }
 function graphItemLabel(collection, item, index) {
-  if (isRecord(item) && typeof item.id === "string" && item.id.length > 0)
+  if (isRecord2(item) && typeof item.id === "string" && item.id.length > 0)
     return `${collection}.${item.id}`;
   return `${collection} item ${index + 1}`;
 }
 function normalizeConfidenceField(value, fallback) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return;
   const confidence = confidenceNumberFromUnknown(value.confidence);
   if (confidence !== undefined)
@@ -1057,7 +2246,7 @@ function inferClaimKind(subjectId, graph) {
     ];
     for (const [field, kind] of collectionKinds) {
       const collection = graph[field];
-      if (Array.isArray(collection) && collection.some((item) => isRecord(item) && item.id === subjectId)) {
+      if (Array.isArray(collection) && collection.some((item) => isRecord2(item) && item.id === subjectId)) {
         return kind;
       }
     }
@@ -1134,7 +2323,7 @@ function normalizeClaimKind(value, subjectId, graph) {
   return inferred;
 }
 function analystAdapter(report) {
-  const analyst = isRecord(report.analyst) ? report.analyst : {};
+  const analyst = isRecord2(report.analyst) ? report.analyst : {};
   return typeof analyst.adapter === "string" ? analyst.adapter : "external-analyst";
 }
 function defaultHarnessReadPlan() {
@@ -1195,12 +2384,12 @@ function resolveHarnessReportPath(rootDir, value) {
 }
 function writeHarnessReportArtifacts(options) {
   const written = [];
-  writeJson(join(options.rootDir, HARNESS_REPORT_PATH), options.report);
+  writeJson(join3(options.rootDir, HARNESS_REPORT_PATH), options.report);
   written.push(HARNESS_REPORT_PATH);
-  writeJson(join(options.rootDir, HARNESS_REPORT_VALIDATION_PATH), options.validation);
+  writeJson(join3(options.rootDir, HARNESS_REPORT_VALIDATION_PATH), options.validation);
   written.push(HARNESS_REPORT_VALIDATION_PATH);
   if (options.markdown) {
-    const markdownPath = join(options.rootDir, HARNESS_REPORT_MARKDOWN_PATH);
+    const markdownPath = join3(options.rootDir, HARNESS_REPORT_MARKDOWN_PATH);
     mkdirSync(dirname(markdownPath), { recursive: true });
     writeFileSync(markdownPath, renderHarnessReportMarkdown(options.report, options.validation));
     written.push(HARNESS_REPORT_MARKDOWN_PATH);
@@ -1208,7 +2397,7 @@ function writeHarnessReportArtifacts(options) {
   return written;
 }
 function renderHarnessReportMarkdown(report, validation) {
-  const summary = isRecord(report.summary) ? report.summary : {};
+  const summary = isRecord2(report.summary) ? report.summary : {};
   const citations = Array.isArray(report.citations) ? report.citations : [];
   const claims = Array.isArray(report.claims) ? report.claims : [];
   const unknowns = Array.isArray(report.unknowns) ? report.unknowns : [];
@@ -1232,7 +2421,7 @@ function renderHarnessReportMarkdown(report, validation) {
     ""
   ];
   for (const [index, claim] of claims.slice(0, 80).entries()) {
-    const claimRecord = isRecord(claim) ? claim : {};
+    const claimRecord = isRecord2(claim) ? claim : {};
     const citationIds = Array.isArray(claimRecord.citationIds) ? claimRecord.citationIds : [];
     const citedPaths = citationIds.map((id) => citations.find((citation) => citation.id === id)).filter((citation) => Boolean(citation)).map((citation) => `${citation.path ?? citation.id}${citation.line ? `:${citation.line}` : ""}`).join(", ");
     lines.push(`### ${typeof claimRecord.title === "string" ? claimRecord.title : claimLabel(claim, index)}`, "", `- Kind: ${typeof claimRecord.kind === "string" ? claimRecord.kind : "unknown"}`, `- Confidence: ${formatConfidence(claimRecord.confidence)}`, `- Evidence: ${citedPaths || "none"}`, `- Summary: ${typeof claimRecord.summary === "string" ? claimRecord.summary : "unknown"}`, "");
@@ -1243,7 +2432,7 @@ function renderHarnessReportMarkdown(report, validation) {
   if (unknowns.length > 0) {
     lines.push("## Open Questions", "");
     for (const unknown of unknowns) {
-      lines.push(`- ${isRecord(unknown) && typeof unknown.question === "string" ? unknown.question : "Unknown harness question"}`);
+      lines.push(`- ${isRecord2(unknown) && typeof unknown.question === "string" ? unknown.question : "Unknown harness question"}`);
     }
     lines.push("");
   }
@@ -1253,7 +2442,7 @@ function renderHarnessReportMarkdown(report, validation) {
 `;
 }
 function claimLabel(claim, index) {
-  if (isRecord(claim)) {
+  if (isRecord2(claim)) {
     if (typeof claim.id === "string" && claim.id.length > 0)
       return claim.id;
     if (typeof claim.title === "string" && claim.title.length > 0)
@@ -1262,7 +2451,7 @@ function claimLabel(claim, index) {
   return `claim #${index + 1}`;
 }
 function citationLabel(citation, index) {
-  if (isRecord(citation) && typeof citation.id === "string" && citation.id.length > 0)
+  if (isRecord2(citation) && typeof citation.id === "string" && citation.id.length > 0)
     return citation.id;
   return `#${index + 1}`;
 }
@@ -1332,10 +2521,10 @@ function citationExcerpt(rootDir, path, line) {
   if (!isInside(rootDir, absPath) || !existsSync(absPath))
     return {};
   try {
-    const stat = lstatSync(absPath);
+    const stat = lstatSync2(absPath);
     if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 131072)
       return {};
-    const lines = readFileSync(absPath, "utf8").split(/\r?\n/);
+    const lines = readFileSync3(absPath, "utf8").split(/\r?\n/);
     const selected = line ? lines[line - 1] : lines.find((candidate) => candidate.trim().length > 0);
     if (!selected)
       return {};
@@ -1345,13 +2534,13 @@ function citationExcerpt(rootDir, path, line) {
   }
 }
 function validateSummaryMatchesGraph(summary, graph, check) {
-  if (!isRecord(graph))
+  if (!isRecord2(graph))
     return;
   const fields = {
     runtimeAgentCount: safeArrayLength(graph.runtimeAgents),
     agentFamilyCount: safeArrayLength(graph.agentFamilies),
     artifactCount: safeArrayLength(graph.artifacts),
-    sharedArtifactCount: Array.isArray(graph.artifacts) ? graph.artifacts.filter((artifact) => isRecord(artifact) && artifact.scope === "shared").length : 0,
+    sharedArtifactCount: Array.isArray(graph.artifacts) ? graph.artifacts.filter((artifact) => isRecord2(artifact) && artifact.scope === "shared").length : 0,
     channelAdapterCount: safeArrayLength(graph.channelAdapters),
     identityNamespaceCount: safeArrayLength(graph.identityNamespaces),
     environmentCount: safeArrayLength(graph.environments),
@@ -1394,7 +2583,7 @@ function validateClaimSubjectExists(graph, claim, errors, warnings) {
   const collection = graph[collectionName];
   if (!Array.isArray(collection))
     return;
-  if (collection.some((item) => isRecord(item) && item.id === claim.subjectId))
+  if (collection.some((item) => isRecord2(item) && item.id === claim.subjectId))
     return;
   const message = `Claim ${claim.id} subject ${claim.subjectId} is not present in graph.${collectionName}.`;
   if (claim.kind === "unknown")
@@ -1403,7 +2592,7 @@ function validateClaimSubjectExists(graph, claim, errors, warnings) {
     errors.push(message);
 }
 function validateClaimQuality(claims, graph, warn) {
-  const claimRecords = claims.filter(isRecord);
+  const claimRecords = claims.filter(isRecord2);
   if (claimRecords.length === 0)
     return;
   const graphClaimableItems = graph ? safeArrayLength(graph.runtimeAgents) + safeArrayLength(graph.agentFamilies) + safeArrayLength(graph.developerAgentAdapters) + safeArrayLength(graph.artifacts) + safeArrayLength(graph.channelAdapters) + safeArrayLength(graph.identityNamespaces) + safeArrayLength(graph.agentFrameworks) + safeArrayLength(graph.modelProviders) + safeArrayLength(graph.deployments) + safeArrayLength(graph.relationships) : 0;
@@ -1483,7 +2672,7 @@ function validateCitation(citation, rootDir, errors, warnings, options) {
     return;
   }
   try {
-    const stat = lstatSync(absPath);
+    const stat = lstatSync2(absPath);
     if (stat.isSymbolicLink())
       errors.push(`Citation ${citation.id} points to a symlink.`);
     if (stat.isDirectory()) {
@@ -1492,7 +2681,7 @@ function validateCitation(citation, rootDir, errors, warnings, options) {
     }
     if (!stat.isFile())
       errors.push(`Citation ${citation.id} does not point to a file.`);
-    const lines = readFileSync(absPath, "utf8").split(/\r?\n/);
+    const lines = readFileSync3(absPath, "utf8").split(/\r?\n/);
     if (citation.line !== undefined) {
       const lineCount = lines.length;
       if (citation.line < 1 || citation.line > lineCount) {
@@ -1543,7 +2732,7 @@ function isSecretishPath(path) {
   return name === ".env" || name.startsWith(".env.") || name.includes("secret") || name.includes("private-key") || name.endsWith(".pem");
 }
 function isInside(rootDir, absPath) {
-  const rel = relative(resolve(rootDir), resolve(absPath));
+  const rel = relative3(resolve(rootDir), resolve(absPath));
   return rel === "" || !rel.startsWith("..") && !rel.startsWith("/");
 }
 function writeJson(path, value) {
@@ -1569,11 +2758,11 @@ function sortJson(value) {
   }
   return value;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function normalizePath(path) {
   return path.replace(/\\/g, "/");
 }
 
-export { HARNESS_REPORT_SCHEMA_VERSION, HARNESS_REPORT_VALIDATION_SCHEMA_VERSION, HARNESS_REPORT_APPROVAL_SCHEMA_VERSION, HARNESS_REPORT_PATH, HARNESS_REPORT_MARKDOWN_PATH, HARNESS_REPORT_VALIDATION_PATH, HARNESS_REPORT_APPROVAL_PATH, HARNESS_ANALYZE_CONCERNS, MAX_HARNESS_REPORT_SUMMARY_LENGTH, createHarnessReport, validateHarnessReport, approveHarnessReport, loadHarnessReportForSync, readHarnessReport, normalizeHarnessReport, requiresArtifactBody, artifactHasBody, firstEvidencePath, stampRemoteSnapshotTruncation, resolveHarnessReportPath, writeHarnessReportArtifacts, renderHarnessReportMarkdown, hashHarnessReport, hashStableJson, graphForReport };
+export { mergeBoundRuntimeClasses, tagComponentStatus, HARNESS_REPORT_SCHEMA_VERSION, HARNESS_REPORT_VALIDATION_SCHEMA_VERSION, HARNESS_REPORT_APPROVAL_SCHEMA_VERSION, HARNESS_REPORT_PATH, HARNESS_REPORT_MARKDOWN_PATH, HARNESS_REPORT_VALIDATION_PATH, HARNESS_REPORT_APPROVAL_PATH, HARNESS_ANALYZE_CONCERNS, MAX_HARNESS_REPORT_SUMMARY_LENGTH, createHarnessReport, validateHarnessReport, approveHarnessReport, loadHarnessReportForSync, readHarnessReport, normalizeHarnessReport, requiresArtifactBody, artifactHasBody, firstEvidencePath, stampRemoteSnapshotTruncation, resolveHarnessReportPath, writeHarnessReportArtifacts, renderHarnessReportMarkdown, hashHarnessReport, hashStableJson, graphForReport };