@martinloop/mcp 0.3.8 → 0.3.9

package/dist/vendor/adapters/core/src/persistence/store.d.ts

@@ -1,89 +0,0 @@
-import type { LoopBudget, LoopRecord, LoopTask, MachineState } from "../../../../contracts/index.js";
-import { type LedgerEvent } from "./ledger.js";
-export interface RunContract {
-    runId: string;
-    workspaceId: string;
-    projectId: string;
-    task: LoopTask;
-    budget: LoopBudget;
-    createdAt: string;
-    metadata?: Record<string, string>;
-}
-export interface AttemptArtifacts {
-    /** Compiled PromptPacket written as compiled-context.json */
-    compiledContext: unknown;
-    /** Structured verification evidence captured from the authoritative MartinLoop verifier (optional) */
-    verification?: unknown;
-    /** Unified diff string from the patch (optional) */
-    diff?: string;
-    /** Raw verifier command output (optional) */
-    verifierOutput?: string;
-    /** Grounding scan result (optional) */
-    groundingScan?: unknown;
-    /** Safety leash artifact captured for a blocked or escalated attempt (optional) */
-    leash?: unknown;
-    /** Patch score artifact captured for Phase 10 patch-truth decisions (optional) */
-    patchScore?: unknown;
-    /** Patch keep/discard/escalate decision artifact (optional) */
-    patchDecision?: unknown;
-    /** Rollback boundary captured before an attempt mutates the repo (optional) */
-    rollbackBoundary?: unknown;
-    /** Rollback restore outcome captured after discard/escalation/failure (optional) */
-    rollbackOutcome?: unknown;
-}
-/**
- * RunStore isolates all filesystem persistence from orchestration logic.
- * runMartin accepts an optional store; when provided, every lifecycle event
- * is durably written before the run proceeds to the next step.
- */
-export interface RunStore {
-    /**
-     * Optional runs root hint for filesystem-backed stores.
-     * Orchestration should prefer this over recomputing the default home store.
-     */
-    runsRoot?: string;
-    /**
-     * Write contract.json for a new run. Called once at run start.
-     * The contract is immutable after this point.
-     */
-    initRun(contract: RunContract): Promise<void>;
-    /**
-     * Overwrite state.json with the current MachineState.
-     * Called on every phase transition.
-     */
-    updateState(runId: string, state: MachineState): Promise<void>;
-    /**
-     * Append one event line to ledger.jsonl. Append-only — never rewrites.
-     */
-    appendLedger(runId: string, event: LedgerEvent): Promise<void>;
-    /**
-     * Write artifacts for a completed attempt to artifacts/attempt-<n>/.
-     */
-    writeAttemptArtifacts(runId: string, attemptIndex: number, artifacts: AttemptArtifacts): Promise<void>;
-    /**
-     * Persist the latest canonical loop record snapshot when the caller has one.
-     * Optional to avoid breaking custom RunStore implementations.
-     */
-    writeLoopRecord?(runId: string, loop: LoopRecord): Promise<void>;
-}
-export declare function resolveRunsRoot(env?: NodeJS.ProcessEnv): string;
-export declare function runDir(runsRoot: string, runId: string): string;
-export declare function artifactDir(runsRoot: string, runId: string, attemptIndex: number): string;
-/**
- * Filesystem-backed RunStore. Writes to:
- *   <runsRoot>/<runId>/contract.json
- *   <runsRoot>/<runId>/state.json
- *   <runsRoot>/<runId>/ledger.jsonl
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/compiled-context.json
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/diff.patch (if diff provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/verifier-output.txt (if provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/grounding-scan.json (if provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/leash.json (if leash provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/patch-score.json (if patchScore provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/patch-decision.json (if patchDecision provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/rollback-boundary.json (if rollbackBoundary provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/rollback-outcome.json (if rollbackOutcome provided)
- */
-export declare function createFileRunStore(options?: {
-    runsRoot?: string;
-}): RunStore;

package/dist/vendor/adapters/core/src/persistence/store.js

