@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/guarantees/index/build-guarantee-dependency-graph.js

@@ -1,248 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { validateUiFeatureContracts } from "../features/ui-feature-contract.js";
-import { arrayOrEmpty, diagnostic } from "./guarantee-journey-audit-item.js";
-import { allVerifierRefs, dependencyIdsForGuarantee, readSceneYaml, sceneManifestPathForGuarantee, sceneStateKeys, selectedByFilter, sortGuaranteeEntries, validateFilter } from "./parse-verifier-registry.js";
-function buildGuaranteeDependencyGraph(input) {
-  const valid = input.guarantees.filter((entry) => Boolean(entry.manifest)).sort(sortGuaranteeEntries);
-  const byId = new Map(valid.map((entry) => [entry.manifest.id, entry]));
-  const byJourneyIndex = new Map(valid.flatMap((entry) => entry.manifest.journeyIndex ? [[entry.manifest.journeyIndex, entry]] : []));
-  const selectedIds = new Set(valid.filter((entry) => selectedByFilter(entry.manifest, input.filter)).map((entry) => entry.manifest.id));
-  const includeIds = new Set(selectedIds);
-  const reasonById = /* @__PURE__ */ new Map();
-  const diagnostics = [];
-  const visitInclude = (id, chain) => {
-    const entry = byId.get(id);
-    if (!entry) return;
-    if (chain.includes(id)) {
-      diagnostics.push(diagnostic("error", "guarantee.dependency_cycle", `Guarantee dependency cycle: ${[...chain, id].join(" -> ")}.`, "dependencies", entry.sourcePath));
-      return;
-    }
-    const deps = dependencyIdsForGuarantee({ entry, byId, byJourneyIndex, valid });
-    for (const [depId, reasons] of deps) {
-      for (const reason of reasons) {
-        const existing = reasonById.get(depId) ?? /* @__PURE__ */ new Set();
-        existing.add(reason);
-        reasonById.set(depId, existing);
-      }
-      if (input.includeDependencies !== false && !includeIds.has(depId)) includeIds.add(depId);
-      if (input.includeDependencies !== false) visitInclude(depId, [...chain, id]);
-    }
-  };
-  for (const id of [...selectedIds]) visitInclude(id, []);
-  const included = valid.filter((entry) => includeIds.has(entry.manifest.id));
-  const includedIds = new Set(included.map((entry) => entry.manifest.id));
-  const depMap = /* @__PURE__ */ new Map();
-  const reasonMap = /* @__PURE__ */ new Map();
-  const stateProduces = /* @__PURE__ */ new Map();
-  const stateConsumes = /* @__PURE__ */ new Map();
-  for (const entry of included) {
-    const scenePath = sceneManifestPathForGuarantee(entry);
-    const scene = scenePath && existsSync(scenePath) ? readSceneYaml(scenePath) : null;
-    stateProduces.set(entry.manifest.id, sceneStateKeys(scene, "producesState"));
-    stateConsumes.set(entry.manifest.id, sceneStateKeys(scene, "consumesState"));
-    const deps = dependencyIdsForGuarantee({ entry, byId, byJourneyIndex, valid });
-    const filtered = [...deps.keys()].filter((id) => includedIds.has(id)).sort((a, b) => sortGuaranteeEntries(byId.get(a), byId.get(b)));
-    depMap.set(entry.manifest.id, filtered);
-    const reasons = /* @__PURE__ */ new Set();
-    for (const depId of filtered) for (const reason of arrayOrEmpty(deps.get(depId))) reasons.add(reason);
-    for (const reason of arrayOrEmpty(reasonById.get(entry.manifest.id))) reasons.add(reason);
-    reasonMap.set(entry.manifest.id, reasons);
-  }
-  const producersByStateKey = /* @__PURE__ */ new Map();
-  for (const [id, keys] of stateProduces) {
-    for (const key of keys) {
-      producersByStateKey.set(key, [...arrayOrEmpty(producersByStateKey.get(key)), id]);
-    }
-  }
-  for (const [key, producers] of producersByStateKey) {
-    const unique = [...new Set(producers)];
-    const executionGroups = /* @__PURE__ */ new Map();
-    for (const id of unique) {
-      const executionKey = byId.get(id)?.manifest.scene?.executionKey ?? id;
-      executionGroups.set(executionKey, [...arrayOrEmpty(executionGroups.get(executionKey)), id]);
-    }
-    if (executionGroups.size > 1) {
-      diagnostics.push(diagnostic(
-        "error",
-        "guarantee.state_duplicate_producer",
-        `State key ${key} is produced by multiple execution nodes: ${[...executionGroups.keys()].join(", ")}.`,
-        "journey.producesState",
-        byId.get(unique[0])?.sourcePath
-      ));
-    }
-    producersByStateKey.set(key, [...executionGroups.values()].map((ids) => ids[0]));
-  }
-  for (const [id, keys] of stateConsumes) {
-    for (const key of keys) {
-      const producers = arrayOrEmpty(producersByStateKey.get(key));
-      const producer = producers.length === 1 ? producers[0] : void 0;
-      const producerExecutionKey = producer ? byId.get(producer)?.manifest.scene?.executionKey ?? producer : void 0;
-      const consumerExecutionKey = byId.get(id)?.manifest.scene?.executionKey ?? id;
-      if (producer && producerExecutionKey !== consumerExecutionKey && includedIds.has(producer)) {
-        const deps = arrayOrEmpty(depMap.get(id));
-        if (!deps.includes(producer)) deps.push(producer);
-        depMap.set(id, deps.sort((a, b) => sortGuaranteeEntries(byId.get(a), byId.get(b))));
-        const reasons = reasonMap.get(id) ?? /* @__PURE__ */ new Set();
-        reasons.add("state");
-        reasonMap.set(id, reasons);
-      }
-    }
-  }
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const ordered = [];
-  const visitOrder = (id, chain) => {
-    if (visited.has(id)) return;
-    if (visiting.has(id)) {
-      diagnostics.push(diagnostic("error", "guarantee.dependency_cycle", `Guarantee dependency cycle: ${[...chain, id].join(" -> ")}.`, "dependencies", byId.get(id)?.sourcePath));
-      return;
-    }
-    visiting.add(id);
-    for (const dep of arrayOrEmpty(depMap.get(id))) visitOrder(dep, [...chain, id]);
-    visiting.delete(id);
-    visited.add(id);
-    ordered.push(id);
-  };
-  for (const entry of included) visitOrder(entry.manifest.id, []);
-  const inverse = /* @__PURE__ */ new Map();
-  for (const [id, deps] of depMap) for (const dep of deps) inverse.set(dep, [...arrayOrEmpty(inverse.get(dep)), id]);
-  const depthCache = /* @__PURE__ */ new Map();
-  const depth = (id, chain = []) => {
-    if (depthCache.has(id)) return depthCache.get(id);
-    if (chain.includes(id)) {
-      diagnostics.push(diagnostic("error", "guarantee.dependency_cycle", `Guarantee dependency cycle: ${[...chain, id].join(" -> ")}.`, "dependencies", byId.get(id)?.sourcePath));
-      return 0;
-    }
-    const value = Math.max(0, ...arrayOrEmpty(depMap.get(id)).map((dep) => depth(dep, [...chain, id]) + 1));
-    depthCache.set(id, value);
-    return value;
-  };
-  const meta = /* @__PURE__ */ new Map();
-  for (const [index, id] of ordered.entries()) {
-    meta.set(id, {
-      dependsOn: arrayOrEmpty(depMap.get(id)),
-      dependencyOf: arrayOrEmpty(inverse.get(id)).sort((a, b) => sortGuaranteeEntries(byId.get(a), byId.get(b))),
-      dependencyReason: [...reasonMap.get(id) ?? /* @__PURE__ */ new Set()],
-      dependencyDepth: depth(id),
-      executionOrder: index,
-      producesState: arrayOrEmpty(stateProduces.get(id)),
-      consumesState: arrayOrEmpty(stateConsumes.get(id))
-    });
-  }
-  return { entries: ordered.map((id) => byId.get(id)).filter(Boolean), selectedIds, meta, diagnostics };
-}
-function filterGuarantees(input) {
-  return buildGuaranteeDependencyGraph(input).entries;
-}
-function validateGuaranteeRegistry(input) {
-  const diagnostics = [
-    ...input.guarantees.flatMap((entry) => entry.diagnostics),
-    ...arrayOrEmpty(input.verifierRegistries).flatMap((entry) => entry.diagnostics)
-  ];
-  validateFilter(input.filter, diagnostics);
-  const valid = input.guarantees.filter((entry) => Boolean(entry.manifest));
-  diagnostics.push(...validateUiFeatureContracts({ guarantees: valid }));
-  const ids = /* @__PURE__ */ new Map();
-  const journeyIndexes = /* @__PURE__ */ new Map();
-  const capabilityIds = /* @__PURE__ */ new Map();
-  for (const entry of valid) {
-    const existing = ids.get(entry.manifest.id);
-    if (existing) diagnostics.push(diagnostic("error", "guarantee.duplicate_id", `Duplicate guarantee id "${entry.manifest.id}" also appears at ${existing.relativePath}.`, "id", entry.sourcePath));
-    ids.set(entry.manifest.id, entry);
-    const capabilityId = entry.manifest.catalogContract?.capabilityId;
-    if (capabilityId) {
-      const existingCapability = capabilityIds.get(capabilityId);
-      if (existingCapability) diagnostics.push(diagnostic("error", "guarantee.duplicate_capability_id", `Duplicate capabilityId "${capabilityId}" also appears at ${existingCapability.relativePath}.`, "capabilityId", entry.sourcePath));
-      capabilityIds.set(capabilityId, entry);
-    }
-    if (entry.manifest.journeyIndex) {
-      const existingIndex = journeyIndexes.get(entry.manifest.journeyIndex);
-      if (existingIndex) diagnostics.push(diagnostic("error", "guarantee.duplicate_journey_index", `Duplicate journey index ${entry.manifest.journeyIndex} also appears at ${existingIndex.relativePath}.`, "journeyIndex", entry.sourcePath));
-      journeyIndexes.set(entry.manifest.journeyIndex, entry);
-    }
-  }
-  for (const entry of valid) {
-    for (const dep of arrayOrEmpty(entry.manifest.dependencies.guarantees)) {
-      if (!ids.has(dep)) diagnostics.push(diagnostic("error", "guarantee.missing_dependency", `Missing guarantee dependency "${dep}".`, "dependencies.guarantees", entry.sourcePath));
-    }
-    for (const dep of arrayOrEmpty(entry.manifest.dependencies.journeys)) {
-      if (!journeyIndexes.has(dep)) diagnostics.push(diagnostic("error", "guarantee.missing_journey_dependency", `Missing journey dependency "${dep}".`, "dependencies.journeys", entry.sourcePath));
-    }
-    const replacement = entry.manifest.catalogContract?.supersededBy;
-    if (replacement && !ids.has(replacement)) diagnostics.push(diagnostic("error", "guarantee.missing_replacement", `Missing superseding guarantee "${replacement}".`, "supersededBy", entry.sourcePath));
-    if (replacement && entry.manifest.status !== "deprecated") diagnostics.push(diagnostic("error", "guarantee.replacement_requires_deprecated", "Only deprecated guarantees may declare supersededBy.", "supersededBy", entry.sourcePath));
-    for (const superseded of arrayOrEmpty(entry.manifest.catalogContract?.supersedes)) if (!ids.has(superseded)) diagnostics.push(diagnostic("error", "guarantee.missing_superseded", `Missing superseded guarantee "${superseded}".`, "supersedes", entry.sourcePath));
-  }
-  for (const entry of valid) {
-    for (const dep of arrayOrEmpty(entry.manifest.dependsOnGuarantees)) {
-      const [ownerPackage, ref] = dep.includes(":") ? dep.split(/:(.+)/u).filter(Boolean) : ["", dep];
-      const match = valid.find((candidate) => (!ownerPackage || candidate.manifest.ownerPackage === ownerPackage) && candidate.manifest.status === "active" && (candidate.manifest.id === ref || allVerifierRefs(candidate.manifest).includes(ref)));
-      if (!match) diagnostics.push(diagnostic("error", "guarantee.missing_depends_on_guarantee", `Missing active guarantee dependency "${dep}".`, "dependsOnGuarantees", entry.sourcePath));
-    }
-  }
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const visit = (id, chain) => {
-    if (visited.has(id)) return;
-    if (visiting.has(id)) {
-      diagnostics.push(diagnostic("error", "guarantee.dependency_cycle", `Guarantee dependency cycle: ${[...chain, id].join(" -> ")}.`, "dependencies.guarantees", ids.get(id)?.sourcePath));
-      return;
-    }
-    visiting.add(id);
-    for (const dep of arrayOrEmpty(ids.get(id)?.manifest.dependencies.guarantees)) visit(dep, [...chain, id]);
-    visiting.delete(id);
-    visited.add(id);
-  };
-  for (const id of ids.keys()) visit(id, []);
-  const verifierIds = new Set(arrayOrEmpty(input.verifierRegistries).flatMap((entry) => Object.keys(entry.registry?.verifiers ?? {})));
-  const verifierKinds = new Map(arrayOrEmpty(input.verifierRegistries).flatMap(
-    (registry) => Object.entries(registry.registry?.verifiers ?? {}).map(([id, definition]) => [id, definition.kind])
-  ));
-  const verifierDefinitions = new Map(arrayOrEmpty(input.verifierRegistries).flatMap((registry) => Object.entries(registry.registry?.verifiers ?? {})));
-  for (const entry of valid) {
-    for (const ref of allVerifierRefs(entry.manifest)) {
-      if (ref.startsWith("todo.")) {
-        if (entry.manifest.status === "active") diagnostics.push(diagnostic("error", "guarantee.todo_verifier_active", `Active guarantee cannot use placeholder verifier ref "${ref}".`, "verifierRefs", entry.sourcePath));
-        continue;
-      }
-      if (!verifierIds.has(ref)) {
-        const severity = entry.manifest.status === "active" ? "error" : "warning";
-        diagnostics.push(diagnostic(severity, "guarantee.missing_verifier_ref", `Verifier ref "${ref}" is not defined.`, "verifierRefs", entry.sourcePath));
-      }
-      if ((entry.manifest.gates.includes("release") || entry.manifest.gates.includes("security")) && verifierKinds.get(ref) === "manualEvidence") {
-        diagnostics.push(diagnostic("error", "guarantee.release_manual_evidence", `Release/security guarantee cannot depend on manual evidence verifier "${ref}".`, "verifierRefs", entry.sourcePath));
-      }
-    }
-    if (entry.manifest.catalogContract && entry.manifest.status === "active") {
-      const structured = allVerifierRefs(entry.manifest).some((ref) => verifierDefinitions.get(ref)?.resultSchema === "treeseed.guarantee-verifier-result/v1");
-      if (!structured) diagnostics.push(diagnostic("error", "guarantee.v2_active_structured_verifier_required", "Active v2 guarantees require a structured verifier-result producer.", "verifierRefs", entry.sourcePath));
-    }
-  }
-  const selected = input.filter ? filterGuarantees({ guarantees: input.guarantees, filter: input.filter }).length : void 0;
-  const errors = diagnostics.filter((entry) => entry.severity === "error").length;
-  const warnings = diagnostics.filter((entry) => entry.severity === "warning").length;
-  return {
-    ok: errors === 0,
-    workspaceRoot: resolve(input.workspaceRoot),
-    guarantees: input.guarantees,
-    verifierRegistries: arrayOrEmpty(input.verifierRegistries),
-    diagnostics,
-    counts: {
-      total: input.guarantees.length,
-      valid: valid.length,
-      ...selected !== void 0 ? { selected } : {},
-      errors,
-      warnings
-    }
-  };
-}
-function refs(contract) {
-  return arrayOrEmpty(contract?.verifierRefs);
-}
-export {
-  buildGuaranteeDependencyGraph,
-  filterGuarantees,
-  refs,
-  validateGuaranteeRegistry
-};

