@tea-agent/loop-agent 0.13.0-beta.0 → 0.13.0

package/dist/workflows/dag/frontend-repair.js

@@ -0,0 +1,341 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
+export const FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID = "frontend-repair-assessment-v1";
+export const frontendRepairFailureClassSchema = z.enum([
+    "typecheck",
+    "build",
+    "lint",
+    "component-test",
+    "unit-test",
+    "trace",
+    "review",
+    "contract",
+    "path",
+    "dependency",
+    "credential",
+    "deploy",
+    "spec-unclear",
+    "unknown",
+]);
+const REPAIRABLE = new Set([
+    "typecheck",
+    "build",
+    "lint",
+    "component-test",
+    "unit-test",
+    "trace",
+    "review",
+]);
+export function isFrontendRepairable(failureClass) {
+    return REPAIRABLE.has(failureClass);
+}
+export function classifyFrontendFailure(input) {
+    const blob = `${input.nodeId}\n${input.failureCategory ?? ""}\n${input.stdout ?? ""}\n${input.stderr ?? ""}`.toLowerCase();
+    if (input.nodeId.includes("contract") ||
+        blob.includes("contract mismatch") ||
+        blob.includes("source binding")) {
+        return "contract";
+    }
+    if (blob.includes("forbidden") ||
+        blob.includes("write guard") ||
+        blob.includes("write-set") ||
+        blob.includes("writeset")) {
+        return "path";
+    }
+    if (blob.includes("package.json") ||
+        blob.includes("unapproved dependency") ||
+        blob.includes("npm install")) {
+        return "dependency";
+    }
+    if (blob.includes("credential") ||
+        blob.includes("api key") ||
+        blob.includes("secret")) {
+        return "credential";
+    }
+    if (blob.includes("deploy") || blob.includes("production release")) {
+        return "deploy";
+    }
+    if (blob.includes("spec unclear") ||
+        blob.includes("requirement ambiguous") ||
+        blob.includes("needs human")) {
+        return "spec-unclear";
+    }
+    if (input.nodeId.includes("trace") || blob.includes("trace:")) {
+        return "trace";
+    }
+    if (input.nodeId.includes("review")) {
+        return "review";
+    }
+    if (blob.includes("typecheck") ||
+        blob.includes("tsc") ||
+        /error ts\d+/i.test(blob)) {
+        return "typecheck";
+    }
+    if (blob.includes("eslint") || blob.includes("lint")) {
+        return "lint";
+    }
+    if (blob.includes("build") ||
+        blob.includes("vite build") ||
+        blob.includes("next build")) {
+        return "build";
+    }
+    if (blob.includes("testing-library") ||
+        blob.includes("component") ||
+        blob.includes("render(")) {
+        return "component-test";
+    }
+    if (blob.includes("vitest") ||
+        blob.includes("jest") ||
+        blob.includes("npm test") ||
+        input.nodeId.includes("behavior")) {
+        return "unit-test";
+    }
+    if (input.failureCategory === "invalid-output")
+        return "contract";
+    if (input.failureCategory === "write-guard")
+        return "path";
+    return "unknown";
+}
+export const frontendRepairAssessmentSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID),
+    contract: z
+        .object({
+        relativePath: z.string().min(1),
+        schemaId: z.string().min(1),
+    })
+        .strict(),
+    failedNodeIds: z.array(z.string().min(1)),
+    failureClass: frontendRepairFailureClassSchema,
+    eligible: z.boolean(),
+    reason: z.string().min(1),
+    attempt: z.number().int().min(1).max(2),
+    maxAttempts: z.literal(1),
+    allowedRepairWriteSet: z.array(z.string().min(1)),
+    evidenceRefs: z.array(z.string().min(1)),
+    browserStatus: z.literal("not-run"),
+})
+    .strict();
+function nodeHadFailure(record) {
+    if (record.status === "ERROR")
+        return true;
+    if (recordIndicatesCommandFailure(record))
+        return true;
+    const results = record.commandResults ?? [];
+    if (results.some((item) => item.ok === false))
+        return true;
+    return false;
+}
+function normalize(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+export function assertWriteSetSubset(repairWriteSet, implementWriteSet) {
+    for (const entry of repairWriteSet) {
+        const ok = implementWriteSet.some((pattern) => normalize(entry) === normalize(pattern) ||
+            pathMatchesPattern(normalize(entry), pattern) ||
+            pathMatchesPattern(normalize(pattern), entry));
+        // exact equality preferred for generation-time copy
+        if (!implementWriteSet.map(normalize).includes(normalize(entry))) {
+            // allow identical globs only
+            if (!ok || normalize(entry) !== normalize(entry)) {
+                // require exact membership for exclusive writeSet entries
+            }
+        }
+        if (!implementWriteSet.map(normalize).includes(normalize(entry))) {
+            throw new Error(`repair writeSet entry "${entry}" is not ⊆ implement writeSet`);
+        }
+    }
+}
+async function loadImplementWriteSet(runDir, fallback) {
+    if (fallback.length > 0)
+        return fallback;
+    const candidates = ["run.json", "dag.json", "spec.json"];
+    for (const name of candidates) {
+        try {
+            const raw = JSON.parse(await readFile(path.join(runDir, name), "utf8"));
+            const tasks = raw.spec?.tasks ?? raw.tasks ?? [];
+            const implement = tasks.find((task) => task.id === "frontend-implement-pi");
+            if (implement?.writeSet?.length)
+                return implement.writeSet;
+        }
+        catch {
+            // continue
+        }
+    }
+    return fallback;
+}
+export async function runFrontendFailureAssessGate(input) {
+    const attempt = input.attempt ?? 1;
+    const implementWriteSet = await loadImplementWriteSet(input.runDir, input.implementWriteSet ?? []);
+    if (implementWriteSet.length === 0) {
+        throw new Error("assess: implement writeSet unavailable");
+    }
+    const contractRel = "contracts/frontend-implementation-contract.json";
+    const contractPath = path.join(input.runDir, contractRel);
+    let contractSchemaId = FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID;
+    try {
+        const raw = JSON.parse(await readFile(contractPath, "utf8"));
+        const parsed = frontendImplementationContractSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new Error("invalid frontend implementation contract");
+        }
+        contractSchemaId = FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID;
+    }
+    catch {
+        // still allow assessment of failures without contract? fail-closed to contract
+        throw new Error("assess: missing or invalid contracts/frontend-implementation-contract.json");
+    }
+    const candidateNodeIds = [
+        "frontend-static-verify-shell",
+        "frontend-behavior-verify-shell",
+        "frontend-verification-trace-shell",
+        "frontend-static-reverify-shell",
+        "frontend-behavior-reverify-shell",
+        "frontend-verification-retrace-shell",
+    ];
+    const failed = [];
+    for (const nodeId of candidateNodeIds) {
+        const nodePath = path.join(input.runDir, `${nodeId}.json`);
+        try {
+            const record = JSON.parse(await readFile(nodePath, "utf8"));
+            if (nodeHadFailure(record) || recordIndicatesCommandFailure(record)) {
+                failed.push({ nodeId, record });
+            }
+        }
+        catch {
+            // missing optional nodes ok
+        }
+    }
+    assertWriteSetSubset(implementWriteSet, implementWriteSet);
+    if (failed.length === 0) {
+        const assessment = {
+            schemaVersion: 1,
+            schemaId: FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID,
+            contract: {
+                relativePath: contractRel,
+                schemaId: contractSchemaId,
+            },
+            failedNodeIds: [],
+            failureClass: "unknown",
+            eligible: false,
+            reason: "no failed frontend verify/trace nodes in current run",
+            attempt,
+            maxAttempts: 1,
+            allowedRepairWriteSet: [...implementWriteSet],
+            evidenceRefs: [contractRel],
+            browserStatus: "not-run",
+        };
+        await writeAssessment(input.runDir, assessment);
+        return assessment;
+    }
+    const primary = failed[0];
+    const failureClass = classifyFrontendFailure({
+        nodeId: primary.nodeId,
+        failureCategory: primary.record.failureCategory,
+        stdout: primary.record.stdout,
+        stderr: primary.record.stderr,
+    });
+    const eligible = isFrontendRepairable(failureClass) && attempt <= 1;
+    const reason = eligible
+        ? `repairable failureClass=${failureClass} on ${primary.nodeId}`
+        : `non-repairable or ineligible: failureClass=${failureClass} attempt=${attempt}`;
+    const assessment = {
+        schemaVersion: 1,
+        schemaId: FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID,
+        contract: {
+            relativePath: contractRel,
+            schemaId: contractSchemaId,
+        },
+        failedNodeIds: failed.map((item) => item.nodeId),
+        failureClass,
+        eligible,
+        reason,
+        attempt,
+        maxAttempts: 1,
+        allowedRepairWriteSet: [...implementWriteSet],
+        evidenceRefs: [contractRel, ...failed.map((item) => `${item.nodeId}.json`)],
+        browserStatus: "not-run",
+    };
+    await writeAssessment(input.runDir, assessment);
+    return assessment;
+}
+function recordIndicatesCommandFailure(record) {
+    // Prefer explicit commandResults when present
+    if (record.commandResults?.some((item) => item.ok === false))
+        return true;
+    // Node may be FINISHED with nonZeroExitPolicy=record; look for harness markers
+    const stdout = record.stdout ?? "";
+    if (/nonZeroExitPolicy=record/.test(stdout) &&
+        /exitCode=[1-9]/.test(stdout)) {
+        return true;
+    }
+    if (record.failureCategory && record.failureCategory !== "success") {
+        // recorded failures may still be FINISHED
+        if (record.status === "FINISHED") {
+            return (record.failureCategory === "nonzero-exit" ||
+                record.failureCategory === "invalid-output" ||
+                record.failureCategory === "timeout");
+        }
+    }
+    return false;
+}
+async function writeAssessment(runDir, assessment) {
+    const relative = "contracts/frontend-repair-assessment.json";
+    const absolute = path.join(runDir, relative);
+    await mkdir(path.dirname(absolute), { recursive: true });
+    await writeFile(absolute, `${JSON.stringify(assessment, null, 2)}\n`, "utf8");
+    return absolute;
+}
+export async function runFrontendRepairContractGate(input) {
+    const relative = "contracts/frontend-repair-assessment.json";
+    const absolute = path.join(input.runDir, relative);
+    const raw = JSON.parse(await readFile(absolute, "utf8"));
+    const parsed = frontendRepairAssessmentSchema.safeParse(raw);
+    if (!parsed.success) {
+        throw new Error(`repair-contract: invalid assessment: ${parsed.error.issues
+            .map((i) => i.message)
+            .join("; ")}`);
+    }
+    const assessment = parsed.data;
+    const implementWriteSet = await loadImplementWriteSet(input.runDir, input.implementWriteSet ?? []);
+    assertWriteSetSubset(assessment.allowedRepairWriteSet, implementWriteSet.length
+        ? implementWriteSet
+        : assessment.allowedRepairWriteSet);
+    if (assessment.attempt > assessment.maxAttempts) {
+        throw new Error("repair-contract: attempt exceeds maxAttempts");
+    }
+    if (assessment.failedNodeIds.length === 0) {
+        return { ok: true, assessment };
+    }
+    if (!assessment.eligible) {
+        throw new Error(`repair-contract: non-repairable failure (${assessment.failureClass}): ${assessment.reason}`);
+    }
+    if (!isFrontendRepairable(assessment.failureClass)) {
+        throw new Error(`repair-contract: failureClass ${assessment.failureClass} is not repairable`);
+    }
+    return { ok: true, assessment };
+}
+export function formatFrontendFailureAssessStdout(assessment) {
+    return [
+        "Frontend failure assess: ok",
+        `eligible=${assessment.eligible}`,
+        `failureClass=${assessment.failureClass}`,
+        `failedNodeIds=${assessment.failedNodeIds.join(",") || "(none)"}`,
+        `attempt=${assessment.attempt}/${assessment.maxAttempts}`,
+        `reason=${assessment.reason}`,
+        `browser=${assessment.browserStatus}`,
+        `artifact=contracts/frontend-repair-assessment.json`,
+    ].join("\n");
+}
+export function formatFrontendRepairContractStdout(assessment) {
+    return [
+        "Frontend repair contract: pass",
+        `eligible=${assessment.eligible}`,
+        `failureClass=${assessment.failureClass}`,
+        `writeSetSize=${assessment.allowedRepairWriteSet.length}`,
+    ].join("\n");
+}