@@ -1,125 +0,0 @@
-/// <reference types="node" />
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { writeReceiptIntegrityMaterial } from "./integrity.js";
-// ─── FileRunStore implementation ─────────────────────────────────────────────
-const RUN_INDEX_FILENAME = "run-index.ndjson";
-export function resolveRunsRoot(env = process.env) {
-    return env["MARTIN_RUNS_DIR"]?.trim() ??
-        join(homedir(), ".martin", "runs");
-}
-export function runDir(runsRoot, runId) {
-    return join(runsRoot, runId);
-}
-export function artifactDir(runsRoot, runId, attemptIndex) {
-    return join(runsRoot, runId, "artifacts", `attempt-${String(attemptIndex).padStart(3, "0")}`);
-}
-/**
- * Filesystem-backed RunStore. Writes to:
- *   <runsRoot>/<runId>/contract.json
- *   <runsRoot>/<runId>/state.json
- *   <runsRoot>/<runId>/ledger.jsonl
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/compiled-context.json
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/diff.patch (if diff provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/verifier-output.txt (if provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/grounding-scan.json (if provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/leash.json (if leash provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/patch-score.json (if patchScore provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/patch-decision.json (if patchDecision provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/rollback-boundary.json (if rollbackBoundary provided)
- *   <runsRoot>/<runId>/artifacts/attempt-<n>/rollback-outcome.json (if rollbackOutcome provided)
- */
-export function createFileRunStore(options = {}) {
-    const runsRoot = options.runsRoot ?? resolveRunsRoot();
-    return {
-        runsRoot,
-        async initRun(contract) {
-            const dir = runDir(runsRoot, contract.runId);
-            await mkdir(dir, { recursive: true });
-            await writeJsonFile(join(dir, "contract.json"), contract);
-        },
-        async updateState(runId, state) {
-            const dir = runDir(runsRoot, runId);
-            await mkdir(dir, { recursive: true });
-            await writeJsonFile(join(dir, "state.json"), state);
-        },
-        async appendLedger(runId, event) {
-            const dir = runDir(runsRoot, runId);
-            await mkdir(dir, { recursive: true });
-            await appendFile(join(dir, "ledger.jsonl"), `${JSON.stringify(event)}\n`, "utf8");
-        },
-        async writeAttemptArtifacts(runId, attemptIndex, artifacts) {
-            const dir = artifactDir(runsRoot, runId, attemptIndex);
-            await mkdir(dir, { recursive: true });
-            await writeJsonFile(join(dir, "compiled-context.json"), artifacts.compiledContext);
-            if (artifacts.verification !== undefined) {
-                await writeJsonFile(join(dir, "verification.json"), artifacts.verification);
-            }
-            if (artifacts.diff !== undefined) {
-                await writeFile(join(dir, "diff.patch"), artifacts.diff, "utf8");
-            }
-            if (artifacts.verifierOutput !== undefined) {
-                await writeFile(join(dir, "verifier-output.txt"), artifacts.verifierOutput, "utf8");
-            }
-            if (artifacts.groundingScan !== undefined) {
-                await writeJsonFile(join(dir, "grounding-scan.json"), artifacts.groundingScan);
-            }
-            if (artifacts.leash !== undefined) {
-                await writeJsonFile(join(dir, "leash.json"), artifacts.leash);
-            }
-            if (artifacts.patchScore !== undefined) {
-                await writeJsonFile(join(dir, "patch-score.json"), artifacts.patchScore);
-            }
-            if (artifacts.patchDecision !== undefined) {
-                await writeJsonFile(join(dir, "patch-decision.json"), artifacts.patchDecision);
-            }
-            if (artifacts.rollbackBoundary !== undefined) {
-                await writeJsonFile(join(dir, "rollback-boundary.json"), artifacts.rollbackBoundary);
-            }
-            if (artifacts.rollbackOutcome !== undefined) {
-                await writeJsonFile(join(dir, "rollback-outcome.json"), artifacts.rollbackOutcome);
-            }
-        },
-        async writeLoopRecord(runId, loop) {
-            const dir = runDir(runsRoot, runId);
-            await mkdir(dir, { recursive: true });
-            await writeJsonFile(join(dir, "loop-record.json"), loop);
-            await appendRunIndexRecord(runsRoot, loop);
-            const ledgerRaw = await readFile(join(dir, "ledger.jsonl"), "utf8").catch(() => "");
-            const ledgerEntries = ledgerRaw
-                .split(/\r?\n/u)
-                .map((line) => line.trim())
-                .filter(Boolean)
-                .map((line) => JSON.parse(line));
-            await writeReceiptIntegrityMaterial({
-                runId,
-                runsRoot,
-                loopRecord: loop,
-                ledgerEntries,
-                scope: loop.receiptScope ??
-                    {
-                        ...(loop.task.repoRoot ? { repoRoot: loop.task.repoRoot } : {}),
-                        ...(loop.task.repoRoot ? { workingDirectory: loop.task.repoRoot } : {}),
-                        runsRoot
-                    },
-                signedAt: loop.updatedAt
-            });
-        }
-    };
-}
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-async function writeJsonFile(path, value) {
-    await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-async function appendRunIndexRecord(runsRoot, loop) {
-    const line = JSON.stringify({
-        loopId: loop.loopId,
-        workspaceId: loop.workspaceId,
-        projectId: loop.projectId,
-        status: loop.status,
-        lifecycleState: loop.lifecycleState,
-        updatedAt: loop.updatedAt
-    });
-    await appendFile(join(runsRoot, RUN_INDEX_FILENAME), `${line}\n`, "utf8");
-}

package/dist/vendor/adapters/core/src/persistence/trace-store.d.ts

@@ -1,85 +0,0 @@
-/**
- * Append-Only Trace Store
- *
- * Aggregates run data over time to build institutional memory. Every governed
- * run's routing decision, cost, failure class, and outcome is appended to a
- * local JSONL trace file. Data is NEVER overwritten — only appended.
- *
- * The trace store feeds:
- * - classifyRoute() with historicalDirectSuccessRate from real past runs
- * - Cost prediction models with actual spend data
- * - Failure pattern detection across runs
- * - Team analytics and optimization recommendations
- *
- * Storage: `<runsRoot>/_martin/trace-log.jsonl` (one JSON object per line)
- */
-export interface TraceEntry {
-    /** ISO-8601 timestamp */
-    timestamp: string;
-    /** Unique loop identifier */
-    loopId: string;
-    /** The objective that was governed */
-    objective: string;
-    /** Which engine executed the run */
-    engine: string;
-    /** Route selected by classifyRoute */
-    selectedRoute: "direct" | "manager" | "consensus";
-    /** Route classifier confidence (0-1) */
-    routeConfidence: number;
-    /** Budget allocated (USD) */
-    budgetUsd: number;
-    /** Actual spend (USD) */
-    actualCostUsd: number;
-    /** Pre-work burn percentage */
-    preWorkBurnPct: number;
-    /** Number of attempts */
-    attempts: number;
-    /** Final loop status */
-    status: string;
-    /** Final lifecycle state */
-    lifecycleState: string;
-    /** Failure class of last attempt (if failed) */
-    failureClass?: string;
-    /** Whether verification passed */
-    verificationPassed: boolean;
-    /** Number of files changed */
-    filesChanged: number;
-    /** Working directory (hashed for privacy) */
-    workspaceHash: string;
-}
-export interface TraceAggregation {
-    totalRuns: number;
-    directRuns: number;
-    managerRuns: number;
-    consensusRuns: number;
-    directSuccessRate: number;
-    managerSuccessRate: number;
-    averageCostUsd: number;
-    averagePreWorkBurnPct: number;
-    totalSpendUsd: number;
-    totalSavedUsd: number;
-    topFailureClasses: Array<{
-        failureClass: string;
-        count: number;
-    }>;
-    averageAttemptsPerRun: number;
-    lastUpdated: string;
-}
-/**
- * Append a trace entry to the local trace store. Never overwrites.
- */
-export declare function appendTraceEntry(runsRoot: string, entry: TraceEntry): Promise<void>;
-/**
- * Read all trace entries from the local trace store.
- */
-export declare function readTraceEntries(runsRoot: string): Promise<TraceEntry[]>;
-/**
- * Aggregate trace entries into summary statistics.
- * Used by classifyRoute() to get historicalDirectSuccessRate.
- */
-export declare function aggregateTraces(entries: TraceEntry[]): TraceAggregation;
-/**
- * Get the historical direct success rate for use in route classification.
- * Returns undefined if insufficient data (< 5 runs).
- */
-export declare function getHistoricalDirectSuccessRate(runsRoot: string): Promise<number | undefined>;

package/dist/vendor/adapters/core/src/persistence/trace-store.js

@@ -1,125 +0,0 @@
-/**
- * Append-Only Trace Store
- *
- * Aggregates run data over time to build institutional memory. Every governed
- * run's routing decision, cost, failure class, and outcome is appended to a
- * local JSONL trace file. Data is NEVER overwritten — only appended.
- *
- * The trace store feeds:
- * - classifyRoute() with historicalDirectSuccessRate from real past runs
- * - Cost prediction models with actual spend data
- * - Failure pattern detection across runs
- * - Team analytics and optimization recommendations
- *
- * Storage: `<runsRoot>/_martin/trace-log.jsonl` (one JSON object per line)
- */
-import { appendFile, mkdir, readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-const TRACE_DIRECTORY = "_martin";
-const TRACE_FILENAME = "trace-log.jsonl";
-function resolveTracePath(runsRoot) {
-    return join(resolve(runsRoot), TRACE_DIRECTORY, TRACE_FILENAME);
-}
-/**
- * Append a trace entry to the local trace store. Never overwrites.
- */
-export async function appendTraceEntry(runsRoot, entry) {
-    const tracePath = resolveTracePath(runsRoot);
-    await mkdir(join(resolve(runsRoot), TRACE_DIRECTORY), { recursive: true });
-    const line = JSON.stringify(entry) + "\n";
-    await appendFile(tracePath, line, "utf8");
-}
-/**
- * Read all trace entries from the local trace store.
- */
-export async function readTraceEntries(runsRoot) {
-    const tracePath = resolveTracePath(runsRoot);
-    try {
-        const raw = await readFile(tracePath, "utf8");
-        return raw
-            .split("\n")
-            .filter((line) => line.trim().length > 0)
-            .map((line) => {
-            try {
-                return JSON.parse(line);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter((entry) => entry !== null);
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Aggregate trace entries into summary statistics.
- * Used by classifyRoute() to get historicalDirectSuccessRate.
- */
-export function aggregateTraces(entries) {
-    if (entries.length === 0) {
-        return {
-            totalRuns: 0,
-            directRuns: 0,
-            managerRuns: 0,
-            consensusRuns: 0,
-            directSuccessRate: 0,
-            managerSuccessRate: 0,
-            averageCostUsd: 0,
-            averagePreWorkBurnPct: 0,
-            totalSpendUsd: 0,
-            totalSavedUsd: 0,
-            topFailureClasses: [],
-            averageAttemptsPerRun: 0,
-            lastUpdated: new Date().toISOString()
-        };
-    }
-    const direct = entries.filter((e) => e.selectedRoute === "direct");
-    const manager = entries.filter((e) => e.selectedRoute === "manager");
-    const consensus = entries.filter((e) => e.selectedRoute === "consensus");
-    const directSuccesses = direct.filter((e) => e.status === "completed" && e.verificationPassed);
-    const managerSuccesses = manager.filter((e) => e.status === "completed" && e.verificationPassed);
-    const totalCost = entries.reduce((sum, e) => sum + e.actualCostUsd, 0);
-    const totalBudget = entries.reduce((sum, e) => sum + e.budgetUsd, 0);
-    const totalAttempts = entries.reduce((sum, e) => sum + e.attempts, 0);
-    const totalBurnPct = entries.reduce((sum, e) => sum + e.preWorkBurnPct, 0);
-    // Count failure classes
-    const failureCounts = new Map();
-    for (const entry of entries) {
-        if (entry.failureClass) {
-            failureCounts.set(entry.failureClass, (failureCounts.get(entry.failureClass) ?? 0) + 1);
-        }
-    }
-    const topFailureClasses = [...failureCounts.entries()]
-        .map(([failureClass, count]) => ({ failureClass, count }))
-        .sort((a, b) => b.count - a.count)
-        .slice(0, 10);
-    return {
-        totalRuns: entries.length,
-        directRuns: direct.length,
-        managerRuns: manager.length,
-        consensusRuns: consensus.length,
-        directSuccessRate: direct.length > 0 ? directSuccesses.length / direct.length : 0,
-        managerSuccessRate: manager.length > 0 ? managerSuccesses.length / manager.length : 0,
-        averageCostUsd: Math.round((totalCost / entries.length) * 100) / 100,
-        averagePreWorkBurnPct: Math.round(totalBurnPct / entries.length),
-        totalSpendUsd: Math.round(totalCost * 100) / 100,
-        totalSavedUsd: Math.round((totalBudget - totalCost) * 100) / 100,
-        topFailureClasses,
-        averageAttemptsPerRun: Math.round((totalAttempts / entries.length) * 10) / 10,
-        lastUpdated: entries[entries.length - 1]?.timestamp ?? new Date().toISOString()
-    };
-}
-/**
- * Get the historical direct success rate for use in route classification.
- * Returns undefined if insufficient data (< 5 runs).
- */
-export async function getHistoricalDirectSuccessRate(runsRoot) {
-    const entries = await readTraceEntries(runsRoot);
-    const directRuns = entries.filter((e) => e.selectedRoute === "direct");
-    if (directRuns.length < 5)
-        return undefined;
-    const successes = directRuns.filter((e) => e.status === "completed" && e.verificationPassed);
-    return successes.length / directRuns.length;
-}

package/dist/vendor/adapters/core/src/policy-compiler.d.ts

@@ -1,2 +0,0 @@
-import { type ExecutionPolicy, type ExecutionPolicyCompileInput } from "../../../contracts/index.js";
-export declare function compileExecutionPolicy(input: ExecutionPolicyCompileInput): ExecutionPolicy;

package/dist/vendor/adapters/core/src/policy-compiler.js

@@ -1,195 +0,0 @@
-import { cloneExecutionPolicy } from "../../../contracts/index.js";
-export function compileExecutionPolicy(input) {
-    const provenance = [];
-    const budget = {
-        maxUsd: resolveBudgetField("maxUsd", input, provenance),
-        softLimitUsd: resolveBudgetField("softLimitUsd", input, provenance),
-        maxIterations: resolveBudgetField("maxIterations", input, provenance),
-        maxTokens: resolveBudgetField("maxTokens", input, provenance)
-    };
-    if (budget.softLimitUsd >= budget.maxUsd) {
-        budget.softLimitUsd = Math.round(budget.maxUsd * 0.75 * 100) / 100;
-        provenance.push({
-            field: "budget.softLimitUsd",
-            source: "config",
-            value: String(budget.softLimitUsd)
-        });
-    }
-    const governance = {
-        policyProfile: resolveEnumField({
-            field: "governance.policyProfile",
-            defaultsTo: input.defaults.policyProfile,
-            configValue: input.config?.policyProfile,
-            requestValue: input.request.policyProfile,
-            allowed: ["strict", "balanced", "overnight", "debug"],
-            provenance
-        }),
-        telemetryDestination: resolveEnumField({
-            field: "governance.telemetryDestination",
-            defaultsTo: input.defaults.telemetryDestination,
-            configValue: input.config?.governance?.telemetryDestination,
-            requestValue: input.request.telemetryDestination,
-            allowed: ["local-only", "control-plane"],
-            provenance
-        }),
-        destructiveActionPolicy: resolveEnumField({
-            field: "governance.destructiveActionPolicy",
-            defaultsTo: input.defaults.destructiveActionPolicy,
-            configValue: input.config?.governance?.destructiveActionPolicy,
-            allowed: ["never", "approval", "allowed"],
-            provenance
-        })
-    };
-    const verificationPlan = resolveVerificationPlan(input, provenance);
-    const task = {
-        verificationPlan
-    };
-    if (input.request.mutationMode) {
-        task.mutationMode = input.request.mutationMode;
-        provenance.push({
-            field: "task.mutationMode",
-            source: "request",
-            value: input.request.mutationMode
-        });
-    }
-    if (input.request.repoRoot) {
-        task.repoRoot = input.request.repoRoot;
-        provenance.push({
-            field: "task.repoRoot",
-            source: "request",
-            value: input.request.repoRoot
-        });
-    }
-    if ((input.request.allowedPaths?.length ?? 0) > 0) {
-        const allowedPaths = input.request.allowedPaths ?? [];
-        task.allowedPaths = [...allowedPaths];
-        provenance.push({
-            field: "task.allowedPaths",
-            source: "request",
-            value: allowedPaths.join(", ")
-        });
-    }
-    if ((input.request.deniedPaths?.length ?? 0) > 0) {
-        const deniedPaths = input.request.deniedPaths ?? [];
-        task.deniedPaths = [...deniedPaths];
-        provenance.push({
-            field: "task.deniedPaths",
-            source: "request",
-            value: deniedPaths.join(", ")
-        });
-    }
-    if ((input.request.acceptanceCriteria?.length ?? 0) > 0) {
-        const acceptanceCriteria = input.request.acceptanceCriteria ?? [];
-        task.acceptanceCriteria = [...acceptanceCriteria];
-        provenance.push({
-            field: "task.acceptanceCriteria",
-            source: "request",
-            value: acceptanceCriteria.join(", ")
-        });
-    }
-    if (input.request.approvalPolicy) {
-        task.approvalPolicy = { ...input.request.approvalPolicy };
-        provenance.push({
-            field: "task.approvalPolicy",
-            source: "request",
-            value: JSON.stringify(input.request.approvalPolicy)
-        });
-    }
-    return cloneExecutionPolicy({
-        configPath: input.configPath,
-        budget,
-        governance,
-        task,
-        provenance
-    });
-}
-function resolveBudgetField(field, input, provenance) {
-    if (input.request.budgetOverrides?.[field]) {
-        const value = input.request.budget[field];
-        provenance.push({
-            field: `budget.${String(field)}`,
-            source: "request",
-            value: String(value)
-        });
-        return value;
-    }
-    const configValue = input.config?.budget?.[field];
-    if (typeof configValue === "number" && Number.isFinite(configValue)) {
-        provenance.push({
-            field: `budget.${String(field)}`,
-            source: "config",
-            value: String(configValue)
-        });
-        return configValue;
-    }
-    const value = input.defaults.budget[field];
-    provenance.push({
-        field: `budget.${String(field)}`,
-        source: "default",
-        value: String(value)
-    });
-    return value;
-}
-function resolveVerificationPlan(input, provenance) {
-    const requestVerificationPlan = normalizeStringList(input.request.verificationPlan);
-    if (requestVerificationPlan.length > 0) {
-        provenance.push({
-            field: "task.verificationPlan",
-            source: "request",
-            value: requestVerificationPlan.join(", ")
-        });
-        return requestVerificationPlan;
-    }
-    const configVerificationPlan = normalizeStringList(input.config?.governance?.verifierRules);
-    if (configVerificationPlan.length > 0) {
-        provenance.push({
-            field: "task.verificationPlan",
-            source: "config",
-            value: configVerificationPlan.join(", ")
-        });
-        return configVerificationPlan;
-    }
-    const defaultVerificationPlan = normalizeStringList(input.defaults.verifierRules);
-    provenance.push({
-        field: "task.verificationPlan",
-        source: "default",
-        value: defaultVerificationPlan.join(", ")
-    });
-    return defaultVerificationPlan;
-}
-function resolveEnumField(input) {
-    const normalizedRequest = normalizeEnumCandidate(input.requestValue, input.allowed);
-    if (normalizedRequest) {
-        input.provenance.push({
-            field: input.field,
-            source: "request",
-            value: normalizedRequest
-        });
-        return normalizedRequest;
-    }
-    const normalizedConfig = normalizeEnumCandidate(input.configValue, input.allowed);
-    if (normalizedConfig) {
-        input.provenance.push({
-            field: input.field,
-            source: "config",
-            value: normalizedConfig
-        });
-        return normalizedConfig;
-    }
-    input.provenance.push({
-        field: input.field,
-        source: "default",
-        value: input.defaultsTo
-    });
-    return input.defaultsTo;
-}
-function normalizeEnumCandidate(value, allowed) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return allowed.find((candidate) => candidate === trimmed);
-}
-function normalizeStringList(values) {
-    return (values ?? []).map((value) => value.trim()).filter(Boolean);
-}