package/dist/guarantees/index/export-guarantees-csv.d.ts

@@ -1,110 +0,0 @@
-import { GuaranteeRunStatus, GuaranteeVerifierResolution, GuaranteeVerifierResolutionReport } from './guarantee-journey-audit-item.js';
-import { GuaranteeDiagnostic, GuaranteeFilter, GuaranteeRegistryReport, GuaranteeStatus, LoadedGuarantee, LoadedGuaranteeVerifierRegistry } from './guarantee-schema-version.js';
-export declare function exportGuaranteesCsv(input: {
-    guarantees: LoadedGuarantee[];
-    filter?: GuaranteeFilter;
-}): string;
-export declare function exportGuaranteesJson(input: {
-    registry: GuaranteeRegistryReport;
-    filter?: GuaranteeFilter;
-}): {
-    schemaVersion: string;
-    generatedAt: string;
-    workspaceRoot: string;
-    guarantees: {
-        schemaVersion: import("./guarantee-schema-version.js").GuaranteeSchemaVersion;
-        id: string;
-        journeyIndex?: number;
-        type: string;
-        subtype: string;
-        journey: string;
-        ownerPackage: string;
-        surface?: import("./guarantee-schema-version.js").GuaranteeSurface;
-        summary: string;
-        status: GuaranteeStatus;
-        run?: import("./guarantee-schema-version.js").GuaranteeRunContract;
-        dependencies: import("./guarantee-schema-version.js").GuaranteeDependencies;
-        actors: {
-            allowed: string[];
-            forbidden: string[];
-        };
-        gates: import("./guarantee-schema-version.js").GuaranteeGate[];
-        devices: {
-            required: import("./guarantee-schema-version.js").GuaranteeDevice[];
-            optional?: import("./guarantee-schema-version.js").GuaranteeDevice[];
-        };
-        preconditions: {
-            fixtures?: string[];
-            notes?: string[];
-        };
-        uiFeature?: import("./guarantee-schema-version.js").GuaranteeUiFeatureReference;
-        scene?: import("./guarantee-schema-version.js").GuaranteeSceneContract;
-        api?: import("./guarantee-schema-version.js").GuaranteeApiContract;
-        content?: import("./guarantee-schema-version.js").GuaranteeVerifierContract;
-        audit?: import("./guarantee-schema-version.js").GuaranteeVerifierContract;
-        negativeCases?: import("./guarantee-schema-version.js").GuaranteeNegativeCase[];
-        evidence: {
-            required: string[];
-            optional?: string[];
-        };
-        notes?: string[];
-        dependsOnGuarantees?: string[];
-        catalogContract?: import("../index.js").GuaranteeCatalogContract;
-        sourcePath: string;
-    }[];
-};
-export declare function exportGuaranteesMarkdown(input: {
-    registry: GuaranteeRegistryReport;
-    filter?: GuaranteeFilter;
-}): string;
-export declare function writeGuaranteesExport(input: {
-    workspaceRoot: string;
-    format: 'csv' | 'json' | 'markdown';
-    output: string;
-    filter?: GuaranteeFilter;
-}): {
-    ok: boolean;
-    outputPath: string;
-    registry: GuaranteeRegistryReport;
-};
-export declare function verifierDefinitionsByRef(registries: LoadedGuaranteeVerifierRegistry[]): Map<string, GuaranteeVerifierResolution>;
-export declare function resolveGuaranteeVerifierRefs(input: {
-    refs: string[];
-    verifierRegistries: LoadedGuaranteeVerifierRegistry[];
-    status?: GuaranteeStatus;
-    sourcePath?: string;
-}): GuaranteeVerifierResolutionReport;
-export declare function packageWorkspaceForOwner(ownerPackage: string): string;
-export declare function npmWorkspaceArgs(workspace: string, args: string[]): string[];
-export declare function relativeEvidencePath(workspaceRoot: string, path: string): string;
-export declare function writeCommandEvidence(input: {
-    workspaceRoot: string;
-    outputRoot: string;
-    ref: string;
-    command: string;
-    args: string[];
-    cwd?: string;
-    timeoutSeconds?: number;
-    env?: Record<string, string | undefined>;
-    onProgress?: (message: string, stream?: 'stdout' | 'stderr') => void;
-    validateSuccess?: (result: {
-        stdout: string;
-        stderr: string;
-    }) => string | null;
-}): Promise<{
-    status: GuaranteeRunStatus;
-    summary: string;
-    evidence: string[];
-    diagnostics?: undefined;
-} | {
-    status: GuaranteeRunStatus;
-    summary: string;
-    evidence: string[];
-    diagnostics: GuaranteeDiagnostic[];
-}>;
-export declare function stripAnsi(value: string): string;
-export declare function vitestExecutedAssertionCount(output: string): number;
-export declare function validateVitestVerifierOutput(result: {
-    stdout: string;
-    stderr: string;
-}): "Vitest verifier completed without executing any assertions. Check the verifier testName/testFile; skipped-only or no-match runs are not valid guarantee evidence." | null;

