@tea-agent/loop-agent 0.20.1 → 0.22.0

package/dist/workflows/dag/frontend-lint-baseline.js

@@ -0,0 +1,471 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+export const FRONTEND_LINT_BASELINE_SCHEMA_ID = "frontend-lint-baseline-v1";
+export const FRONTEND_LINT_ASSESSMENT_SCHEMA_ID = "frontend-lint-assessment-v1";
+const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/);
+const relativePathSchema = z
+    .string()
+    .min(1)
+    .refine((value) => !value.includes("\\") &&
+    !path.posix.isAbsolute(value) &&
+    !value.split("/").includes(".."), "expected a contained repo-relative path");
+export const frontendLintDiagnosticSchema = z
+    .object({
+    file: relativePathSchema,
+    line: z.number().int().positive(),
+    column: z.number().int().positive(),
+    severity: z.enum(["error", "warning"]),
+    message: z.string().min(1),
+    ruleId: z.string().min(1).nullable(),
+})
+    .strict();
+export const frontendLintCommandIdentitySchema = z
+    .object({
+    commands: z.array(z.string().min(1)).min(1),
+    sha256: sha256Schema,
+})
+    .strict();
+const rawEvidenceRefSchema = z
+    .object({
+    path: relativePathSchema,
+    sha256: sha256Schema,
+    stream: z.enum(["stdout", "stderr"]),
+    commandIndex: z.number().int().nonnegative(),
+})
+    .strict();
+const lintCommandResultSchema = z
+    .object({
+    command: z.string().min(1),
+    exitCode: z.number().int().nullable(),
+    timedOut: z.boolean(),
+    failureCategory: z.string().min(1),
+})
+    .strict();
+export const frontendLintBaselineArtifactSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_LINT_BASELINE_SCHEMA_ID),
+    status: z.enum(["available", "unavailable"]),
+    reason: z.string().min(1).optional(),
+    commandIdentity: frontendLintCommandIdentitySchema,
+    diagnostics: z.array(frontendLintDiagnosticSchema),
+    commandResults: z.array(lintCommandResultSchema),
+    rawEvidenceRefs: z.array(rawEvidenceRefSchema),
+})
+    .strict();
+export const frontendLintAssessmentArtifactSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    schemaId: z.literal(FRONTEND_LINT_ASSESSMENT_SCHEMA_ID),
+    status: z.enum(["passed", "baseline-debt", "failed", "unavailable"]),
+    commandIdentity: frontendLintCommandIdentitySchema,
+    baselineRef: z
+        .object({
+        path: relativePathSchema,
+        sha256: sha256Schema,
+        nodeId: z.string().min(1),
+    })
+        .strict()
+        .optional(),
+    currentExitCode: z.number().int().nullable(),
+    writerChangedFiles: z.array(relativePathSchema),
+    currentDiagnostics: z.array(frontendLintDiagnosticSchema),
+    toleratedDiagnosticCount: z.number().int().nonnegative(),
+    blockingDiagnostics: z.array(frontendLintDiagnosticSchema),
+    blockingReasons: z.array(z.string().min(1)),
+    rawEvidenceRefs: z.array(rawEvidenceRefSchema),
+})
+    .strict();
+const ANSI_PATTERN = 
+// eslint-disable-next-line no-control-regex
+/[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*)?\u0007)|(?:(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+function stripAnsi(value) {
+    return value.replace(ANSI_PATTERN, "");
+}
+function normalizeRepoPath(workspaceRoot, candidate) {
+    const clean = stripAnsi(candidate).trim().replace(/^file:\/\//, "");
+    const windowsAbsolute = /^[A-Za-z]:[\\/]/.test(clean);
+    const windowsRoot = /^[A-Za-z]:[\\/]/.test(workspaceRoot);
+    let relative;
+    if (windowsAbsolute || windowsRoot) {
+        if (!windowsAbsolute || !windowsRoot)
+            return null;
+        relative = path.win32.relative(workspaceRoot, clean);
+    }
+    else if (path.posix.isAbsolute(clean)) {
+        relative = path.posix.relative(workspaceRoot.replaceAll("\\", "/"), clean.replaceAll("\\", "/"));
+    }
+    else {
+        relative = clean;
+    }
+    const normalized = relative.replaceAll("\\", "/").replace(/^\.\//, "");
+    if (normalized.length === 0 ||
+        path.posix.isAbsolute(normalized) ||
+        normalized === ".." ||
+        normalized.startsWith("../")) {
+        return null;
+    }
+    return normalized;
+}
+const IGNORED_ESLINT_LINES = [
+    /^$/,
+    /^>\s/,
+    /^npm (?:warn|notice)\b/i,
+    /^eslint\b/i,
+    /^✖\s+\d+\s+problems?/i,
+    /^\d+\s+problems?\s+\(/i,
+    /^\d+\s+errors?\s+and\s+\d+\s+warnings?/i,
+    /^--$/,
+];
+function isIgnoredEslintLine(line) {
+    return IGNORED_ESLINT_LINES.some((pattern) => pattern.test(line.trim()));
+}
+export function parseEslintDiagnostics(input) {
+    const diagnostics = [];
+    const unparsedLines = [];
+    let currentFile = null;
+    for (const rawLine of stripAnsi(input.output).split(/\r?\n/)) {
+        const line = rawLine.trimEnd();
+        if (isIgnoredEslintLine(line))
+            continue;
+        const stylish = line.match(/^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)(?:\s{2,}([@a-zA-Z0-9_./-]+))?\s*$/);
+        if (stylish && currentFile) {
+            diagnostics.push({
+                file: currentFile,
+                line: Number(stylish[1]),
+                column: Number(stylish[2]),
+                severity: stylish[3],
+                message: stylish[4].trim(),
+                ruleId: stylish[5]?.trim() || null,
+            });
+            continue;
+        }
+        const compact = line.match(/^(.+?):\s*line\s+(\d+),\s*col\s+(\d+),\s*(Error|Warning)\s*-\s*(.+?)(?:\s+\(([^)]+)\))?$/i);
+        if (compact) {
+            const file = normalizeRepoPath(input.workspaceRoot, compact[1]);
+            if (!file) {
+                unparsedLines.push(line.trim());
+                continue;
+            }
+            diagnostics.push({
+                file,
+                line: Number(compact[2]),
+                column: Number(compact[3]),
+                severity: compact[4].toLowerCase(),
+                message: compact[5].trim(),
+                ruleId: compact[6]?.trim() || null,
+            });
+            continue;
+        }
+        const candidateFile = normalizeRepoPath(input.workspaceRoot, line.trim());
+        if (candidateFile &&
+            /\.[a-z0-9]+$/i.test(candidateFile) &&
+            !/\s{2,}/.test(line.trim())) {
+            currentFile = candidateFile;
+            continue;
+        }
+        unparsedLines.push(line.trim());
+    }
+    return { diagnostics, unparsedLines };
+}
+export function createFrontendLintCommandIdentity(commands) {
+    const normalized = commands.map((command) => command.trim());
+    return {
+        commands: normalized,
+        sha256: createHash("sha256")
+            .update(JSON.stringify(normalized))
+            .digest("hex"),
+    };
+}
+function diagnosticKey(value) {
+    return JSON.stringify([
+        value.file,
+        value.line,
+        value.column,
+        value.severity,
+        value.message,
+        value.ruleId,
+    ]);
+}
+export function assessFrontendLint(input) {
+    const writerChangedFiles = [
+        ...new Set(input.writerChangedFiles.map((value) => value.replaceAll("\\", "/"))),
+    ].sort();
+    const base = {
+        schemaVersion: 1,
+        schemaId: FRONTEND_LINT_ASSESSMENT_SCHEMA_ID,
+        commandIdentity: input.commandIdentity,
+        ...(input.baselineRef ? { baselineRef: input.baselineRef } : {}),
+        currentExitCode: input.currentExitCode,
+        writerChangedFiles,
+        currentDiagnostics: input.currentDiagnostics,
+        rawEvidenceRefs: input.rawEvidenceRefs,
+    };
+    if (input.currentExitCode === 0) {
+        return {
+            ...base,
+            status: "passed",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: [],
+            blockingReasons: [],
+        };
+    }
+    if (!input.baseline || input.baseline.status !== "available") {
+        return {
+            ...base,
+            status: "unavailable",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: input.currentDiagnostics,
+            blockingReasons: [
+                input.baseline?.reason ?? "lint baseline is missing or unavailable",
+            ],
+        };
+    }
+    if (input.currentUnavailableReason) {
+        return {
+            ...base,
+            status: "unavailable",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: input.currentDiagnostics,
+            blockingReasons: [input.currentUnavailableReason],
+        };
+    }
+    if (input.baseline.commandIdentity.sha256 !== input.commandIdentity.sha256) {
+        return {
+            ...base,
+            status: "unavailable",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: input.currentDiagnostics,
+            blockingReasons: ["lint command identity drifted from baseline"],
+        };
+    }
+    if (input.currentUnparsedLines.length > 0 || input.currentDiagnostics.length === 0) {
+        return {
+            ...base,
+            status: "unavailable",
+            toleratedDiagnosticCount: 0,
+            blockingDiagnostics: input.currentDiagnostics,
+            blockingReasons: ["current lint output cannot be parsed reliably"],
+        };
+    }
+    const changed = new Set(writerChangedFiles);
+    const changedDiagnostics = input.currentDiagnostics.filter((item) => changed.has(item.file));
+    const baselineCounts = new Map();
+    for (const item of input.baseline.diagnostics) {
+        const key = diagnosticKey(item);
+        baselineCounts.set(key, (baselineCounts.get(key) ?? 0) + 1);
+    }
+    const newDiagnostics = [];
+    let toleratedDiagnosticCount = 0;
+    for (const item of input.currentDiagnostics) {
+        if (changed.has(item.file))
+            continue;
+        const key = diagnosticKey(item);
+        const count = baselineCounts.get(key) ?? 0;
+        if (count === 0) {
+            newDiagnostics.push(item);
+        }
+        else {
+            baselineCounts.set(key, count - 1);
+            toleratedDiagnosticCount += 1;
+        }
+    }
+    const blockingReasons = [];
+    if (changedDiagnostics.length > 0) {
+        blockingReasons.push("writer-changed files contain lint diagnostics");
+    }
+    if (newDiagnostics.length > 0) {
+        blockingReasons.push("current lint contains diagnostics absent from baseline");
+    }
+    const blockingDiagnostics = [...changedDiagnostics, ...newDiagnostics];
+    return {
+        ...base,
+        status: blockingReasons.length > 0 ? "failed" : "baseline-debt",
+        toleratedDiagnosticCount,
+        blockingDiagnostics,
+        blockingReasons,
+    };
+}
+const writerChangeManifestSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    writerNodeId: z.string().min(1),
+    changedFiles: z.array(relativePathSchema),
+    beforeStatusSha256: sha256Schema,
+    afterStatusSha256: sha256Schema,
+})
+    .strict();
+export async function readWriterChangedFiles(runDir, writerNodeIds) {
+    const changed = new Set();
+    for (const writerNodeId of writerNodeIds) {
+        const raw = JSON.parse(await readFile(path.join(runDir, writerNodeId, "change-manifest.json"), "utf8"));
+        const parsed = writerChangeManifestSchema.parse(raw);
+        if (parsed.writerNodeId !== writerNodeId) {
+            throw new Error(`lint assessment writer manifest ownership mismatch for ${writerNodeId}`);
+        }
+        for (const file of parsed.changedFiles)
+            changed.add(file);
+    }
+    return [...changed].sort();
+}
+async function writeContract(runDir, name, value) {
+    const relative = `contracts/${name}`;
+    const raw = `${JSON.stringify(value, null, 2)}\n`;
+    await mkdir(path.join(runDir, "contracts"), { recursive: true });
+    await writeFile(path.join(runDir, relative), raw, "utf8");
+    return {
+        path: relative,
+        sha256: createHash("sha256").update(raw).digest("hex"),
+    };
+}
+async function materializeRawEvidence(input) {
+    const refs = [];
+    const evidenceDir = path.join(input.runDir, "contracts", "lint-evidence");
+    await mkdir(evidenceDir, { recursive: true });
+    for (const [commandIndex, result] of input.results.entries()) {
+        for (const stream of ["stdout", "stderr"]) {
+            const raw = await readResultStream(input.runDir, result, stream);
+            const relative = `contracts/lint-evidence/${input.phase}-${commandIndex}.${stream}.txt`;
+            await writeFile(path.join(input.runDir, relative), raw, "utf8");
+            refs.push({
+                path: relative,
+                sha256: createHash("sha256").update(raw).digest("hex"),
+                stream,
+                commandIndex,
+            });
+        }
+    }
+    return refs;
+}
+async function readResultStream(runDir, result, stream) {
+    const artifactPath = stream === "stdout"
+        ? result.stdoutArtifactPath
+        : result.stderrArtifactPath;
+    if (artifactPath) {
+        const resolved = path.resolve(artifactPath);
+        const relative = path.relative(path.resolve(runDir), resolved);
+        if (relative !== "" &&
+            !relative.startsWith("..") &&
+            !path.isAbsolute(relative)) {
+            try {
+                return await readFile(resolved, "utf8");
+            }
+            catch {
+                // Fall through to the bounded executor value.
+            }
+        }
+    }
+    return result[stream];
+}
+async function parseCommandResults(input) {
+    const diagnostics = [];
+    const unparsedLines = [];
+    for (const result of input.results) {
+        const parsed = parseEslintDiagnostics({
+            workspaceRoot: input.workspaceRoot,
+            output: `${await readResultStream(input.runDir, result, "stdout")}\n${await readResultStream(input.runDir, result, "stderr")}`,
+        });
+        diagnostics.push(...parsed.diagnostics);
+        unparsedLines.push(...parsed.unparsedLines);
+    }
+    return { diagnostics, unparsedLines };
+}
+export async function materializeFrontendLintBaseline(input) {
+    const commandIdentity = createFrontendLintCommandIdentity(input.commands);
+    const parsed = await parseCommandResults(input);
+    const unusableResult = input.results.find((result) => result.timedOut ||
+        result.exitCode === null ||
+        result.failureCategory === "spawn-error");
+    let reason;
+    if (input.worktreeChanged)
+        reason = "lint baseline command modified the worktree";
+    else if (unusableResult)
+        reason = "lint baseline command timed out or could not execute";
+    else if (input.results.some((result) => result.exitCode !== 0) &&
+        (parsed.unparsedLines.length > 0 || parsed.diagnostics.length === 0)) {
+        reason = "lint baseline output cannot be parsed reliably";
+    }
+    const rawEvidenceRefs = await materializeRawEvidence({
+        runDir: input.runDir,
+        phase: "baseline",
+        results: input.results,
+    });
+    const artifact = frontendLintBaselineArtifactSchema.parse({
+        schemaVersion: 1,
+        schemaId: FRONTEND_LINT_BASELINE_SCHEMA_ID,
+        status: reason ? "unavailable" : "available",
+        ...(reason ? { reason } : {}),
+        commandIdentity,
+        diagnostics: parsed.diagnostics,
+        commandResults: input.results.map((result) => ({
+            command: result.command,
+            exitCode: result.exitCode,
+            timedOut: result.timedOut,
+            failureCategory: result.failureCategory,
+        })),
+        rawEvidenceRefs,
+    });
+    const ref = await writeContract(input.runDir, "frontend-lint-baseline.json", artifact);
+    return { artifact, ref };
+}
+export async function materializeFrontendLintAssessment(input) {
+    const baselinePath = path.join(input.runDir, "contracts", "frontend-lint-baseline.json");
+    let baseline;
+    let baselineRef;
+    try {
+        const raw = await readFile(baselinePath, "utf8");
+        baseline = frontendLintBaselineArtifactSchema.parse(JSON.parse(raw));
+        baselineRef = {
+            path: "contracts/frontend-lint-baseline.json",
+            sha256: createHash("sha256").update(raw).digest("hex"),
+            nodeId: input.baselineNodeId,
+        };
+    }
+    catch {
+        baseline = undefined;
+    }
+    let writerChangedFiles = [];
+    let manifestError;
+    try {
+        writerChangedFiles = await readWriterChangedFiles(input.runDir, input.writerNodeIds);
+    }
+    catch (error) {
+        manifestError = error instanceof Error ? error.message : String(error);
+    }
+    const parsed = await parseCommandResults(input);
+    const rawEvidenceRefs = await materializeRawEvidence({
+        runDir: input.runDir,
+        phase: "current",
+        results: input.results,
+    });
+    const commandIdentity = createFrontendLintCommandIdentity(input.commands);
+    const nonzero = input.results.find((result) => result.exitCode !== 0);
+    const unusableResult = input.results.find((result) => result.timedOut ||
+        result.exitCode === null ||
+        result.failureCategory === "spawn-error");
+    let assessment = assessFrontendLint({
+        baseline,
+        baselineRef,
+        commandIdentity,
+        currentExitCode: unusableResult ? null : (nonzero?.exitCode ?? 0),
+        currentDiagnostics: parsed.diagnostics,
+        currentUnparsedLines: parsed.unparsedLines,
+        currentUnavailableReason: unusableResult
+            ? "current lint command timed out or could not execute"
+            : undefined,
+        writerChangedFiles,
+        rawEvidenceRefs,
+    });
+    if (manifestError && assessment.status !== "passed") {
+        assessment = {
+            ...assessment,
+            status: "unavailable",
+            blockingReasons: [manifestError],
+        };
+    }
+    assessment = frontendLintAssessmentArtifactSchema.parse(assessment);
+    await writeContract(input.runDir, "frontend-lint-assessment.json", assessment);
+    return assessment;
+}

package/dist/workflows/dag/frontend-prewrite-gate.js

@@ -1,34 +1,52 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
-import { frontendImplementationContractSchema, materializeFrontendImplementationContract, } from "./frontend-implementation-contract.js";
+import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
+import { frontendImplementationContractSchema, materializeFrontendImplementationContract, assertFrontendSourceBindingFresh, } from "./frontend-implementation-contract.js";
+import { captureFrontendWorktreeBaseline } from "./frontend-worktree-diff.js";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
 async function selectNode(runDir, primary, fallbacks) {
-    for (const nodeId of [primary, ...fallbacks.filter((id) => id !== primary)]) {
+    const candidates = [primary, ...fallbacks.filter((id) => id !== primary)];
+    const rejections = [];
+    for (const nodeId of candidates) {
         try {
-            await stat(path.join(runDir, `${nodeId}.json`));
-            return nodeId;
+            const raw = await readFile(path.join(runDir, `${nodeId}.json`), "utf8");
+            const record = JSON.parse(raw);
+            if (record.status === "FINISHED")
+                return nodeId;
+            rejections.push(`${nodeId}: status=${String(record.status)}`);
         }
         catch (error) {
-            if (error.code === "ENOENT")
+            if (error.code === "ENOENT") {
+                rejections.push(`${nodeId}: file missing`);
                 continue;
+            }
             throw error;
         }
     }
-    throw new Error(`frontend prewrite gate missing node output: ${[primary, ...fallbacks].join(", ")}`);
+    throw new Error(`frontend prewrite gate no FINISHED candidate: ${rejections.join("; ")}`);
 }
 async function readNodeText(runDir, nodeId) {
     const record = JSON.parse(await readFile(path.join(runDir, `${nodeId}.json`), "utf8"));
+    if (record.status !== "FINISHED") {
+        throw new Error(`frontend prewrite gate requires FINISHED node ${nodeId} (got ${String(record.status)})`);
+    }
     const text = record.assistantText?.trim() || record.stdout?.trim() || "";
     if (!text)
         throw new Error(`frontend prewrite gate empty output from ${nodeId}`);
     return text;
 }
-function firstVerdictLine(text) {
-    for (const raw of text.split(/\r?\n/)) {
-        const line = raw.trim().replace(/^\*{1,3}\s*(VERDICT:[^*]+?)\s*\*{1,3}$/, "$1").trim();
-        if (line.startsWith("VERDICT:"))
-            return line;
-    }
-    return "";
+function firstNonEmptyVerdictLine(text) {
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const normalize = (line) => {
+        const emphasized = line.match(/^(?:`{1,3}|\*{1,3})\s*(VERDICT:[^`*]+?)\s*(?:`{1,3}|\*{1,3})$/);
+        return (emphasized?.[1] ?? line).trim();
+    };
+    const normalizedLines = lines.map(normalize);
+    const first = normalizedLines[0] ?? "";
+    // The prompt requires VERDICT to be the first non-empty line, but model
+    // output can still prepend a summary. Keep the protocol strict in the
+    // prompt while making the deterministic gate resilient to that drift.
+    return normalizedLines.find((line) => /^VERDICT:/.test(line)) ?? first;
 }
 function eventArgs(event) {
     return event.args ?? event.toolInput ?? event.input ?? {};
@@ -55,7 +73,7 @@ async function checkOpenspecReadEvidence(input) {
     const matched = new Set();
     const normalizedCandidates = new Set(candidatePaths
         .map((candidate) => toRepoRelativePath(candidate, repoRoot))
-        .filter((candidate) => Boolean(candidate?.startsWith("openspec/"))));
+        .filter((candidate) => Boolean(candidate && isOpenspecSpecFilePath(candidate))));
     for (const nodeId of [planNodeId, reviewNodeId]) {
         const eventsPath = path.join(runDir, nodeId, "session-events.jsonl");
         try {
@@ -105,11 +123,31 @@ async function checkOpenspecReadEvidence(input) {
     return [...matched];
 }
 export async function runFrontendPrewriteGate(input) {
+    const workspaceRoot = input.workspaceRoot ?? input.repoRoot;
+    if (workspaceRoot) {
+        if (input.config.requireSourceFreshness) {
+            if (!input.sourceBinding)
+                throw new Error("frontend prewrite gate requires sourceBinding for freshness check");
+            await assertFrontendSourceBindingFresh({ workspaceRoot, binding: input.sourceBinding });
+        }
+        let hasGitMetadata = true;
+        try {
+            await stat(path.join(workspaceRoot, ".git"));
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes("ENOENT"))
+                hasGitMetadata = false;
+            else
+                throw error;
+        }
+        if (hasGitMetadata)
+            await captureFrontendWorktreeBaseline({ runDir: input.runDir, workspaceRoot });
+    }
     const planNodeId = await selectNode(input.runDir, input.config.planFromNodeId, input.config.planFallbackFromNodeIds);
     const reviewNodeId = await selectNode(input.runDir, input.config.reviewFromNodeId, input.config.reviewFallbackFromNodeIds);
     const planText = await readNodeText(input.runDir, planNodeId);
     const reviewText = await readNodeText(input.runDir, reviewNodeId);
-    const verdict = firstVerdictLine(reviewText);
+    const verdict = firstNonEmptyVerdictLine(reviewText);
     if (verdict !== "VERDICT: pass") {
         throw new Error(`frontend prewrite gate blocked by ${reviewNodeId}: ${verdict || "missing VERDICT"}`);
     }
@@ -129,13 +167,38 @@ export async function runFrontendPrewriteGate(input) {
     if (!input.config.allowedMockStrategies.includes(contract.mockApi.strategy)) {
         throw new Error(`frontend prewrite gate blocked mock strategy ${contract.mockApi.strategy}; allowed=${input.config.allowedMockStrategies.join(",")}`);
     }
+    if (input.config.implementationWriteSet) {
+        const writeSet = new Set(input.config.implementationWriteSet);
+        const contractTargets = new Set(contract.targets.files);
+        const uncoveredTargets = [...contractTargets].filter((target) => ![...writeSet].some((pattern) => pathMatchesPattern(target, pattern) || target === pattern));
+        if (uncoveredTargets.length > 0) {
+            throw new Error(`frontend prewrite gate contract target is outside implementation writeSet: ${uncoveredTargets.join(", ")}`);
+        }
+    }
+    if (contract.mockApi.strategy !== "not-needed") {
+        for (const endpoint of contract.mockApi.endpoints) {
+            for (const relative of [endpoint.fixture, endpoint.consumer]) {
+                if (!relative)
+                    continue;
+                const absolute = path.resolve(workspaceRoot ?? ".", relative);
+                try {
+                    const info = await stat(absolute);
+                    if (!info.isFile())
+                        throw new Error("not a regular file");
+                }
+                catch (error) {
+                    throw new Error(`frontend prewrite gate missing Mock file ${relative}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    }
     const candidatePaths = input.config.openspecCandidatePaths ?? [];
     const openspecReadPaths = await checkOpenspecReadEvidence({
         runDir: input.runDir,
         candidatePaths,
         planNodeId,
         reviewNodeId,
-        repoRoot: input.repoRoot ?? process.cwd(),
+        repoRoot: workspaceRoot ?? process.cwd(),
     });
     if (candidatePaths.length > 0 && openspecReadPaths.length === 0) {
         const checkedNodes = [planNodeId, reviewNodeId].join(", ");

package/dist/workflows/dag/frontend-project-capability.js

@@ -5,6 +5,7 @@
  */
 import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
+import { OPENSPEC_SPEC_DIRS, OPENSPEC_SPEC_EXT_RE } from "../../shared/openspec-spec.js";
 async function exists(filePath) {
     try {
         await stat(filePath);
@@ -33,10 +34,14 @@ function hasDep(deps, name) {
     return Object.hasOwn(deps, name);
 }
 async function listOpenspec(repoRoot) {
-    const root = path.join(repoRoot, "openspec");
-    if (!(await exists(root)))
-        return [];
     const out = [];
+    for (const specDir of OPENSPEC_SPEC_DIRS) {
+        const root = path.join(repoRoot, specDir);
+        if (!(await exists(root)))
+            continue;
+        await walk(root, 0);
+    }
+    return out.slice(0, 40);
     async function walk(dir, depth) {
         if (depth > 4)
             return;
@@ -53,7 +58,7 @@ async function listOpenspec(repoRoot) {
                 const info = await stat(full);
                 if (info.isDirectory())
                     await walk(full, depth + 1);
-                else if (/\.(md|mdx|json)$/i.test(name)) {
+                else if (OPENSPEC_SPEC_EXT_RE.test(name)) {
                     out.push(path.relative(repoRoot, full).replace(/\\/g, "/"));
                 }
             }
@@ -62,15 +67,13 @@ async function listOpenspec(repoRoot) {
             }
         }
     }
-    await walk(root, 0);
-    return out.slice(0, 40);
 }
 export function buildAdapterGuidance(capability) {
     const lines = [
         "## Frontend project capability (generation-time)",
         `Framework: ${capability.framework}${capability.frameworkVersion ? `@${capability.frameworkVersion}` : ""}`,
         `Evidence: ${capability.evidencePaths.join(", ") || "(none)"}`,
-        "Rules: openspec/** and task sources outrank adapter tips; do not invent APIs for unknown versions; lockfile-only is not enough.",
+        "Rules: openspec specs and task sources outrank adapter tips; do not invent APIs for unknown versions; lockfile-only is not enough.",
     ];
     if (capability.framework === "react") {
         lines.push("React adapter: prefer function components + hooks; reuse existing Testing Library / Vitest patterns; do not introduce new state libs without authorization.");
@@ -125,7 +128,7 @@ export async function discoverFrontendProjectCapability(repoRoot) {
             },
         };
         if (openspec.length) {
-            base.reasons.push(`openspec/ files discovered: ${openspec.slice(0, 5).join(", ")}`);
+            base.reasons.push(`openspec spec files discovered: ${openspec.slice(0, 5).join(", ")}`);
         }
         return { ...base, adapterGuidance: buildAdapterGuidance(base) };
     }