package/dist/workflows/dag/frontend-risk.js

@@ -0,0 +1,161 @@
+/**
+ * Deterministic frontend-implementation risk classifier (M4).
+ * Pure function: no I/O, no model, no side effects.
+ */
+const HIGH_RISK_PATTERNS = [
+    {
+        id: "new-route",
+        re: /new\s+route|新增路由|createBrowserRouter|add\s+route|新建页面路由/i,
+    },
+    {
+        id: "shared-public-api",
+        re: /public\s+api|shared\s+component|公共组件|破坏性|breaking\s+change/i,
+    },
+    {
+        id: "auth-permission",
+        re: /\bauth\b|\bpermission\b|\brbac\b|登录|权限|\bjwt\b|\bsession\b/i,
+    },
+    {
+        id: "sensitive-action",
+        re: /\bpayment\b|delete\s+account|支付|删除用户|\bdestructive\b/i,
+    },
+    {
+        id: "ssr-boundary",
+        re: /\bssr\b|\brsc\b|server\s+component|use client|getServerSideProps|\bhydration\b|server-client/i,
+    },
+    {
+        id: "new-dependency",
+        re: /new\s+dependency|add\s+dependency|npm\s+install|新增依赖|package\.json/i,
+    },
+    {
+        id: "schema-api-change",
+        re: /\bopenapi\b|graphql\s+schema|api\s+contract|接口变更|schema\s+change/i,
+    },
+    {
+        id: "design-conflict",
+        re: /design\s+conflict|规范冲突|openSpec\s+conflict/i,
+    },
+    {
+        id: "cross-domain-paths",
+        re: /多个领域|cross-module|multiple\s+packages/i,
+    },
+    {
+        id: "new-state-infra",
+        re: /\bredux\b|\bzustand\b|\bpinia\b|\bjotai\b|\brecoil\b|新状态库|state\s+management\s+introduc/i,
+    },
+];
+const SMALL_PATTERNS = [
+    {
+        id: "single-component",
+        re: /single\s+component|单一组件|局部样式|style\s+tweak|css\s+only|文案|copy\s+change/i,
+    },
+    {
+        id: "no-remote",
+        re: /no\s+api|无接口|本地状态|local\s+state\s+only|pure\s+ui/i,
+    },
+];
+function blobOf(input) {
+    return [
+        input.title ?? "",
+        input.requirementMarkdown ?? "",
+        input.constraintMarkdown ?? "",
+        (input.allowedPaths ?? []).join("\n"),
+        input.manifestEvidence ?? "",
+    ].join("\n");
+}
+function pathSpreadScore(paths) {
+    const tops = new Set(paths
+        .map((p) => p.replace(/\\/g, "/").split("/").filter(Boolean)[0] ?? "")
+        .filter(Boolean));
+    return tops.size;
+}
+/**
+ * Classify frontend task risk. High-risk signals always win over small keywords.
+ * supervised / explicit high governance never selects small topology.
+ */
+export function classifyFrontendRisk(input) {
+    const blob = blobOf(input);
+    const signals = [];
+    const rejectedSignals = [];
+    const profile = (input.governanceProfile ?? "").toLowerCase();
+    const supervised = profile === "supervised" ||
+        profile.includes("supervised") ||
+        /\bsupervised\b/i.test(blob);
+    for (const pattern of HIGH_RISK_PATTERNS) {
+        if (pattern.re.test(blob))
+            signals.push(pattern.id);
+    }
+    const paths = input.allowedPaths ?? [];
+    const spread = pathSpreadScore(paths);
+    if (paths.some((p) => /package\.json|pnpm-lock|yarn\.lock|package-lock/.test(p))) {
+        signals.push("new-dependency");
+    }
+    // Explicit multi-domain language only — path count alone is not high-risk
+    if (spread >= 3 &&
+        /\b(多个领域|cross-module|multiple\s+packages)\b/i.test(blob)) {
+        signals.push("cross-domain-paths");
+    }
+    const highRisk = signals.length > 0;
+    const smallHits = [];
+    for (const pattern of SMALL_PATTERNS) {
+        if (pattern.re.test(blob))
+            smallHits.push(pattern.id);
+    }
+    // small only if: no high-risk, paths concentrated, no remote API signals, not supervised
+    const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
+        !/\b(no\s+api|无接口|not-needed)\b/i.test(blob);
+    const concentrated = pathSpreadScore(paths) <= 1 && paths.length <= 4;
+    if (supervised) {
+        rejectedSignals.push(...smallHits.map((id) => `small:${id}:blocked-by-supervised`));
+        return {
+            selectedRisk: highRisk ? "high-risk" : "standard",
+            signals: supervised ? [...signals, "supervised-profile"] : signals,
+            rejectedSignals,
+            reason: highRisk
+                ? `high-risk signals present under supervised: ${signals.join(", ")}`
+                : "supervised profile forces full gates (standard minimum)",
+            forceFullGates: true,
+        };
+    }
+    if (highRisk) {
+        rejectedSignals.push(...smallHits.map((id) => `small:${id}:blocked-by-high-risk`));
+        return {
+            selectedRisk: "high-risk",
+            signals,
+            rejectedSignals,
+            reason: `high-risk signals: ${[...new Set(signals)].join(", ")}`,
+            forceFullGates: true,
+        };
+    }
+    if (smallHits.length > 0 &&
+        concentrated &&
+        !hasApiSignal &&
+        (input.complexity === "small" || smallHits.length >= 1)) {
+        return {
+            selectedRisk: "small",
+            signals: smallHits,
+            rejectedSignals,
+            reason: `small signals without high-risk: ${smallHits.join(", ")}`,
+            forceFullGates: false,
+        };
+    }
+    if (smallHits.length > 0 && (hasApiSignal || !concentrated)) {
+        rejectedSignals.push(...smallHits.map((id) => `small:${id}:blocked-by-${hasApiSignal ? "api-signal" : "path-spread"}`));
+        return {
+            selectedRisk: "standard",
+            signals: smallHits,
+            rejectedSignals,
+            reason: hasApiSignal
+                ? "small keywords present but API/remote signals require standard topology"
+                : "small keywords present but path spread requires standard topology",
+            forceFullGates: false,
+        };
+    }
+    return {
+        selectedRisk: "standard",
+        signals: ["default-standard"],
+        rejectedSignals,
+        reason: "ambiguous or standard frontend work; default standard topology",
+        forceFullGates: false,
+    };
+}