package/dist/guarantees/index/export-guarantees-csv.js

@@ -1,235 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, relative, resolve } from "node:path";
-import { filterGuarantees } from "./build-guarantee-dependency-graph.js";
-import { arrayOrEmpty, diagnostic, slugifyGuaranteeJourney } from "./guarantee-journey-audit-item.js";
-import { discoverGuarantees } from "./parse-verifier-registry.js";
-import { csvEscape } from "./plan-guarantees.js";
-import { evidenceEnvSummary, runVerifierCommand } from "./run-verifier-command.js";
-function exportGuaranteesCsv(input) {
-  const rows = filterGuarantees({ guarantees: input.guarantees, filter: input.filter, includeDependencies: false });
-  const header = [
-    "Guarantee ID",
-    "Journey Index",
-    "Type",
-    "Subtype",
-    "Journey",
-    "Owner Package",
-    "Surface",
-    "Status",
-    "Dependencies",
-    "Actor Roles",
-    "Forbidden Roles",
-    "Device Coverage",
-    "Preconditions",
-    "Scene Manifest",
-    "API Verifier Refs",
-    "Content Verifier Refs",
-    "Audit Verifier Refs",
-    "Negative Cases",
-    "Release Gates",
-    "Evidence Required",
-    "Notes",
-    "Source Path"
-  ];
-  const body = rows.map((entry) => [
-    entry.manifest.id,
-    entry.manifest.journeyIndex ?? "",
-    entry.manifest.type,
-    entry.manifest.subtype,
-    entry.manifest.journey,
-    entry.manifest.ownerPackage,
-    entry.manifest.surface ?? "",
-    entry.manifest.status,
-    [...arrayOrEmpty(entry.manifest.dependencies.guarantees), ...arrayOrEmpty(entry.manifest.dependencies.journeys).map((id) => `journey:${id}`)],
-    entry.manifest.actors.allowed,
-    entry.manifest.actors.forbidden,
-    [...entry.manifest.devices.required, ...arrayOrEmpty(entry.manifest.devices.optional)],
-    [...arrayOrEmpty(entry.manifest.preconditions.fixtures), ...arrayOrEmpty(entry.manifest.preconditions.notes)],
-    entry.manifest.scene?.manifest ?? "",
-    arrayOrEmpty(entry.manifest.api?.verifierRefs),
-    arrayOrEmpty(entry.manifest.content?.verifierRefs),
-    arrayOrEmpty(entry.manifest.audit?.verifierRefs),
-    arrayOrEmpty(entry.manifest.negativeCases).map((negativeCase) => negativeCase.id),
-    entry.manifest.gates,
-    entry.manifest.evidence.required,
-    arrayOrEmpty(entry.manifest.notes),
-    entry.relativePath
-  ]);
-  return [header, ...body].map((row) => row.map(csvEscape).join(",")).join("\n") + "\n";
-}
-function exportGuaranteesJson(input) {
-  return {
-    schemaVersion: "treeseed.guarantees.export/v1",
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    workspaceRoot: input.registry.workspaceRoot,
-    guarantees: filterGuarantees({ guarantees: input.registry.guarantees, filter: input.filter, includeDependencies: false }).map((entry) => ({
-      sourcePath: entry.relativePath,
-      ...entry.manifest
-    }))
-  };
-}
-function exportGuaranteesMarkdown(input) {
-  const rows = filterGuarantees({ guarantees: input.registry.guarantees, filter: input.filter, includeDependencies: false });
-  return [
-    "# TreeSeed Guarantees",
-    "",
-    `Generated from ${rows.length} guarantee manifests.`,
-    "",
-    "| ID | Type | Subtype | Journey | Status | Gates |",
-    "| --- | --- | --- | --- | --- | --- |",
-    ...rows.map((entry) => `| ${entry.manifest.id} | ${entry.manifest.type} | ${entry.manifest.subtype} | ${entry.manifest.journey.replace(/\|/gu, "\\|")} | ${entry.manifest.status} | ${entry.manifest.gates.join(", ")} |`),
-    ""
-  ].join("\n");
-}
-function writeGuaranteesExport(input) {
-  const registry = discoverGuarantees({ workspaceRoot: input.workspaceRoot, filter: input.filter });
-  const outputPath = resolve(input.workspaceRoot, input.output);
-  mkdirSync(dirname(outputPath), { recursive: true });
-  const content = input.format === "csv" ? exportGuaranteesCsv({ guarantees: registry.guarantees, filter: input.filter }) : input.format === "json" ? `${JSON.stringify(exportGuaranteesJson({ registry, filter: input.filter }), null, 2)}
-` : exportGuaranteesMarkdown({ registry, filter: input.filter });
-  writeFileSync(outputPath, content, "utf8");
-  return { ok: registry.ok, outputPath, registry };
-}
-function verifierDefinitionsByRef(registries) {
-  const definitions = /* @__PURE__ */ new Map();
-  for (const registry of registries) {
-    for (const [ref, definition] of Object.entries(registry.registry?.verifiers ?? {})) {
-      definitions.set(ref, {
-        ref,
-        resolved: true,
-        sourcePath: registry.sourcePath,
-        ownerPackage: definition.ownerPackage ?? registry.ownerPackage,
-        definition: { ownerPackage: definition.ownerPackage ?? registry.ownerPackage, ...definition }
-      });
-    }
-  }
-  return definitions;
-}
-function resolveGuaranteeVerifierRefs(input) {
-  const diagnostics = [];
-  const definitions = verifierDefinitionsByRef(input.verifierRegistries);
-  const resolutions = [...new Set(input.refs)].map((ref) => {
-    if (ref.startsWith("todo.")) {
-      const severity2 = input.status === "active" ? "error" : "warning";
-      diagnostics.push(diagnostic(severity2, "guarantee.todo_verifier_ref", `Verifier ref "${ref}" is a placeholder.`, "verifierRefs", input.sourcePath));
-      return { ref, resolved: false };
-    }
-    const resolved = definitions.get(ref);
-    if (resolved) return resolved;
-    const severity = input.status === "active" ? "error" : "warning";
-    diagnostics.push(diagnostic(severity, "guarantee.missing_verifier_ref", `Verifier ref "${ref}" is not defined.`, "verifierRefs", input.sourcePath));
-    return { ref, resolved: false };
-  });
-  return { ok: diagnostics.every((entry) => entry.severity !== "error"), resolutions, diagnostics };
-}
-function packageWorkspaceForOwner(ownerPackage) {
-  if (ownerPackage === "@treeseed/market") return ".";
-  const name = ownerPackage.replace(/^@treeseed\//u, "");
-  return `packages/${name}`;
-}
-function npmWorkspaceArgs(workspace, args) {
-  return workspace === "." ? args : ["-w", workspace, ...args];
-}
-function relativeEvidencePath(workspaceRoot, path) {
-  return relative(resolve(workspaceRoot), resolve(path)).replace(/\\/gu, "/");
-}
-async function writeCommandEvidence(input) {
-  const safeRef = slugifyGuaranteeJourney(input.ref);
-  const evidencePath = resolve(input.outputRoot, "evidence", `${safeRef}.json`);
-  mkdirSync(dirname(evidencePath), { recursive: true });
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const cwd = input.cwd ? resolve(input.workspaceRoot, input.cwd) : resolve(input.workspaceRoot);
-  const renderedCommand = [input.command, ...input.args].join(" ");
-  input.onProgress?.(`[guarantees][verifier] ${input.ref}: running ${renderedCommand}`);
-  try {
-    const result = await runVerifierCommand({
-      command: input.command,
-      args: input.args,
-      cwd,
-      env: input.env ? { ...process.env, ...input.env } : process.env,
-      timeoutMs: Math.max(1, input.timeoutSeconds ?? 300) * 1e3,
-      onProgress: input.onProgress,
-      ref: input.ref
-    });
-    const successError = input.validateSuccess?.(result);
-    if (successError) {
-      throw Object.assign(new Error(successError), { stdout: result.stdout, stderr: result.stderr, code: 1 });
-    }
-    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    writeFileSync(evidencePath, `${JSON.stringify({
-      ref: input.ref,
-      command: input.command,
-      args: input.args,
-      cwd: input.cwd ?? ".",
-      startedAt,
-      completedAt,
-      exitCode: 0,
-      env: evidenceEnvSummary(input.env),
-      stdout: result.stdout,
-      stderr: result.stderr
-    }, null, 2)}
-`, "utf8");
-    input.onProgress?.(`[guarantees][verifier] ${input.ref}: passed`);
-    return {
-      status: "passed",
-      summary: `${input.ref} passed.`,
-      evidence: [relativeEvidencePath(input.workspaceRoot, evidencePath)]
-    };
-  } catch (error) {
-    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const commandError = error;
-    writeFileSync(evidencePath, `${JSON.stringify({
-      ref: input.ref,
-      command: input.command,
-      args: input.args,
-      cwd: input.cwd ?? ".",
-      startedAt,
-      completedAt,
-      exitCode: commandError.code ?? 1,
-      env: evidenceEnvSummary(input.env),
-      stdout: commandError.stdout ?? "",
-      stderr: commandError.stderr ?? "",
-      error: commandError.message
-    }, null, 2)}
-`, "utf8");
-    input.onProgress?.(`[guarantees][verifier] ${input.ref}: failed - ${commandError.message}`, "stderr");
-    return {
-      status: "failed",
-      summary: `${input.ref} failed.`,
-      evidence: [relativeEvidencePath(input.workspaceRoot, evidencePath)],
-      diagnostics: [diagnostic("error", "guarantee.verifier_failed", commandError.message, input.ref)]
-    };
-  }
-}
-function stripAnsi(value) {
-  return value.replace(/\u001B\[[0-9;]*m/gu, "");
-}
-function vitestExecutedAssertionCount(output) {
-  const text = stripAnsi(output).replace(/\r\n/gu, "\n");
-  const testsLine = text.split("\n").find((line) => /^\s*Tests\s+/u.test(line));
-  if (!testsLine) return 0;
-  const passed = [...testsLine.matchAll(/(\d+)\s+passed/gu)].reduce((total, match) => total + Number(match[1] ?? 0), 0);
-  const failed = [...testsLine.matchAll(/(\d+)\s+failed/gu)].reduce((total, match) => total + Number(match[1] ?? 0), 0);
-  return passed + failed;
-}
-function validateVitestVerifierOutput(result) {
-  const output = `${result.stdout}
-${result.stderr}`;
-  if (vitestExecutedAssertionCount(output) > 0) return null;
-  return "Vitest verifier completed without executing any assertions. Check the verifier testName/testFile; skipped-only or no-match runs are not valid guarantee evidence.";
-}
-export {
-  exportGuaranteesCsv,
-  exportGuaranteesJson,
-  exportGuaranteesMarkdown,
-  npmWorkspaceArgs,
-  packageWorkspaceForOwner,
-  relativeEvidencePath,
-  resolveGuaranteeVerifierRefs,
-  stripAnsi,
-  validateVitestVerifierOutput,
-  verifierDefinitionsByRef,
-  vitestExecutedAssertionCount,
-  writeCommandEvidence,
-  writeGuaranteesExport
-};