@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.4

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

@@ -2,6 +2,18 @@ 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";
+/**
+ * Shared marker for a project that exposes no usable verification command at
+ * generation time. The marker command runs (and logs not-run honestly), but it
+ * must never count as successful verification evidence: labels carrying this
+ * text are excluded from successful evidence and targets bound to it fail the
+ * trace gate instead of passing it.
+ */
+export const FRONTEND_NO_VERIFICATION_MARKER_TEXT = "No frontend verification command configured";
+export function isFrontendNoVerificationMarkerLabel(label) {
+    return label.includes(FRONTEND_NO_VERIFICATION_MARKER_TEXT);
+}
+export const FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE = `frontend verification unavailable: the only frozen static command is the no-op not-run marker (${FRONTEND_NO_VERIFICATION_MARKER_TEXT}); declare verification commands via task.json --verify or 执行约束.md and regenerate the DAG`;
 async function readJsonFile(filePath) {
     return JSON.parse(await readFile(filePath, "utf8"));
 }
@@ -37,7 +49,7 @@ function symbolEvidenceCandidates(symbol) {
         return [symbol, describeTitle, "describe("];
     return [symbol];
 }
-function isConfigurationVerificationFile(file) {
+export function isConfigurationVerificationFile(file) {
     return /(?:^|\/)(?:package\.json|tsconfig(?:\.[^/]+)?\.json|(?:vite|webpack|rollup|docusaurus)\.config\.[cm]?[jt]s)$/.test(file.replace(/\\/g, "/"));
 }
 /**
@@ -52,7 +64,14 @@ export async function evaluateVerificationTargets(input) {
     const hardIssues = [];
     for (const target of input.contract.verificationTargets) {
         const issues = [];
-        const owners = input.labelOwners.get(target.commandLabel);
+        if (isFrontendNoVerificationMarkerLabel(target.commandLabel)) {
+            // A target bound to the not-run marker has no verification behind it;
+            // passing it would let the run finish green without any check.
+            issues.push(`${target.id}: ${FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE}`);
+        }
+        const owners = isFrontendNoVerificationMarkerLabel(target.commandLabel)
+            ? []
+            : (input.labelOwners.get(target.commandLabel) ?? []);
         if (!owners?.length) {
             issues.push(`commandLabel not executed in current-run frozen evidence: ${target.commandLabel}`);
         }
@@ -82,6 +101,26 @@ export async function evaluateVerificationTargets(input) {
     }
     return { targets, hardIssues };
 }
+/**
+ * Shared deterministic symbol resolvability check used by BOTH the verify
+ * trace gate and the plan-time canonical drop (`dropUnresolvedVerificationSymbols`):
+ * whether `symbol` can be matched inside `content`. Handles `all describe
+ * blocks`, `describe('title')` extraction, and slash-delimited multi-symbol
+ * labels the same way everywhere, so plan-time normalization and the final
+ * trace gate can never disagree.
+ */
+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);
@@ -105,18 +144,8 @@ async function assertFileAndSymbol(input) {
     }
     if (input.symbol) {
         const content = await readFile(absolute, "utf8");
-        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}`);
-            }
+        if (!verificationSymbolMatchesContent(input.symbol, content)) {
+            issues.push(`symbol not found: ${input.symbol} in ${input.file}`);
         }
     }
     return issues;
@@ -189,11 +218,17 @@ export async function runFrontendVerificationTraceGate(input) {
         throw new Error("trace: selected Mock strategy requires successful Mock verification commands");
     }
     if (input.evidence) {
-        if (input.evidence.static.commandLabels.length === 0) {
-            throw new Error("trace: no successful static verification commands in current run");
+        // The no-op not-run marker never counts as successful verification
+        // evidence, even if it executed with exit code 0.
+        const effectiveStaticLabels = input.evidence.static.commandLabels.filter((label) => !isFrontendNoVerificationMarkerLabel(label));
+        const effectiveBehaviorLabels = input.evidence.behavior.commandLabels.filter((label) => !isFrontendNoVerificationMarkerLabel(label));
+        if (effectiveStaticLabels.length === 0) {
+            throw new Error(input.evidence.static.commandLabels.length > 0
+                ? `trace: ${FRONTEND_VERIFICATION_UNAVAILABLE_MESSAGE}`
+                : "trace: no successful static verification commands in current run");
         }
         if (requiresBehaviorVerification &&
-            input.evidence.behavior.commandLabels.length === 0) {
+            effectiveBehaviorLabels.length === 0) {
             throw new Error("trace: no successful behavior verification commands in current run");
         }
     }

package/dist/workflows/dag/frontend-worktree-diff.js

@@ -10,21 +10,52 @@ async function runGit(cwd, args) {
     const result = await runResilientGitCommand({ cwd, args, readOnly: true });
     return { code: result.code, stdout: result.stdout, stderr: result.stderr };
 }
+/**
+ * Ephemeral interpreter/tool caches that writers may create while drafting
+ * tests (kept in sync with `isEphemeralToolCachePath` in
+ * src/executors/shell-write-guard.ts). They are not product evidence: tool
+ * cache writes must neither fail the write guard nor appear in the review
+ * diff as pre-existing changes.
+ */
+export function isEphemeralToolCachePath(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    if (!normalized)
+        return false;
+    if (normalized === ".pytest_cache" ||
+        normalized.startsWith(".pytest_cache/")) {
+        return true;
+    }
+    if (normalized === ".mypy_cache" || normalized.startsWith(".mypy_cache/")) {
+        return true;
+    }
+    if (normalized === ".ruff_cache" || normalized.startsWith(".ruff_cache/")) {
+        return true;
+    }
+    if (normalized === ".playwright-cli" ||
+        normalized.startsWith(".playwright-cli/")) {
+        return true;
+    }
+    if (normalized === ".coverage" || normalized.startsWith(".coverage.")) {
+        return true;
+    }
+    // vite/vitest runtime caches live under node_modules/.vite (e.g.
+    // node_modules/.vite/vitest/results.json). node_modules is the gitignored
+    // dependency tree — tool cache writes there are never a product change.
+    if (normalized.startsWith("node_modules/.vite/")) {
+        return true;
+    }
+    if (/(?:^|\/)__pycache__(?:\/|$)/.test(normalized))
+        return true;
+    if (/\.(?:pyc|pyo)$/.test(normalized))
+        return true;
+    return false;
+}
 function splitLines(text) {
     return text
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter(Boolean);
 }
-function statusPaths(status) {
-    return status
-        .split(/\r?\n/)
-        .map((line) => line.trimEnd())
-        .filter((line) => line.length >= 4)
-        .map((line) => line.slice(3).split(" -> ").at(-1) ?? "")
-        .filter(Boolean)
-        .sort();
-}
 async function sha256File(filePath) {
     try {
         const bytes = await readFile(filePath);
@@ -37,15 +68,26 @@ async function sha256File(filePath) {
 export async function captureFrontendWorktreeBaseline(input) {
     const run = input.dependencies?.runGit ?? runGit;
     const root = path.resolve(input.workspaceRoot);
-    const status = await run(root, [
-        "status",
-        "--porcelain=v1",
-        "--untracked-files=all",
+    // Baseline = the full concrete workspace inventory the writer may touch
+    // (tracked + untracked, gitignored excluded), NOT just currently-changed
+    // files. Using `git status` here made a clean repository baseline-empty
+    // (status has no entries when nothing changed), which wrongly blocked
+    // writer admission with baseline-empty.
+    const ls = await run(root, [
+        "ls-files",
+        "-co",
+        "--exclude-standard",
+        "-z",
     ]);
-    if (status.code !== 0) {
-        throw new Error(`frontend worktree baseline failed: ${status.stderr.trim() || status.stdout.trim()}`);
+    if (ls.code !== 0) {
+        throw new Error(`frontend worktree baseline failed: ${ls.stderr.trim() || ls.stdout.trim()}`);
     }
-    const files = statusPaths(status.stdout);
+    const files = ls.stdout
+        .split("\0")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((file) => !isEphemeralToolCachePath(file))
+        .sort();
     const hashes = {};
     for (const file of files)
         hashes[file] = await sha256File(path.join(root, file));
@@ -112,8 +154,12 @@ export async function runFrontendWorktreeDiffGate(input) {
     if (untracked.code !== 0) {
         throw new Error(`frontend worktree diff gate ls-files failed: ${untracked.stderr.trim() || untracked.stdout.trim()}`);
     }
-    const changedFilesAll = splitLines(nameOnly.stdout).sort();
-    const untrackedFilesAll = splitLines(untracked.stdout).sort();
+    const changedFilesAll = splitLines(nameOnly.stdout)
+        .filter((file) => !isEphemeralToolCachePath(file))
+        .sort();
+    const untrackedFilesAll = splitLines(untracked.stdout)
+        .filter((file) => !isEphemeralToolCachePath(file))
+        .sort();
     const authorizedChangedPaths = input.authorizedChangedPaths ?? [];
     if (baseline) {
         for (const file of baseline.files) {
@@ -199,3 +245,36 @@ export function formatFrontendWorktreeDiffStdout(result) {
         .filter(Boolean)
         .join("\n");
 }
+/**
+ * Expand glob-shaped contract paths into concrete workspace file paths.
+ *
+ * The frontend contract schema allows `targets.files` entries such as
+ * `src/**` (skeleton inherits the task allowedPaths), but writer admission
+ * derives the concrete writeSet and requires real file paths. This helper
+ * matches every candidate against the enumerated workspace files and returns
+ * the concrete paths. Candidates that are already concrete are kept as-is;
+ * globs that match nothing are dropped (the derived writeSet only contains
+ * paths the writer can actually touch).
+ */
+export function expandFrontendGlobPaths(input) {
+    const concrete = new Set();
+    const patterns = [];
+    for (const candidate of input.candidates) {
+        const normalized = candidate.replace(/\\/g, "/");
+        if (normalized.includes("*")) {
+            patterns.push(normalized);
+        }
+        else {
+            concrete.add(normalized);
+        }
+    }
+    if (patterns.length === 0)
+        return [...concrete].sort();
+    const workspace = [...new Set(input.workspaceFiles.map((f) => f.replace(/\\/g, "/")))];
+    for (const file of workspace) {
+        if (patterns.some((pattern) => pathMatchesPattern(file, pattern))) {
+            concrete.add(file);
+        }
+    }
+    return [...concrete].sort();
+}

