@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/workflows/dag/frontend-review-context.js

@@ -4,166 +4,11 @@ import path from "node:path";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "./frontend-worktree-diff.js";
 import { frontendLintAssessmentArtifactSchema } from "./frontend-lint-baseline.js";
-import { deterministicSha256, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, frontendImplementationContractSchema, writeFrontendContractReviewArtifacts, } from "./frontend-implementation-contract.js";
+import { frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
+import { frontendRepairAssessmentSchema } from "./frontend-repair.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
-import { ledgerStatsLine, parseLedgerJson } from "../../task/source-prepare/ledger.js";
-export const FRONTEND_REVIEW_CONTEXT_SCHEMA_ID = "frontend-review-context-v2";
-/**
- * Deterministically assemble the cumulative diff from a task baseline and the
- * current candidate snapshot. Same input always yields the same output:
- * paths are sorted, statuses are derived from a fixed decision table, and both
- * digests use canonical JSON hashing.
- */
-export function assembleCumulativeDiffContext(input) {
-    const baselineByPath = new Map(input.baselineEntries.map((entry) => [entry.path, entry.sha256]));
-    const currentByPath = new Map(input.currentEntries.map((entry) => [entry.path, entry.sha256]));
-    const allPaths = new Set([
-        ...baselineByPath.keys(),
-        ...currentByPath.keys(),
-    ]);
-    const sortedPaths = [...allPaths].sort();
-    const perPath = sortedPaths
-        .map((p) => {
-        const baselineSha256 = baselineByPath.get(p) ?? null;
-        const hasCurrent = currentByPath.has(p);
-        const currentSha256 = hasCurrent
-            ? (currentByPath.get(p) ?? null)
-            : null;
-        let status;
-        if (baselineSha256 === null) {
-            status = currentSha256 === null ? "deleted" : "added";
-        }
-        else if (currentSha256 === null) {
-            status = hasCurrent ? "deleted" : "unchanged";
-        }
-        else {
-            status =
-                currentSha256 === baselineSha256 ? "unchanged" : "modified";
-        }
-        return { path: p, status, baselineSha256, currentSha256 };
-    })
-        // Cumulative diff carries only actual changes. The worktree baseline is
-        // the full repository inventory (git ls-files -co), so an unfiltered
-        // perPath enumerates thousands of unchanged hashes (e.g. 3000+ entries
-        // ≈ 700KB), ballooning the review context and blowing the review node
-        // read budget on a single read. Unchanged entries add no diff evidence.
-        .filter((entry) => entry.status !== "unchanged");
-    const baselineDigest = deterministicSha256([...input.baselineEntries].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
-    const cumulativeDigest = deterministicSha256(perPath);
-    return {
-        schemaId: "frontend-cumulative-diff-context-v1",
-        baselineDigest,
-        perPath,
-        cumulativeDigest,
-        empty: perPath.length === 0,
-    };
-}
-async function sha256File(filePath) {
-    try {
-        const bytes = await readFile(filePath);
-        return createHash("sha256").update(bytes).digest("hex");
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Capture the cumulative diff from the frozen worktree baseline and the
- * run-owned diff gate output. Pure status/digest logic lives in
- * `assembleCumulativeDiffContext`; this wrapper only does IO.
- */
-export async function captureCumulativeDiffContext(input) {
-    const root = path.resolve(input.workspaceRoot);
-    let baselineEntries = [];
-    try {
-        const raw = JSON.parse(await readFile(path.join(input.runDir, "contracts/frontend-worktree-baseline.json"), "utf8"));
-        baselineEntries = (raw.files ?? [])
-            .map((file) => ({ path: file, sha256: raw.hashes?.[file] ?? null }))
-            .filter((entry) => entry.sha256 !== null);
-    }
-    catch {
-        // Missing baseline → empty baseline entries (still deterministic).
-    }
-    const candidatePaths = [
-        ...new Set([...input.diff.changedFiles, ...input.diff.untrackedFiles]),
-    ];
-    const currentEntries = [];
-    for (const file of candidatePaths) {
-        currentEntries.push({
-            path: file,
-            sha256: await sha256File(path.join(root, file)),
-        });
-    }
-    return assembleCumulativeDiffContext({ baselineEntries, currentEntries });
-}
-const TYPED_TO_LEGACY = {
-    approve_review: "pass",
-    request_review_changes: "request-revision",
-};
-function isTypedReviewTerminalVerdict(value) {
-    return value === "approve_review" || value === "request_review_changes";
-}
-function isLegacyReviewVerdict(value) {
-    return value === "pass" || value === "request-revision";
-}
-/**
- * Deterministic, fail-closed equivalence between the typed review terminal
- * verdict(s) observed in the attempt and the legacy JSON verdict.
- *
- * Fail-closed cases (all yield `match: false` with an explicit reason):
- *   - no typed terminal fact;
- *   - more than one typed terminal fact (conflicting);
- *   - an unknown typed terminal kind;
- *   - a missing/illegal legacy JSON verdict.
- */
-export function compareTypedReviewToLegacyJsonVerdict(input) {
-    const kinds = [...input.typedKinds];
-    const legacyVerdict = isLegacyReviewVerdict(input.legacyVerdict ?? "")
-        ? input.legacyVerdict
-        : undefined;
-    if (kinds.length === 0) {
-        return {
-            typedVerdict: undefined,
-            legacyVerdict,
-            match: false,
-            reason: "typed review terminal fact missing",
-        };
-    }
-    if (kinds.length > 1) {
-        return {
-            typedVerdict: undefined,
-            legacyVerdict,
-            match: false,
-            reason: `conflicting typed review terminal facts: ${[...new Set(kinds)].join(",")}`,
-        };
-    }
-    const typedVerdict = kinds[0];
-    if (!isTypedReviewTerminalVerdict(typedVerdict)) {
-        return {
-            typedVerdict: undefined,
-            legacyVerdict,
-            match: false,
-            reason: `unknown typed review terminal fact kind: ${typedVerdict}`,
-        };
-    }
-    if (!legacyVerdict) {
-        return {
-            typedVerdict,
-            legacyVerdict: undefined,
-            match: false,
-            reason: "legacy JSON verdict missing or not pass|request-revision",
-        };
-    }
-    const expected = TYPED_TO_LEGACY[typedVerdict];
-    return {
-        typedVerdict,
-        legacyVerdict,
-        match: expected === legacyVerdict,
-        reason: expected === legacyVerdict
-            ? "typed review verdict matches legacy JSON verdict"
-            : `typed review verdict ${typedVerdict} maps to ${expected} but legacy JSON verdict is ${legacyVerdict}`,
-    };
-}
+import { ledgerStatsLine, parseLedgerJson, } from "../../task/source-prepare/ledger.js";
+export const FRONTEND_REVIEW_CONTEXT_SCHEMA_ID = "frontend-review-context-v1";
 /**
  * review-context 稳定失败枚举（AC-011 / AC-HARD-005）：v2 drift / manifest 失败返回
  * 结构化、可消费的 failure code（稳定枚举 + reason 的 envelope），既有调用方无需字符串
@@ -207,37 +52,6 @@ async function readOptionalLintAssessment(runDir) {
         throw new Error(`frontend review context invalid ${relativePath}`);
     }
 }
-async function readOptionalRepairAssessment(runDir) {
-    const relativePath = "contracts/frontend-repair-assessment.json";
-    try {
-        return JSON.parse(await readFile(path.join(runDir, relativePath), "utf8"));
-    }
-    catch (error) {
-        if (error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT") {
-            return undefined;
-        }
-        throw new Error(`frontend review context invalid ${relativePath}`);
-    }
-}
-/** M8: verify failure ownership facts written by frontend-verify-shell. */
-async function readOptionalVerifyFailure(runDir) {
-    const relativePath = "contracts/frontend-verify-failure.json";
-    try {
-        return JSON.parse(await readFile(path.join(runDir, relativePath), "utf8"));
-    }
-    catch (error) {
-        if (error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT") {
-            return undefined;
-        }
-        throw new Error(`frontend review context invalid ${relativePath}`);
-    }
-}
 function assertReviewEvidence(input) {
     const contract = frontendImplementationContractSchema.safeParse(input.contract);
     if (!contract.success) {
@@ -280,105 +94,47 @@ function assertReviewEvidence(input) {
         trace.mockStrategy !== contract.data.mockApi.strategy) {
         throw new FrontendReviewContextFailure("review-context-verification-unbound", "frontend review context verification trace is not bound to a passing contract");
     }
+    const assessment = frontendRepairAssessmentSchema.safeParse(input.repairAssessment);
+    if (!assessment.success) {
+        throw new FrontendReviewContextFailure("review-context-invalid-contract", "frontend review context invalid repair assessment");
+    }
 }
 export async function runFrontendReviewContextGate(input) {
-    const contractRelativePath = "contracts/frontend-implementation-contract.json";
-    let contractRaw;
-    try {
-        contractRaw = await readFile(path.join(input.runDir, contractRelativePath), "utf8");
-    }
-    catch (error) {
-        throw new FrontendReviewContextFailure("review-context-manifest-missing", `frontend review context missing or invalid ${contractRelativePath}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    let contract;
-    try {
-        contract = JSON.parse(contractRaw);
-    }
-    catch (error) {
-        throw new FrontendReviewContextFailure("review-context-manifest-missing", `frontend review context missing or invalid ${contractRelativePath}: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    const contract = await readRequiredJson(input.runDir, "contracts/frontend-implementation-contract.json");
     const parsedContract = frontendImplementationContractSchema.safeParse(contract);
     if (!parsedContract.success) {
         throw new FrontendReviewContextFailure("review-context-invalid-contract", "frontend review context invalid implementation contract");
     }
-    // Authorized diff surface = deliverable files + every verification-target
-    // file the contract references. The writer legitimately writes VT test
-    // artifacts (behavior verification), and the reviewer must audit their
-    // diffs; scoping this to targets.files alone failed the baseline-overlap
-    // check on app.test.js (r19 extreme smoke).
-    const authorizedChangedPaths = [
-        ...new Set([
-            ...parsedContract.data.targets.files,
-            ...parsedContract.data.verificationTargets.map((target) => target.file),
-        ]),
-    ];
     const diff = await runFrontendWorktreeDiffGate({
         ...input,
-        authorizedChangedPaths,
+        authorizedChangedPaths: parsedContract.data.targets.files,
     });
     const verificationTrace = await readRequiredJson(input.runDir, "contracts/frontend-verification-trace.json");
-    const repairAssessment = await readOptionalRepairAssessment(input.runDir);
-    const verifyFailure = await readOptionalVerifyFailure(input.runDir);
+    const repairAssessment = await readRequiredJson(input.runDir, "contracts/frontend-repair-assessment.json");
     const lintAssessment = await readOptionalLintAssessment(input.runDir);
-    const cumulativeDiff = await captureCumulativeDiffContext({
-        runDir: input.runDir,
-        workspaceRoot: input.workspaceRoot,
-        diff,
-    });
     assertReviewEvidence({ contract, verificationTrace, repairAssessment });
     // Source fidelity ledger 核对（AC-008 / AC-FIDELITY-008）：ledger 缺失/漂移即阻断；
     // 同时把核对清单注入 review-context 供最终 reviewer 机械化核对。
     const sourceFidelity = await buildReviewSourceFidelityChecklist(input, parsedContract.data);
-    const contractReviewArtifacts = await writeFrontendContractReviewArtifacts({
-        runDir: input.runDir,
-        outputDir: "contracts",
-        artifactName: "frontend-implementation-contract.json",
-        canonical: parsedContract.data,
-        canonicalArtifact: {
-            path: path.join(input.runDir, contractRelativePath),
-            sha256: createHash("sha256").update(contractRaw).digest("hex"),
-            bytes: Buffer.byteLength(contractRaw, "utf8"),
-        },
-    });
     const payload = {
-        schemaVersion: 2,
+        schemaVersion: 1,
         schemaId: FRONTEND_REVIEW_CONTEXT_SCHEMA_ID,
-        contractRef: {
-            path: contractRelativePath,
-            schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
-            sha256: contractReviewArtifacts.index.contract.sha256,
-            bytes: contractReviewArtifacts.index.contract.bytes,
-            indexPath: contractReviewArtifacts.index.relativePath,
-            indexSha256: contractReviewArtifacts.index.artifactSha256,
-            capacityDiagnosticPath: contractReviewArtifacts.capacity.relativePath,
-            capacityDiagnosticSha256: contractReviewArtifacts.capacity.artifactSha256,
-            sections: contractReviewArtifacts.index.sections,
-        },
+        contract,
         verificationTrace,
-        ...(repairAssessment ? { repairAssessment } : {}),
-        ...(verifyFailure ? { verifyFailure } : {}),
+        repairAssessment,
         ...(lintAssessment ? { lintAssessment } : {}),
         sourceFidelity,
         diff: {
             schemaId: diff.schemaId,
             patchPath: diff.patchPath,
             patchSha256: diff.patchSha256,
-            reviewSummaryPath: diff.reviewSummaryPath,
-            reviewIndexPath: diff.reviewIndexPath,
             changedFiles: diff.changedFiles,
             untrackedFiles: diff.untrackedFiles,
             empty: diff.empty,
         },
-        cumulativeDiff,
     };
     const artifactPath = await writeDagRunJsonArtifact(input.runDir, "contracts/frontend-review-context.json", payload);
-    return {
-        ok: true,
-        artifactPath,
-        diff,
-        contractRef: payload.contractRef,
-        capacity: contractReviewArtifacts.capacity,
-    };
+    return { ok: true, artifactPath, diff };
 }
 /**
  * 最终 review 核对清单（机械化）：ledger 缺失/漂移、canonical requirement 漏项、
@@ -437,8 +193,6 @@ export function formatFrontendReviewContextStdout(result) {
     return [
         "Frontend review context: pass",
         `Artifact: ${result.artifactPath}`,
-        `Contract index: ${result.contractRef.indexPath}`,
-        `Capacity: ${result.capacity.overallLevel} (${result.capacity.relativePath}, non-blocking)`,
         formatFrontendWorktreeDiffStdout(result.diff),
     ].join("\n");
 }

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

@@ -49,236 +49,15 @@ function symbolEvidenceCandidates(symbol) {
         return [symbol, describeTitle, "describe("];
     return [symbol];
 }
-export function isConfigurationVerificationFile(file) {
+function isConfigurationVerificationFile(file) {
     return /(?:^|\/)(?:package\.json|tsconfig(?:\.[^/]+)?\.json|(?:vite|webpack|rollup|docusaurus)\.config\.[cm]?[jt]s)$/.test(file.replace(/\\/g, "/"));
 }
-function isIdentifierStart(char) {
-    return char !== undefined && /[A-Za-z_$]/.test(char);
-}
-function isIdentifierPart(char) {
-    return char !== undefined && /[A-Za-z0-9_$]/.test(char);
-}
-function readQuotedString(content, start) {
-    const quote = content[start];
-    if (quote !== "'" && quote !== '"' && quote !== "`")
-        return null;
-    let value = "";
-    for (let index = start + 1; index < content.length; index += 1) {
-        const char = content[index];
-        if (char === "\\") {
-            const escaped = content[index + 1];
-            if (escaped === undefined)
-                return null;
-            value += escaped;
-            index += 1;
-            continue;
-        }
-        if (quote === "`" && char === "$" && content[index + 1] === "{") {
-            // Interpolated templates are not literal titles: their runtime value is
-            // not deterministic from source text alone.
-            return null;
-        }
-        if (char === quote)
-            return { end: index + 1, value };
-        value += char;
-    }
-    return null;
-}
-function skipQuotedSource(content, start) {
-    const quote = content[start];
-    for (let index = start + 1; index < content.length; index += 1) {
-        if (content[index] === "\\") {
-            index += 1;
-            continue;
-        }
-        if (content[index] === quote)
-            return index + 1;
-    }
-    return content.length;
-}
-/**
- * Small JS/TS lexer for test-title extraction. It intentionally emits only
- * identifiers, string literals, and punctuation while skipping comments. This
- * prevents prose in comments or ordinary strings from becoming trace evidence
- * without adding a parser as a production dependency.
- */
-function lexFrontendTestSource(content) {
-    const tokens = [];
-    let index = 0;
-    while (index < content.length) {
-        const char = content[index];
-        if (/\s/.test(char ?? "")) {
-            index += 1;
-            continue;
-        }
-        if (char === "/" && content[index + 1] === "/") {
-            index += 2;
-            while (index < content.length && content[index] !== "\n")
-                index += 1;
-            continue;
-        }
-        if (char === "/" && content[index + 1] === "*") {
-            const end = content.indexOf("*/", index + 2);
-            index = end < 0 ? content.length : end + 2;
-            continue;
-        }
-        const quoted = readQuotedString(content, index);
-        if (quoted) {
-            tokens.push({ type: "string", value: quoted.value });
-            index = quoted.end;
-            continue;
-        }
-        if (char === "'" || char === '"' || char === "`") {
-            // Unterminated or interpolated strings are skipped instead of being
-            // tokenized as executable source.
-            index = skipQuotedSource(content, index);
-            continue;
-        }
-        if (isIdentifierStart(char)) {
-            let end = index + 1;
-            while (isIdentifierPart(content[end]))
-                end += 1;
-            tokens.push({ type: "identifier", value: content.slice(index, end) });
-            index = end;
-            continue;
-        }
-        tokens.push({ type: "punctuation", value: char ?? "" });
-        index += 1;
-    }
-    return tokens;
-}
-/** Extract literal titles from real describe/it/test calls in JS/TS source. */
-export function extractFrontendTestTitles(content) {
-    const tokens = lexFrontendTestSource(content);
-    const titles = [];
-    const configurationModifiers = new Set(["each", "runIf", "skipIf"]);
-    function closingParenIndex(openIndex) {
-        let depth = 0;
-        for (let cursor = openIndex; cursor < tokens.length; cursor += 1) {
-            if (tokens[cursor]?.type !== "punctuation")
-                continue;
-            if (tokens[cursor]?.value === "(")
-                depth += 1;
-            if (tokens[cursor]?.value === ")") {
-                depth -= 1;
-                if (depth === 0)
-                    return cursor;
-            }
-        }
-        return null;
-    }
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index];
-        if (token?.type !== "identifier" ||
-            !["describe", "it", "test"].includes(token.value) ||
-            (tokens[index - 1]?.type === "punctuation" &&
-                tokens[index - 1]?.value === ".")) {
-            continue;
-        }
-        let cursor = index + 1;
-        let hasConfigurationModifier = false;
-        while (tokens[cursor]?.type === "punctuation" &&
-            tokens[cursor]?.value === "." &&
-            tokens[cursor + 1]?.type === "identifier") {
-            if (tokens[cursor + 1]?.type === "identifier" &&
-                configurationModifiers.has(tokens[cursor + 1].value)) {
-                hasConfigurationModifier = true;
-            }
-            cursor += 2;
-        }
-        if (tokens[cursor]?.type !== "punctuation" ||
-            tokens[cursor]?.value !== "(") {
-            continue;
-        }
-        if (hasConfigurationModifier) {
-            const close = closingParenIndex(cursor);
-            if (close === null ||
-                tokens[close + 1]?.type !== "punctuation" ||
-                tokens[close + 1]?.value !== "(") {
-                continue;
-            }
-            cursor = close + 1;
-        }
-        if (tokens[cursor + 1]?.type !== "string")
-            continue;
-        titles.push(tokens[cursor + 1].value);
-    }
-    return titles;
-}
-function traceKeyMatchesTitle(traceKey, title) {
-    const escaped = traceKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`(?:^|[^A-Za-z0-9_-])${escaped}(?:$|[^A-Za-z0-9_-])`).test(title);
-}
-function formatObservedTestTitles(titles) {
-    if (titles.length === 0)
-        return "(none)";
-    const limit = 8;
-    const preview = titles
-        .slice(0, limit)
-        .map((title) => title.length > 120 ? `${title.slice(0, 117)}...` : title)
-        .join(" | ");
-    return titles.length > limit
-        ? `${preview} | ... (${titles.length - limit} more)`
-        : preview;
-}
-async function evaluateTargetFileTrace(input) {
-    const fileIssues = await assertFileAndSymbol({
-        workspaceRoot: input.workspaceRoot,
-        file: input.target.file,
-    });
-    if (fileIssues.length || input.target.type === "static") {
-        return { issues: fileIssues };
-    }
-    const absolute = path.resolve(input.workspaceRoot, input.target.file);
-    const content = await readFile(absolute, "utf8");
-    const observedTestTitles = extractFrontendTestTitles(content);
-    if (observedTestTitles.some((title) => traceKeyMatchesTitle(input.target.id, title))) {
-        return { issues: [], observedTestTitles };
-    }
-    const observed = formatObservedTestTitles(observedTestTitles);
-    return {
-        issues: [
-            `trace key not found in test title: ${input.target.id} in ${input.target.file}; observed test titles: ${observed}`,
-        ],
-        observedTestTitles,
-    };
-}
-/**
- * Lightweight writer-boundary check. It validates file existence and stable
- * behavior trace tokens only; frozen commands remain the final trace gate's
- * responsibility after command execution.
- */
-export async function evaluateFrontendWriterTracePreflight(input) {
-    const targets = [];
-    const failures = [];
-    for (const target of input.contract.verificationTargets) {
-        const fileTrace = await evaluateTargetFileTrace({
-            workspaceRoot: input.workspaceRoot,
-            target,
-        });
-        for (const detail of fileTrace.issues) {
-            failures.push({ category: "coverage-gap", targetId: target.id, detail });
-        }
-        targets.push({
-            id: target.id,
-            commandLabel: target.commandLabel,
-            file: target.file,
-            ...(target.symbol ? { symbol: target.symbol } : {}),
-            ...(target.type !== "static" ? { traceKey: target.id } : {}),
-            status: fileTrace.issues.length ? "failed" : "ok",
-            matchedNodeIds: [],
-            issues: fileTrace.issues,
-        });
-    }
-    return { ok: failures.length === 0, targets, failures };
-}
 /**
  * Pure verification-target evaluation shared by the trace gate and the repair
  * assess gate. It derives, for each contract verification target, whether the
  * target bound to frozen evidence (commandLabel owners), and whether the file
- * and stable behavior-target id exist in a real test title. It performs no
- * writes and throws nothing: failures are returned as `hardIssues` plus
- * per-target `status`.
+ * and optional symbol exist in the workspace. It performs no writes and throws
+ * nothing: failures are returned as `hardIssues` plus per-target `status`.
  */
 export async function evaluateVerificationTargets(input) {
     const targets = [];
@@ -296,11 +75,17 @@ export async function evaluateVerificationTargets(input) {
         if (!owners?.length) {
             issues.push(`commandLabel not executed in current-run frozen evidence: ${target.commandLabel}`);
         }
-        const fileTrace = await evaluateTargetFileTrace({
+        const fileIssues = await assertFileAndSymbol({
             workspaceRoot: input.workspaceRoot,
-            target,
+            file: target.file,
+            // Configuration files prove that the command's entrypoint exists;
+            // they do not expose source symbols. LLMs sometimes derive a
+            // filename fragment such as "build" from tsconfig.build.json.
+            symbol: isConfigurationVerificationFile(target.file)
+                ? undefined
+                : target.symbol,
         });
-        issues.push(...fileTrace.issues);
+        issues.push(...fileIssues);
         const status = issues.length ? "failed" : "ok";
         if (issues.length)
             hardIssues.push(...issues.map((i) => `${target.id}: ${i}`));
@@ -309,7 +94,6 @@ export async function evaluateVerificationTargets(input) {
             commandLabel: target.commandLabel,
             file: target.file,
             symbol: target.symbol,
-            ...(target.type !== "static" ? { traceKey: target.id } : {}),
             status,
             matchedNodeIds: owners ?? [],
             issues,
@@ -317,25 +101,6 @@ export async function evaluateVerificationTargets(input) {
     }
     return { targets, hardIssues };
 }
-/**
- * Legacy deterministic symbol resolvability check retained by canonical
- * normalization (`dropUnresolvedVerificationSymbols`). New plan tools do not
- * expose symbol and runtime trace binding uses the stable target id. This
- * helper still handles old `all describe blocks`, `describe('title')`, and
- * slash-delimited labels so existing run artifacts normalize consistently.
- */
-export function verificationSymbolMatchesContent(symbol, content) {
-    if (symbol.trim().toLowerCase() === "all describe blocks")
-        return content.includes("describe(");
-    const symbols = symbol.includes(" / ")
-        ? symbol
-            .split(/[（(]/, 1)[0]
-            .split("/")
-            .map((item) => item.trim())
-            .filter(Boolean)
-        : [symbol];
-    return symbols.every((item) => symbolEvidenceCandidates(item).some((candidate) => content.includes(candidate)));
-}
 async function assertFileAndSymbol(input) {
     const issues = [];
     const absolute = path.resolve(input.workspaceRoot, input.file);
@@ -359,8 +124,18 @@ async function assertFileAndSymbol(input) {
     }
     if (input.symbol) {
         const content = await readFile(absolute, "utf8");
-        if (!verificationSymbolMatchesContent(input.symbol, content)) {
-            issues.push(`symbol not found: ${input.symbol} in ${input.file}`);
+        const symbols = input.symbol.includes(" / ")
+            ? input.symbol
+                .split(/[（(]/, 1)[0]
+                .split("/")
+                .map((symbol) => symbol.trim())
+                .filter(Boolean)
+            : [input.symbol];
+        for (const symbol of symbols) {
+            const matched = symbolEvidenceCandidates(symbol).some((candidate) => content.includes(candidate));
+            if (!matched) {
+                issues.push(`symbol not found: ${symbol} in ${input.file}`);
+            }
         }
     }
     return issues;