package/dist/workflows/dag/frontend-verification-trace.js

@@ -0,0 +1,190 @@
+import { readFile, stat, writeFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
+export const FRONTEND_VERIFICATION_TRACE_SCHEMA_ID = "frontend-verification-trace-v1";
+async function readJsonFile(filePath) {
+    return JSON.parse(await readFile(filePath, "utf8"));
+}
+function collectCommandLabels(...nodes) {
+    const map = new Map();
+    for (const { nodeId, record } of nodes) {
+        const labels = record.verifyEvidence?.commandLabels ?? [];
+        for (const label of labels) {
+            const owners = map.get(label) ?? [];
+            owners.push(nodeId);
+            map.set(label, owners);
+        }
+    }
+    return map;
+}
+function assertNodeFinished(nodeId, record) {
+    if (record.status !== "FINISHED") {
+        throw new Error(`trace: node ${nodeId} status must be FINISHED (got ${String(record.status)})`);
+    }
+}
+function parseMockStrategyFromAssess(text) {
+    const match = text.match(/^\s*MOCK_STRATEGY:\s*([a-z0-9-]+)\s*$/im);
+    return match?.[1] ?? null;
+}
+async function assertFileAndSymbol(input) {
+    const issues = [];
+    const absolute = path.resolve(input.workspaceRoot, input.file);
+    const relative = path.relative(input.workspaceRoot, absolute);
+    if (relative.startsWith("..") ||
+        path.isAbsolute(relative) ||
+        relative.includes("..")) {
+        issues.push(`unsafe file path: ${input.file}`);
+        return issues;
+    }
+    try {
+        const info = await stat(absolute);
+        if (!info.isFile()) {
+            issues.push(`path is not a file: ${input.file}`);
+            return issues;
+        }
+    }
+    catch {
+        issues.push(`file not found: ${input.file}`);
+        return issues;
+    }
+    if (input.symbol) {
+        const content = await readFile(absolute, "utf8");
+        if (!content.includes(input.symbol)) {
+            issues.push(`symbol not found: ${input.symbol} in ${input.file}`);
+        }
+    }
+    return issues;
+}
+export async function runFrontendVerificationTraceGate(input) {
+    const contractRelative = input.contractRelativePath ??
+        "contracts/frontend-implementation-contract.json";
+    const contractPath = path.join(input.runDir, contractRelative);
+    let contractRaw;
+    try {
+        contractRaw = await readJsonFile(contractPath);
+    }
+    catch {
+        throw new Error(`trace: missing frontend implementation contract at ${contractRelative}`);
+    }
+    const parsed = frontendImplementationContractSchema.safeParse(contractRaw);
+    if (!parsed.success) {
+        throw new Error(`trace: invalid contract: ${parsed.error.issues
+            .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+            .join("; ")}`);
+    }
+    const contract = parsed.data;
+    // Prefer post-repair reverify nodes when present (M3); else initial verify nodes (M2).
+    const staticCandidates = [
+        "frontend-static-reverify-shell",
+        "frontend-static-verify-shell",
+    ];
+    const behaviorCandidates = [
+        "frontend-behavior-reverify-shell",
+        "frontend-behavior-verify-shell",
+    ];
+    async function loadFirstNode(candidates) {
+        const errors = [];
+        for (const nodeId of candidates) {
+            try {
+                const record = (await readJsonFile(path.join(input.runDir, `${nodeId}.json`)));
+                return { nodeId, record };
+            }
+            catch {
+                errors.push(nodeId);
+            }
+        }
+        throw new Error(`trace: missing static/behavior verify node records (tried ${errors.join(", ")})`);
+    }
+    const staticNode = await loadFirstNode(staticCandidates);
+    const behaviorNode = await loadFirstNode(behaviorCandidates);
+    assertNodeFinished(staticNode.nodeId, staticNode.record);
+    assertNodeFinished(behaviorNode.nodeId, behaviorNode.record);
+    const labelOwners = collectCommandLabels({ nodeId: staticNode.nodeId, record: staticNode.record }, { nodeId: behaviorNode.nodeId, record: behaviorNode.record });
+    const assessPath = path.join(input.runDir, "frontend-mock-assess-pi.json");
+    try {
+        const assess = (await readJsonFile(assessPath));
+        const text = assess.assistantText?.trim() || assess.stdout?.trim() || "";
+        const strategy = parseMockStrategyFromAssess(text);
+        if (strategy && strategy !== contract.mockApi.strategy) {
+            throw new Error(`trace: mock strategy mismatch: assess=${strategy} contract=${contract.mockApi.strategy}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.startsWith("trace: mock strategy mismatch")) {
+            throw error;
+        }
+        // assess optional for pure unit fixtures without mock node
+    }
+    const targets = [];
+    const hardIssues = [];
+    for (const target of contract.verificationTargets) {
+        const issues = [];
+        const owners = labelOwners.get(target.commandLabel);
+        if (!owners?.length) {
+            issues.push(`commandLabel not executed in current-run frozen evidence: ${target.commandLabel}`);
+        }
+        const fileIssues = await assertFileAndSymbol({
+            workspaceRoot: input.workspaceRoot,
+            file: target.file,
+            symbol: target.symbol,
+        });
+        issues.push(...fileIssues);
+        const status = issues.length ? "failed" : "ok";
+        if (issues.length)
+            hardIssues.push(...issues.map((i) => `${target.id}: ${i}`));
+        targets.push({
+            id: target.id,
+            commandLabel: target.commandLabel,
+            file: target.file,
+            symbol: target.symbol,
+            status,
+            matchedNodeIds: owners ?? [],
+            issues,
+        });
+    }
+    if (hardIssues.length) {
+        throw new Error(`trace: ${hardIssues.join("; ")}`);
+    }
+    const result = {
+        ok: true,
+        schemaId: FRONTEND_VERIFICATION_TRACE_SCHEMA_ID,
+        contractSchemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
+        browserStatus: "not-run",
+        visualStatus: "not-run",
+        targets,
+        mockStrategy: contract.mockApi.strategy,
+    };
+    if (input.writeArtifact !== false) {
+        const artifactRel = "contracts/frontend-verification-trace.json";
+        const artifactPath = path.join(input.runDir, artifactRel);
+        await mkdir(path.dirname(artifactPath), { recursive: true });
+        await writeFile(artifactPath, `${JSON.stringify({
+            schemaVersion: 1,
+            schemaId: result.schemaId,
+            contractSchemaId: result.contractSchemaId,
+            browserStatus: result.browserStatus,
+            visualStatus: result.visualStatus,
+            mockStrategy: result.mockStrategy,
+            targets: result.targets,
+        }, null, 2)}\n`, "utf8");
+        result.artifactPath = artifactPath;
+    }
+    return result;
+}
+export function formatFrontendVerificationTraceStdout(result) {
+    const lines = [
+        "Frontend verification trace: pass",
+        `Schema: ${result.schemaId}`,
+        `Contract: ${result.contractSchemaId}`,
+        `Mock strategy: ${result.mockStrategy}`,
+        `Browser: ${result.browserStatus}`,
+        `Visual: ${result.visualStatus}`,
+        `Targets: ${result.targets.length}`,
+        ...result.targets.map((target) => `- ${target.id}: ${target.status} label=${JSON.stringify(target.commandLabel)} file=${target.file}`),
+    ];
+    if (result.artifactPath) {
+        lines.push(`Artifact: ${result.artifactPath}`);
+    }
+    return lines.join("\n");
+}