package/dist/workflows/dag/frontend-writer-admission.js

@@ -0,0 +1,260 @@
+import { deterministicSha256, frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
+import { expandFrontendGlobPaths } from "./frontend-worktree-diff.js";
+import { z } from "zod";
+/** A+B (AC-006): four-state writer admission classification. `accepted` is the
+ * only authorized state; `requires-human-approval` is the High-topology
+ * high-admission-receipt gate; `blocked` is deterministic denial; `stale` is
+ * digest drift (source refresh / re-contract). */
+export const frontendWriterAdmissionClassificationSchema = z.enum([
+    "accepted",
+    "requires-human-approval",
+    "blocked",
+    "stale",
+    // Legacy fixture alias: writeSet-external test helpers still emit `admitted`.
+    // Canonical producers always emit one of the four values above.
+    "admitted",
+]);
+/** A+B (AC-006): Micro topology uses `requirement-to-target-and-evidence`
+ * coverage; Small/Standard/High use `requirement-to-decision`. The two schemas
+ * are deliberately separated so a Micro evidence coverage can never be read as
+ * a decision coverage. */
+export const frontendAdmissionCoverageSchema = z.discriminatedUnion("coverageId", [
+    z
+        .object({
+        coverageId: z.literal("requirement-to-target-and-evidence"),
+        requirementId: z.string().min(1),
+        targetPaths: z.array(z.string().min(1)),
+        evidenceRefs: z.array(z.string().min(1)),
+    })
+        .strict(),
+    z
+        .object({
+        coverageId: z.literal("requirement-to-decision"),
+        requirementId: z.string().min(1),
+        decisionRefs: z.array(z.string().min(1)),
+    })
+        .strict(),
+]);
+/** Failure-source values shared with frontend recovery planning (M8). */
+export const frontendAdmissionFailureSourceSchema = z.enum([
+    "frontend-plan-pi",
+    "frontend-design-policy-shell",
+    "frontend-writer-admission-shell",
+    "frontend-implement-pi",
+    "frontend-verify-shell",
+]);
+/**
+ * Deterministic artifact schema for `contracts/frontend-writer-admission-result.json`.
+ * Scheduler admission gate and frontend recovery planning read this artifact
+ * (fail-closed); it replaces the legacy frontend-prewrite-result-v1 as the
+ * write authorization source.
+ */
+export const frontendWriterAdmissionResultV1Schema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal("frontend-writer-admission-shell-v1"),
+    classification: frontendWriterAdmissionClassificationSchema,
+    writeSet: z.array(z.string().min(1)),
+    writeSetDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    baselineDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    admissionDigest: z.string().regex(/^[a-f0-9]{64}$/),
+    baselineDebtPolicy: z.string().min(1).optional(),
+    findings: z.array(z
+        .object({
+        code: z.string().min(1),
+        message: z.string().min(1),
+        path: z.string().optional(),
+    })
+        .strict()),
+    failureSource: frontendAdmissionFailureSourceSchema.optional(),
+})
+    .strict();
+/** Artifact relative path written by the frontend-writer-admission-shell. */
+export const FRONTEND_WRITER_ADMISSION_RESULT_ARTIFACT = "contracts/frontend-writer-admission-result.json";
+function sortFindings(findings) {
+    return [...findings].sort((a, b) => {
+        if (a.code !== b.code)
+            return a.code < b.code ? -1 : 1;
+        if (a.message !== b.message)
+            return a.message < b.message ? -1 : 1;
+        const pathA = a.path ?? "";
+        const pathB = b.path ?? "";
+        if (pathA !== pathB)
+            return pathA < pathB ? -1 : 1;
+        return 0;
+    });
+}
+/** Reject non-concrete writeSet entries: absolute paths, traversal, globstar,
+ * repo-root, and empty/duplicate-slash segments. */
+export function isConcreteWriteSetPath(value) {
+    const path = value.trim();
+    if (path === "" || path === "." || path === "./")
+        return false;
+    if (path.startsWith("/") || path.includes("\\"))
+        return false;
+    const segments = path.split("/");
+    if (segments.some((segment) => segment === ".." || segment === "**" || segment === "")) {
+        return false;
+    }
+    return true;
+}
+/** Derive the concrete writeSet from implementation targets ∪ non-static
+ * verification target files. Entries are de-duplicated and lexicographically
+ * sorted (frozen). */
+export function deriveWriteSet(contract, options) {
+    const findings = [];
+    const candidates = [
+        ...contract.targets.files,
+        ...contract.verificationTargets
+            .filter((target) => target.type !== "static")
+            .map((target) => target.file),
+    ];
+    // Expand glob entries (e.g. `src/**` inherited from the skeleton) against
+    // the enumerated workspace files so the derived writeSet contains only
+    // concrete paths. Without a file list, globs are treated as concrete and
+    // rejected by isConcreteWriteSetPath below (fail-closed).
+    const expanded = options?.workspaceFiles
+        ? expandFrontendGlobPaths({
+            candidates,
+            workspaceFiles: options.workspaceFiles,
+        })
+        : candidates;
+    const writeSet = new Set();
+    for (const candidate of expanded) {
+        if (!isConcreteWriteSetPath(candidate)) {
+            findings.push({
+                code: "write-set-path-not-concrete",
+                message: `writeSet entry is not a concrete path: ${candidate}`,
+                path: candidate,
+            });
+            continue;
+        }
+        writeSet.add(candidate);
+    }
+    return { writeSet: [...writeSet].sort(), findings };
+}
+/** Sort and freeze the injected baseline; duplicate paths and empty baselines
+ * are blocking (collection itself is production wiring, not this shell). */
+export function freezeBaseline(baseline) {
+    const findings = [];
+    if (baseline.length === 0) {
+        findings.push({
+            code: "baseline-empty",
+            message: "writer admission baseline is empty",
+        });
+    }
+    const seen = new Set();
+    for (const entry of baseline) {
+        if (seen.has(entry.path)) {
+            findings.push({
+                code: "baseline-duplicate-path",
+                message: `baseline contains duplicate path: ${entry.path}`,
+                path: entry.path,
+            });
+        }
+        seen.add(entry.path);
+    }
+    const sorted = [...baseline].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    return { baselineDigest: deterministicSha256(sorted), findings };
+}
+/** Combine mock strategy, allowed strategies digest, frozen command digest,
+ * production-default-off flag and real-integration expectation into one
+ * deterministic admission digest. */
+export function deriveAdmissionDigest(contract, allowedMockStrategies, frozenCommandLabels, baselineDebtPolicy) {
+    return deterministicSha256({
+        mockApiStrategy: contract.mockApi.strategy,
+        allowedMockStrategiesDigest: deterministicSha256([...allowedMockStrategies].sort()),
+        frozenCommandLabelsDigest: deterministicSha256([...frozenCommandLabels].sort()),
+        productionDefaultOff: contract.mockApi.productionDefaultOff === true,
+        hasRealIntegrationGap: Boolean(contract.realIntegrationGap),
+        baselineDebtPolicy: baselineDebtPolicy ?? "",
+    });
+}
+/** Shape-aware deterministic admission: re-validate the typed contract, honor
+ * the design-policy result, derive/freeze the writeSet, digest the baseline,
+ * and assemble the admission digest. */
+export function deriveFrontendWriterAdmissionShell(input) {
+    const findings = [];
+    const shape = frontendImplementationContractSchema.safeParse(input.contract);
+    if (!shape.success) {
+        findings.push({
+            code: "contract-shape-invalid",
+            message: `contract fails strict shape validation: ${shape.error.issues[0]?.message ?? "unknown issue"}`,
+            path: shape.error.issues[0]?.path.join(".") || undefined,
+        });
+    }
+    if (input.designPolicyResult.classification === "blocked") {
+        findings.push({
+            code: "design-policy-blocked",
+            message: `design policy is blocked with ${input.designPolicyResult.findings.length} finding(s)`,
+        });
+    }
+    const derived = deriveWriteSet(input.contract, {
+        workspaceFiles: input.workspaceFiles,
+    });
+    findings.push(...derived.findings);
+    const baseline = freezeBaseline(input.baseline);
+    findings.push(...baseline.findings);
+    const sortedFindings = sortFindings(findings);
+    // Deterministic admission: any finding blocks. High-risk contracts keep the
+    // full policy/writeSet/baseline gates but do NOT stop for a human approval
+    // step — the DAG runs unattended, so `requires-human-approval` would strand
+    // every high-risk writer. The receipt is still materialized for audit; the
+    // scheduler authorizes `accepted` directly.
+    const classification = sortedFindings.length > 0 ? "blocked" : "accepted";
+    const result = {
+        schemaId: "frontend-writer-admission-shell-v1",
+        classification,
+        writeSet: derived.writeSet,
+        writeSetDigest: deterministicSha256(derived.writeSet),
+        baselineDigest: baseline.baselineDigest,
+        admissionDigest: deriveAdmissionDigest(input.contract, input.allowedMockStrategies, input.frozenCommandLabels, input.baselineDebtPolicy),
+        ...(input.baselineDebtPolicy !== undefined
+            ? { baselineDebtPolicy: input.baselineDebtPolicy }
+            : {}),
+        findings: sortedFindings,
+    };
+    return result;
+}
+function normalizeNewVerdict(classification) {
+    return classification === "accepted" ||
+        classification === "requires-human-approval" ||
+        classification === "admitted"
+        ? "accepted"
+        : "blocked";
+}
+function normalizeLegacyVerdict(classification) {
+    return classification === "accepted" || classification === "accepted-normalized"
+        ? "accepted"
+        : "blocked";
+}
+export function compareAdmissionToLegacyGate(input) {
+    const newVerdict = normalizeNewVerdict(input.newClassification);
+    const legacyVerdict = normalizeLegacyVerdict(input.legacyClassification);
+    return {
+        newClassification: input.newClassification,
+        legacyClassification: input.legacyClassification,
+        newVerdict,
+        legacyVerdict,
+        match: newVerdict === legacyVerdict,
+    };
+}
+/** Render a stable, deterministically ordered mismatch list for the evaluation
+ * set. Input order is irrelevant: rows are sorted by a canonical key. */
+export function renderAdmissionShadowDiff(results) {
+    const indexed = results.map((result, index) => ({ ...result, index }));
+    const sorted = indexed.sort((a, b) => {
+        const keyA = `${a.legacyClassification}|${a.newClassification}`;
+        const keyB = `${b.legacyClassification}|${b.newClassification}`;
+        if (keyA !== keyB)
+            return keyA < keyB ? -1 : 1;
+        return a.index - b.index;
+    });
+    const mismatches = sorted.filter((row) => !row.match);
+    const lines = [
+        "## Admission Shadow Diff",
+        `${sorted.length} comparisons, ${mismatches.length} mismatches`,
+        ...sorted.map((row) => `- ${row.legacyClassification} -> ${row.newClassification}: legacy=${row.legacyVerdict} new=${row.newVerdict}${row.match ? " match" : " MISMATCH"}`),
+    ];
+    return lines.join("\n");
+}