tianshu-harness 3.23.0

package/dist/chunk-ZMZCZNKU.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/plan/plan-store.ts
+init_esm_shims();
+import { mkdir, readdir, readFile, stat, writeFile, rm } from "fs/promises";
+import { join } from "path";
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+var PLAN_OPTIONS_FRONTMATTER_RE = /^---\r?\nrivet-options:\s*(\[[\s\S]*?\])\s*\r?\n---\r?\n/;
+var PLAN_STATUS_LINE_RE = /^>\s*\*\*Status:\s*(?:APPROVED|REJECTED|EXECUTED)\*\*.*(?:\r?\n)+/gm;
+function stripPlanStatusMarkers(content) {
+  return content.replace(PLAN_STATUS_LINE_RE, "");
+}
+var PLAN_MODEL_LINE_RE = /^>\s*\*\*Model:\s*(.+?)(?:\s*\((cheap|balanced|strong)\))?\*\*.*(?:\r?\n)+/m;
+function parsePlanModel(content) {
+  const m = content.match(PLAN_MODEL_LINE_RE);
+  if (!m) return void 0;
+  return { model: m[1].trim(), tier: m[2] ?? null };
+}
+function insertPlanModelMarker(content, model, tier) {
+  const stripped = content.replace(new RegExp(PLAN_MODEL_LINE_RE, "gm"), "");
+  const line = `> **Model: ${model}${tier ? ` (${tier})` : ""}**
+
+`;
+  const h1Match = stripped.match(/^#\s+.*$/m);
+  if (h1Match) {
+    const idx = stripped.indexOf(h1Match[0]);
+    return stripped.slice(0, idx) + line + stripped.slice(idx);
+  }
+  return line + stripped;
+}
+var PLANS_DIR = ".rivet/plans";
+function isDraftSlug(slug) {
+  return /^draft-\d+$/.test(slug);
+}
+function plansRoot(cwd) {
+  return join(cwd, PLANS_DIR);
+}
+function planFilePath(cwd, slug) {
+  return join(plansRoot(cwd), `${slug}.md`);
+}
+async function ensurePlansDir(cwd) {
+  const dir = plansRoot(cwd);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+}
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "plan";
+}
+function extractTitle(content) {
+  const m = content.match(/^#\s+(.+)$/m);
+  return m?.[1]?.trim() || "Untitled Plan";
+}
+function parsePlanOptions(content) {
+  const m = content.match(PLAN_OPTIONS_FRONTMATTER_RE);
+  if (!m) return void 0;
+  try {
+    const parsed = JSON.parse(m[1]);
+    if (!Array.isArray(parsed)) return void 0;
+    const options = parsed.filter(
+      (item) => item !== null && typeof item === "object" && typeof item.label === "string" && typeof item.description === "string"
+    );
+    return options.length > 0 ? options : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolvePlanOptionLabel(options, input) {
+  const normalize = (s) => s.trim().toLowerCase();
+  const stripSuffix = (s) => normalize(s).replace(/\s*\([^)]*\)\s*$/, "");
+  const wanted = normalize(input);
+  const exact = options.find((o) => normalize(o.label) === wanted);
+  if (exact) return exact.label;
+  const wantedBare = stripSuffix(input);
+  const bareMatches = options.filter((o) => stripSuffix(o.label) === wantedBare);
+  return bareMatches.length === 1 ? bareMatches[0].label : void 0;
+}
+function stripCopiedTitleSuffix(input) {
+  const idx = input.indexOf(" \u2014 ");
+  return (idx >= 0 ? input.slice(0, idx) : input).trim();
+}
+function resolvePlanRef(plans, input) {
+  const stripped = stripCopiedTitleSuffix(input);
+  const wanted = stripped.toLowerCase();
+  if (!wanted) return { kind: "none" };
+  const exact = plans.find((p) => p.slug.toLowerCase() === wanted);
+  if (exact) return { kind: "match", plan: exact };
+  const wantedSlug = slugify(stripped);
+  const byTitle = plans.filter((p) => slugify(p.title) === wantedSlug);
+  if (byTitle.length === 1) return { kind: "match", plan: byTitle[0] };
+  if (byTitle.length > 1) return { kind: "ambiguous", slugs: byTitle.map((p) => p.slug) };
+  const prefix = plans.filter((p) => p.slug.toLowerCase().startsWith(wanted));
+  if (prefix.length === 1) return { kind: "match", plan: prefix[0] };
+  if (prefix.length > 1) return { kind: "ambiguous", slugs: prefix.map((p) => p.slug) };
+  return { kind: "none" };
+}
+function buildPlanFrontmatter(options) {
+  if (!options || options.length === 0) return "";
+  return `---
+rivet-options: ${JSON.stringify(options)}
+---
+
+`;
+}
+async function writePlan(cwd, slug, content, options) {
+  await ensurePlansDir(cwd);
+  const filePath = planFilePath(cwd, slug);
+  const body = buildPlanFrontmatter(options) + content.replace(PLAN_OPTIONS_FRONTMATTER_RE, "");
+  await writeFile(filePath, body, "utf-8");
+  return `${PLANS_DIR}/${slug}.md`;
+}
+async function readPlan(cwd, slug) {
+  const filePath = planFilePath(cwd, slug);
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const s = await stat(filePath);
+    const status = parsePlanStatus(content);
+    const provenance = parsePlanModel(content);
+    return {
+      slug,
+      title: extractTitle(content),
+      content,
+      path: `${PLANS_DIR}/${slug}.md`,
+      createdAt: s.birthtime,
+      status,
+      options: parsePlanOptions(content),
+      ...provenance ? { model: provenance.model, modelTier: provenance.tier } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function readPlanSync(cwd, slug) {
+  const filePath = planFilePath(cwd, slug);
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const s = statSync(filePath);
+    const provenance = parsePlanModel(content);
+    return {
+      slug,
+      title: extractTitle(content),
+      content,
+      path: `${PLANS_DIR}/${slug}.md`,
+      createdAt: s.birthtime,
+      status: parsePlanStatus(content),
+      options: parsePlanOptions(content),
+      ...provenance ? { model: provenance.model, modelTier: provenance.tier } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function stripPlanChrome(content) {
+  const rawLines = content.split("\n");
+  let start = 0;
+  if (rawLines[0]?.trim() === "---") {
+    const close = rawLines.findIndex((l, i) => i > 0 && l.trim() === "---");
+    if (close > 0) start = close + 1;
+  }
+  const out = [];
+  for (const raw of rawLines.slice(start)) {
+    const t = raw.trim();
+    if (t.startsWith("> **Status:") || t.startsWith("> **Model:")) continue;
+    out.push(raw);
+  }
+  return out;
+}
+async function listPlans(cwd) {
+  const dir = plansRoot(cwd);
+  if (!existsSync(dir)) return [];
+  const entries = await readdir(dir);
+  const plans = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".md")) continue;
+    const slug = entry.replace(/\.md$/, "");
+    if (isDraftSlug(slug)) continue;
+    const plan = await readPlan(cwd, slug);
+    if (plan) plans.push(plan);
+  }
+  return plans.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+}
+function listPlansSync(cwd) {
+  const dir = plansRoot(cwd);
+  if (!existsSync(dir)) return [];
+  const plans = [];
+  for (const entry of readdirSync(dir)) {
+    if (!entry.endsWith(".md")) continue;
+    const slug = entry.replace(/\.md$/, "");
+    if (isDraftSlug(slug)) continue;
+    try {
+      const filePath = planFilePath(cwd, slug);
+      const content = readFileSync(filePath, "utf-8");
+      const s = statSync(filePath);
+      const provenance = parsePlanModel(content);
+      plans.push({
+        slug,
+        title: extractTitle(content),
+        content,
+        path: `${PLANS_DIR}/${slug}.md`,
+        createdAt: s.birthtime,
+        status: parsePlanStatus(content),
+        options: parsePlanOptions(content),
+        ...provenance ? { model: provenance.model, modelTier: provenance.tier } : {}
+      });
+    } catch {
+    }
+  }
+  return plans.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+}
+async function approvePlan(cwd, slug) {
+  return markPlanStatus(cwd, slug, "APPROVED");
+}
+async function rejectPlan(cwd, slug) {
+  return markPlanStatus(cwd, slug, "REJECTED");
+}
+function insertPlanStatusMarker(content, status) {
+  const statusLine = `> **Status: ${status}** \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
+
+`;
+  const h1Match = content.match(/^#\s+.*$/m);
+  if (h1Match) {
+    const idx = content.indexOf(h1Match[0]);
+    return content.slice(0, idx) + statusLine + content.slice(idx);
+  }
+  return statusLine + content;
+}
+async function markPlanStatus(cwd, slug, status) {
+  const plan = await readPlan(cwd, slug);
+  if (!plan) return null;
+  const newContent = insertPlanStatusMarker(plan.content, status);
+  await writePlan(cwd, slug, newContent, plan.options);
+  return readPlan(cwd, slug);
+}
+function parsePlanStatus(content) {
+  if (/Status:\s*EXECUTED/i.test(content)) return "executed";
+  if (/Status:\s*APPROVED/i.test(content)) return "approved";
+  if (/Status:\s*REJECTED/i.test(content)) return "rejected";
+  return "submitted";
+}
+
+export {
+  stripPlanStatusMarkers,
+  insertPlanModelMarker,
+  isDraftSlug,
+  slugify,
+  parsePlanOptions,
+  resolvePlanOptionLabel,
+  stripCopiedTitleSuffix,
+  resolvePlanRef,
+  writePlan,
+  readPlan,
+  readPlanSync,
+  stripPlanChrome,
+  listPlans,
+  listPlansSync,
+  approvePlan,
+  rejectPlan,
+  insertPlanStatusMarker
+};

package/dist/chunk-ZNC5T65N.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/tools/output-markers.ts
+init_esm_shims();
+var BROWSER_NAVIGATED_PREFIX = "\u5DF2\u5BFC\u822A\u81F3";
+var BROWSER_SCREENSHOT_OF_PREFIX = "\u622A\u56FE\u4E8E";
+var COMPUTER_USE_A11Y_TREE_PREFIX = "\u53EF\u8BBF\u95EE\u6027\u6811";
+
+export {
+  BROWSER_NAVIGATED_PREFIX,
+  BROWSER_SCREENSHOT_OF_PREFIX,
+  COMPUTER_USE_A11Y_TREE_PREFIX
+};

package/dist/chunk-ZO3I3A7O.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/verification-attribution.ts
+init_esm_shims();
+function normalizeCommand(command) {
+  return command.trim().replace(/["']/g, "").replace(/\s+/g, " ").toLowerCase();
+}
+function asNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function extractTestFiles(command) {
+  const files = /* @__PURE__ */ new Set();
+  const matches = command.matchAll(/[^\s'"]+\.(?:test|spec)\.(?:ts|tsx|js|jsx|mjs|cjs)/g);
+  for (const match of matches) {
+    const file = match[0]?.trim().replace(/^['"]|['"]$/g, "");
+    if (file) files.add(file);
+  }
+  return [...files].sort();
+}
+function getMetaTargetFiles(meta) {
+  const raw = meta?.targetFiles;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((f) => typeof f === "string" && f.length > 0).sort();
+}
+function runnerFamily(command) {
+  const normalized = normalizeCommand(command);
+  if (normalized.startsWith("run_tests") || normalized.includes("tsx --test") || normalized.includes("node --test")) {
+    return "node-test";
+  }
+  return normalized.split(" ")[0] ?? normalized;
+}
+function isInvocationFailureMeta(status, meta) {
+  if (status !== "failed") return false;
+  return asNumber(meta?.exitCode, 1) !== 0 && asNumber(meta?.passed, 0) === 0 && asNumber(meta?.failed, 1) === 0 && asNumber(meta?.skipped, 0) === 0;
+}
+function eventToVerificationMetadata(event) {
+  const scope = event.meta?.scope === "full" ? "full" : "targeted";
+  const status = event.status ?? "passed";
+  const command = event.command ?? "unknown";
+  const targetFiles = getMetaTargetFiles(event.meta);
+  const resolvedCommand = asString(event.meta?.resolvedCommand);
+  const recommendedCommand = asString(event.meta?.recommendedCommand);
+  const snapshotRef = asString(event.meta?.snapshotRef);
+  const phaseRaw = asString(event.meta?.verificationPhase);
+  const verificationPhase = phaseRaw === "isolated" || phaseRaw === "integration" ? phaseRaw : void 0;
+  const failureKind = asString(event.meta?.failureKind) === "tool_invocation_failure" || isInvocationFailureMeta(status, event.meta) ? "tool_invocation_failure" : asString(event.meta?.failureKind) === "test_failure" ? "test_failure" : void 0;
+  return {
+    command,
+    status,
+    scope,
+    exitCode: asNumber(event.meta?.exitCode, status === "failed" ? 1 : 0),
+    passed: asNumber(event.meta?.passed, status === "passed" ? 1 : 0),
+    failed: asNumber(event.meta?.failed, status === "failed" ? 1 : 0),
+    skipped: asNumber(event.meta?.skipped, 0),
+    durationMs: asNumber(event.meta?.durationMs, 0),
+    ...failureKind ? { failureKind } : {},
+    ...targetFiles.length > 0 ? { targetFiles } : {},
+    ...resolvedCommand ? { resolvedCommand } : {},
+    ...recommendedCommand ? { recommendedCommand } : {},
+    ...snapshotRef ? { snapshotRef } : {},
+    ...verificationPhase ? { verificationPhase } : {}
+  };
+}
+function verificationKey(event) {
+  const command = event.command ?? "unknown";
+  const scope = event.meta?.scope === "full" ? "full" : "targeted";
+  const resolvedCommand = asString(event.meta?.resolvedCommand) ?? "";
+  const metaTargetFiles = getMetaTargetFiles(event.meta);
+  const cmdTargetFiles = extractTestFiles(command);
+  const resolvedTargetFiles = extractTestFiles(resolvedCommand);
+  const targetFiles = metaTargetFiles.length > 0 ? metaTargetFiles : [...cmdTargetFiles, ...resolvedTargetFiles];
+  const uniqueTargetFiles = [...new Set(targetFiles)].sort();
+  if (uniqueTargetFiles.length > 0) {
+    return `tests::${scope}::${runnerFamily(`${command} ${resolvedCommand}`)}::${uniqueTargetFiles.join("|")}`;
+  }
+  return `${normalizeCommand(command)}::${scope}`;
+}
+function getEffectiveVerifications(events, currentSnapshotRef) {
+  const allVerificationEvents = events.filter((e) => e.type === "verification");
+  let staleSnapshotDropped = 0;
+  const verificationEvents = currentSnapshotRef ? allVerificationEvents.filter((e) => {
+    const ref = asString(e.meta?.snapshotRef);
+    if (ref && ref !== currentSnapshotRef) {
+      staleSnapshotDropped++;
+      return false;
+    }
+    return true;
+  }) : allVerificationEvents;
+  const keyMap = /* @__PURE__ */ new Map();
+  let supersededFailures = 0;
+  for (let i = 0; i < verificationEvents.length; i++) {
+    const event = verificationEvents[i];
+    const key = verificationKey(event);
+    const existing = keyMap.get(key);
+    if (existing) {
+      if (existing.event.status === "failed" && event.status === "passed") {
+        supersededFailures++;
+      }
+    }
+    keyMap.set(key, { event, index: i });
+  }
+  const effective = [];
+  for (const { event } of keyMap.values()) {
+    effective.push(eventToVerificationMetadata(event));
+  }
+  return { effective, supersededFailures, totalRawCount: allVerificationEvents.length, staleSnapshotDropped };
+}
+function normalizePathForMatch(p) {
+  return p.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function pathsMatch(a, b) {
+  if (a === b) return true;
+  return a.endsWith(`/${b}`) || b.endsWith(`/${a}`);
+}
+function assessImpactedTestCoverage(impactedTests, verifications, existsFn) {
+  if (impactedTests.length === 0) return { uncovered: [], uncoverable: [] };
+  const passed = verifications.filter((v) => v.status === "passed");
+  if (passed.some((v) => v.scope === "full")) return { uncovered: [], uncoverable: [] };
+  const coveredFiles = [];
+  for (const v of passed) {
+    const targets = v.targetFiles && v.targetFiles.length > 0 ? v.targetFiles : [...extractTestFiles(v.command), ...extractTestFiles(v.resolvedCommand ?? "")];
+    for (const t of targets) coveredFiles.push(normalizePathForMatch(t));
+  }
+  const uncovered = [];
+  const uncoverable = [];
+  for (const test of [...new Set(impactedTests)].sort()) {
+    if (!existsFn(test)) {
+      uncoverable.push(test);
+      continue;
+    }
+    const normalized = normalizePathForMatch(test);
+    if (!coveredFiles.some((c) => pathsMatch(normalized, c))) {
+      uncovered.push(test);
+    }
+  }
+  return { uncovered, uncoverable };
+}
+function isInvocationFailure(result) {
+  return result.status === "failed" && result.exitCode !== 0 && result.passed === 0 && result.failed === 0 && result.skipped === 0;
+}
+function createVerificationAttribution(_opts) {
+  function attribute(result) {
+    if (result.status === "passed") {
+      return {
+        attribution: "verified",
+        isBlocking: false,
+        reason: `Verification passed: ${result.command}`,
+        source: result
+      };
+    }
+    if (result.status === "blocked") {
+      const blockedReason = result.blockedReason;
+      if (blockedReason === "no_test_framework" || blockedReason === "no_tests_found") {
+        const userGuidance = result.userGuidance ?? "\u9879\u76EE\u7F3A\u5C11\u53EF\u81EA\u52A8\u68C0\u6D4B\u7684\u6D4B\u8BD5\u6846\u67B6\u3002";
+        return {
+          attribution: "no_test_infra",
+          isBlocking: false,
+          reason: `Verification infrastructure missing (${blockedReason}): ${result.command}. ${userGuidance}`,
+          source: result
+        };
+      }
+      return {
+        attribution: "external_blocked",
+        isBlocking: false,
+        reason: `Verification blocked by external factors: ${result.command} (exit ${result.exitCode})`,
+        source: result
+      };
+    }
+    if (result.status === "failed") {
+      if (result.verificationPhase === "integration") {
+        return {
+          attribution: "integration_conflict",
+          isBlocking: false,
+          reason: `Integration verification failed on current HEAD: ${result.command} \u2014 ${result.failed} test(s) failed. The owned diff passed in isolation; this is a concurrent-change conflict. Rebase/coordinate before merging; delivery is not blocked.`,
+          source: result
+        };
+      }
+      if (result.failureKind === "tool_invocation_failure" || isInvocationFailure(result)) {
+        return {
+          attribution: "tool_invocation_failure",
+          isBlocking: true,
+          reason: `Verification invocation failed: ${result.command}. No tests were executed; rerun with the repo recommended command.`,
+          source: result
+        };
+      }
+      if (result.scope === "targeted") {
+        return {
+          attribution: "owned_failure",
+          isBlocking: true,
+          reason: `Targeted verification failed: ${result.command} \u2014 ${result.failed} test(s) failed`,
+          source: result
+        };
+      }
+      return {
+        attribution: "unattributed_failure",
+        isBlocking: false,
+        reason: `Full-scope verification failed: ${result.command} \u2014 ${result.failed} test(s) failed. Attribution to owned vs external files is unresolved.`,
+        source: result
+      };
+    }
+    return {
+      attribution: "unverified",
+      isBlocking: true,
+      reason: `Unknown verification status for: ${result.command}`,
+      source: result
+    };
+  }
+  function getAggregateAttribution(results) {
+    if (results.length === 0) {
+      return {
+        attribution: "unverified",
+        isBlocking: true,
+        reason: "No verifications have been run.",
+        source: {
+          command: "(none)",
+          status: "blocked",
+          scope: "full",
+          exitCode: -1,
+          passed: 0,
+          failed: 0,
+          skipped: 0,
+          durationMs: 0
+        }
+      };
+    }
+    const attributions = results.map((r) => attribute(r));
+    const hasOwnedFailure = attributions.some((a) => a.attribution === "owned_failure");
+    if (hasOwnedFailure) {
+      const first = attributions.find((a) => a.attribution === "owned_failure");
+      return {
+        attribution: "owned_failure",
+        isBlocking: true,
+        reason: `Owned verification failure: ${first.source.command}`,
+        source: first.source
+      };
+    }
+    const hasToolInvocationFailure = attributions.some((a) => a.attribution === "tool_invocation_failure");
+    if (hasToolInvocationFailure) {
+      const first = attributions.find((a) => a.attribution === "tool_invocation_failure");
+      return {
+        attribution: "tool_invocation_failure",
+        isBlocking: true,
+        reason: `Verification invocation failure: ${first.source.command}`,
+        source: first.source
+      };
+    }
+    const hasNoTestInfra = attributions.some((a) => a.attribution === "no_test_infra");
+    if (hasNoTestInfra) {
+      const first = attributions.find((a) => a.attribution === "no_test_infra");
+      return {
+        attribution: "no_test_infra",
+        isBlocking: false,
+        reason: `Project test infrastructure missing: ${first.source.command}. ${first.source.userGuidance ?? ""}`,
+        source: first.source
+      };
+    }
+    const hasUnattributedFailure = attributions.some((a) => a.attribution === "unattributed_failure");
+    if (hasUnattributedFailure) {
+      const first = attributions.find((a) => a.attribution === "unattributed_failure");
+      return {
+        attribution: "unattributed_failure",
+        isBlocking: false,
+        reason: `Full-suite verification failed without owned-file attribution: ${first.source.command}. Treat as delivery caveat until diagnosed.`,
+        source: first.source
+      };
+    }
+    const hasExternalBlocked = attributions.some((a) => a.attribution === "external_blocked");
+    if (hasExternalBlocked) {
+      const first = attributions.find((a) => a.attribution === "external_blocked");
+      return {
+        attribution: "external_blocked",
+        isBlocking: false,
+        reason: `Verification blocked by external factors: ${first.source.command}`,
+        source: first.source
+      };
+    }
+    const hasIntegrationConflict = attributions.some((a) => a.attribution === "integration_conflict");
+    if (hasIntegrationConflict) {
+      const first = attributions.find((a) => a.attribution === "integration_conflict");
+      return {
+        attribution: "integration_conflict",
+        isBlocking: false,
+        reason: `Integration conflict on current HEAD: ${first.source.command}. Owned changes passed in isolation; rebase/coordinate before merging. Delivery not blocked.`,
+        source: first.source
+      };
+    }
+    return {
+      attribution: "verified",
+      isBlocking: false,
+      reason: `${results.length} verification(s) passed.`,
+      source: results[0]
+    };
+  }
+  return { attribute, getAggregateAttribution };
+}
+
+export {
+  getEffectiveVerifications,
+  assessImpactedTestCoverage,
+  createVerificationAttribution
+};