@tea-agent/loop-agent 0.35.2 → 0.35.3

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

@@ -20,6 +20,14 @@ export const frontendRepairFailureClassSchema = z.enum([
     "spec-unclear",
     "unknown",
 ]);
+export const frontendCommandCategorySchema = z.enum([
+    "typecheck",
+    "build",
+    "lint",
+    "component-test",
+    "unit-test",
+    "trace",
+]);
 const REPAIRABLE = new Set([
     "typecheck",
     "build",
@@ -27,12 +35,72 @@ const REPAIRABLE = new Set([
     "component-test",
     "unit-test",
     "trace",
-    "review",
 ]);
 export function isFrontendRepairable(failureClass) {
     return REPAIRABLE.has(failureClass);
 }
+/**
+ * Deterministic commandLabel → commandCategory mapping (AC-3).
+ * `targetType` comes from the contract verificationTargets[].type
+ * (static | unit | component | integration | mock); the literal commandLabel
+ * wins over type so a `static` typecheck target is never misread as a test.
+ */
+export function mapCommandLabelToCategory(commandLabel, targetType) {
+    const label = commandLabel.toLowerCase();
+    if (/(?:typecheck|check-types|type-check|\btsc\b)/.test(label))
+        return "typecheck";
+    if (/(?:vite\s+build|next\s+build|webpack|rollup|\bbuild\b)/.test(label))
+        return "build";
+    if (/(?:eslint|\blint\b)/.test(label))
+        return "lint";
+    if (targetType === "component")
+        return "component-test";
+    if (targetType === "unit")
+        return "unit-test";
+    if (/(?:component|testing-library|render\()/.test(label))
+        return "component-test";
+    return "unit-test";
+}
+export function isReviewRepairable(finding, implementWriteSet) {
+    const hasFile = Boolean(finding.file && finding.file.trim().length > 0);
+    const hasLocation = Boolean((finding.line !== undefined && finding.line > 0) ||
+        (finding.symbol && finding.symbol.trim().length > 0));
+    const hasRequirement = Boolean((finding.requirementId && finding.requirementId.trim().length > 0) ||
+        (finding.acceptanceCriteriaId &&
+            finding.acceptanceCriteriaId.trim().length > 0));
+    const fixScope = finding.fixScope ?? (hasFile ? [finding.file] : []);
+    const fixScopeSubset = fixScope.length > 0 &&
+        fixScope.every((entry) => isPathWithinWriteSet(entry, implementWriteSet));
+    return (hasFile &&
+        hasLocation &&
+        hasRequirement &&
+        fixScopeSubset &&
+        finding.requiresContractReplan !== true);
+}
 export function classifyFrontendFailure(input) {
+    // AC-2: structured evidence takes priority over string-blob heuristics.
+    if (input.failureCategory === "write-guard") {
+        return "path";
+    }
+    if (input.traceTarget || input.commandCategory === "trace") {
+        return "trace";
+    }
+    if (input.commandCategory) {
+        switch (input.commandCategory) {
+            case "typecheck":
+                return "typecheck";
+            case "build":
+                return "build";
+            case "lint":
+                return "lint";
+            case "component-test":
+                return "component-test";
+            case "unit-test":
+                return "unit-test";
+        }
+    }
+    // Fallback: string-blob heuristic, preserved in its original branch order so
+    // legacy assertions (error TS2304 → typecheck, write-guard → path, etc.) stay green.
     const blob = `${input.nodeId}\n${input.failureCategory ?? ""}\n${input.stdout ?? ""}\n${input.stderr ?? ""}`.toLowerCase();
     if (input.nodeId.includes("contract") ||
         blob.includes("contract mismatch") ||
@@ -120,6 +188,23 @@ export const frontendRepairAssessmentSchema = z
     allowedRepairWriteSet: z.array(z.string().min(1)),
     evidenceRefs: z.array(z.string().min(1)),
     browserStatus: z.literal("not-run"),
+    // AC-5 structured evidence fields (all optional so existing minimal
+    // fixtures and frontend-review-context safeParse stay compatible).
+    verificationTargetId: z.string().min(1).optional(),
+    commandLabel: z.string().min(1).optional(),
+    exitCode: z.number().int().optional(),
+    commandCategory: frontendCommandCategorySchema.optional(),
+    requirementIds: z.array(z.string().min(1)).optional(),
+    acceptanceCriteriaIds: z.array(z.string().min(1)).optional(),
+    fixScope: z.array(z.string().min(1)).optional(),
+    changedPaths: z.array(z.string().min(1)).optional(),
+    traceRef: z
+        .object({
+        relativePath: z.string().min(1),
+        schemaId: z.string().min(1),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 function nodeHadFailure(record) {
@@ -135,19 +220,24 @@ function nodeHadFailure(record) {
 function normalize(value) {
     return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
+/**
+ * Whether a concrete path or glob entry is contained by the implement writeSet.
+ * Exact glob equality is the norm (repair writeSet === implement writeSet);
+ * concrete (non-glob) paths may also be covered by an implement glob.
+ */
+export function isPathWithinWriteSet(entry, implementWriteSet) {
+    const normalizedEntry = normalize(entry);
+    const normalizedImplement = implementWriteSet.map(normalize);
+    if (normalizedImplement.includes(normalizedEntry))
+        return true;
+    if (!normalizedEntry.includes("*")) {
+        return implementWriteSet.some((pattern) => pathMatchesPattern(normalizedEntry, pattern));
+    }
+    return false;
+}
 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))) {
+        if (!isPathWithinWriteSet(entry, implementWriteSet)) {
             throw new Error(`repair writeSet entry "${entry}" is not ⊆ implement writeSet`);
         }
     }
@@ -170,6 +260,63 @@ async function loadImplementWriteSet(runDir, fallback) {
     }
     return fallback;
 }
+function matchVerificationTarget(contract, commandLabel, command) {
+    for (const target of contract.verificationTargets) {
+        if (commandLabel && target.commandLabel === commandLabel)
+            return target;
+        if (command &&
+            (command.includes(target.commandLabel) ||
+                target.commandLabel.includes(command))) {
+            return target;
+        }
+    }
+    return undefined;
+}
+function deriveFailureEvidence(input) {
+    const evidence = {};
+    for (const { record } of input.failed) {
+        const results = record.commandResults ?? [];
+        const failedResult = results.find((item) => item.ok === false) ?? results[0];
+        if (failedResult &&
+            evidence.exitCode === undefined &&
+            typeof failedResult.exitCode === "number") {
+            evidence.exitCode = failedResult.exitCode;
+        }
+        if (failedResult?.commandLabel && !evidence.commandLabel) {
+            evidence.commandLabel = failedResult.commandLabel;
+        }
+        // Structured trace facts passed by the verification bundle / trace gate.
+        const failedTraceTarget = (record.traceTargets ?? []).find((target) => target.status === "failed");
+        if (failedTraceTarget && !evidence.verificationTargetId) {
+            evidence.verificationTargetId = failedTraceTarget.id;
+            if (!evidence.commandLabel)
+                evidence.commandLabel = failedTraceTarget.commandLabel;
+            evidence.traceTarget = failedTraceTarget;
+            evidence.traceRef = {
+                relativePath: "contracts/frontend-verification-trace.json",
+                schemaId: "frontend-verification-trace-v1",
+            };
+        }
+        if (record.changedPaths?.length && !evidence.changedPaths) {
+            evidence.changedPaths = [...record.changedPaths];
+        }
+    }
+    // Resolve commandLabel → contract verification target → category + scope.
+    const target = matchVerificationTarget(input.contract, evidence.commandLabel);
+    if (target) {
+        if (!evidence.verificationTargetId)
+            evidence.verificationTargetId = target.id;
+        if (!evidence.commandLabel)
+            evidence.commandLabel = target.commandLabel;
+        evidence.requirementIds ??= [...target.requirementIds];
+        evidence.acceptanceCriteriaIds ??= [...target.requirementIds];
+        evidence.fixScope ??= [target.file];
+    }
+    if (evidence.commandLabel) {
+        evidence.commandCategory ??= mapCommandLabelToCategory(evidence.commandLabel, target?.type);
+    }
+    return evidence;
+}
 export async function runFrontendFailureAssessGate(input) {
     const attempt = input.attempt ?? 1;
     const implementWriteSet = await loadImplementWriteSet(input.runDir, input.implementWriteSet ?? []);
@@ -179,12 +326,14 @@ export async function runFrontendFailureAssessGate(input) {
     const contractRel = "contracts/frontend-implementation-contract.json";
     const contractPath = path.join(input.runDir, contractRel);
     let contractSchemaId = FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID;
+    let contract;
     try {
         const raw = JSON.parse(await readFile(contractPath, "utf8"));
         const parsed = frontendImplementationContractSchema.safeParse(raw);
         if (!parsed.success) {
             throw new Error("invalid frontend implementation contract");
         }
+        contract = parsed.data;
         contractSchemaId = FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID;
     }
     catch {
@@ -218,7 +367,6 @@ export async function runFrontendFailureAssessGate(input) {
             // missing optional nodes ok
         }
     }
-    assertWriteSetSubset(implementWriteSet, implementWriteSet);
     if (failed.length === 0) {
         const assessment = {
             schemaVersion: 1,
@@ -241,16 +389,49 @@ export async function runFrontendFailureAssessGate(input) {
         return assessment;
     }
     const primary = failed[0];
+    const evidence = deriveFailureEvidence({ contract, failed });
     const failureClass = classifyFrontendFailure({
         nodeId: primary.nodeId,
         failureCategory: primary.record.failureCategory,
         stdout: primary.record.stdout,
         stderr: primary.record.stderr,
+        commandLabel: evidence.commandLabel,
+        commandCategory: evidence.commandCategory,
+        exitCode: evidence.exitCode,
+        traceTarget: evidence.traceTarget ?? null,
+        changedPaths: evidence.changedPaths,
     });
-    const eligible = isFrontendRepairable(failureClass) && attempt <= 1;
-    const reason = eligible
-        ? `repairable failureClass=${failureClass} on ${primary.nodeId}`
-        : `non-repairable or ineligible: failureClass=${failureClass} attempt=${attempt}`;
+    // AC-5: repairable=true requires structured evidence (a resolved exitCode,
+    // commandCategory, or trace-bound verification target). review has its own
+    // stricter gate (AC-4) and is never unconditionally repairable.
+    const baseEligible = isFrontendRepairable(failureClass) && attempt <= 1;
+    let eligible;
+    let reason;
+    if (failureClass === "review") {
+        const finding = primary.record.reviewFinding ?? {};
+        eligible = attempt <= 1 && isReviewRepairable(finding, implementWriteSet);
+        reason = eligible
+            ? `repairable review finding on ${primary.nodeId}`
+            : `review finding lacks file/line-symbol/requirement evidence or is outside writeSet on ${primary.nodeId}`;
+    }
+    else {
+        const hasStructuredEvidence = evidence.exitCode !== undefined ||
+            evidence.commandCategory !== undefined ||
+            Boolean(evidence.verificationTargetId);
+        eligible = baseEligible && hasStructuredEvidence;
+        reason = eligible
+            ? `repairable failureClass=${failureClass} on ${primary.nodeId}`
+            : !baseEligible
+                ? `non-repairable or ineligible: failureClass=${failureClass} attempt=${attempt}`
+                : `missing structured evidence for failureClass=${failureClass} on ${primary.nodeId}`;
+    }
+    // fixScope and changedPaths must stay inside the implement writeSet.
+    if (evidence.fixScope?.length) {
+        assertWriteSetSubset(evidence.fixScope, implementWriteSet);
+    }
+    if (evidence.changedPaths?.length) {
+        assertWriteSetSubset(evidence.changedPaths, implementWriteSet);
+    }
     const assessment = {
         schemaVersion: 1,
         schemaId: FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID,
@@ -267,6 +448,25 @@ export async function runFrontendFailureAssessGate(input) {
         allowedRepairWriteSet: [...implementWriteSet],
         evidenceRefs: [contractRel, ...failed.map((item) => `${item.nodeId}.json`)],
         browserStatus: "not-run",
+        ...(evidence.verificationTargetId
+            ? { verificationTargetId: evidence.verificationTargetId }
+            : {}),
+        ...(evidence.commandLabel ? { commandLabel: evidence.commandLabel } : {}),
+        ...(evidence.exitCode !== undefined ? { exitCode: evidence.exitCode } : {}),
+        ...(evidence.commandCategory
+            ? { commandCategory: evidence.commandCategory }
+            : {}),
+        ...(evidence.requirementIds?.length
+            ? { requirementIds: evidence.requirementIds }
+            : {}),
+        ...(evidence.acceptanceCriteriaIds?.length
+            ? { acceptanceCriteriaIds: evidence.acceptanceCriteriaIds }
+            : {}),
+        ...(evidence.fixScope?.length ? { fixScope: evidence.fixScope } : {}),
+        ...(evidence.changedPaths?.length
+            ? { changedPaths: evidence.changedPaths }
+            : {}),
+        ...(evidence.traceRef ? { traceRef: evidence.traceRef } : {}),
     };
     await writeAssessment(input.runDir, assessment);
     return assessment;
@@ -322,7 +522,8 @@ export async function runFrontendRepairContractGate(input) {
     if (!assessment.eligible) {
         throw new Error(`repair-contract: non-repairable failure (${assessment.failureClass}): ${assessment.reason}`);
     }
-    if (!isFrontendRepairable(assessment.failureClass)) {
+    if (!isFrontendRepairable(assessment.failureClass) &&
+        assessment.failureClass !== "review") {
         throw new Error(`repair-contract: failureClass ${assessment.failureClass} is not repairable`);
     }
     return { ok: true, assessment };

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

@@ -40,6 +40,48 @@ function symbolEvidenceCandidates(symbol) {
 function isConfigurationVerificationFile(file) {
     return /(?:^|\/)(?:package\.json|tsconfig(?:\.[^/]+)?\.json|(?:vite|webpack|rollup|docusaurus)\.config\.[cm]?[jt]s)$/.test(file.replace(/\\/g, "/"));
 }
+/**
+ * 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 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 = [];
+    const hardIssues = [];
+    for (const target of input.contract.verificationTargets) {
+        const issues = [];
+        const owners = input.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,
+            // 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(...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,
+        });
+    }
+    return { targets, hardIssues };
+}
 async function assertFileAndSymbol(input) {
     const issues = [];
     const absolute = path.resolve(input.workspaceRoot, input.file);
@@ -175,38 +217,11 @@ export async function runFrontendVerificationTraceGate(input) {
             }
         }
     }
-    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,
-            // 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(...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,
-        });
-    }
+    const { targets, hardIssues } = await evaluateVerificationTargets({
+        contract,
+        labelOwners,
+        workspaceRoot: input.workspaceRoot,
+    });
     if (hardIssues.length) {
         throw new Error(`trace: ${hardIssues.join("; ")}`);
     }

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

@@ -0,0 +1,106 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { getDagRunDir } from "./lifecycle.js";
+import { captureWriterBaseline, readJournalFile, restoreJournal, sha256HexBytes, writeJournalFile, } from "./frontend-writer-rollback.js";
+/**
+ * Phase 5: writer transient partial-write recovery — compose the phase-4 rollback
+ * journal with the phase-3 staged child handoff. A frontend writer attempt is
+ * snapshotted before the provider call so a transient partial write can be rolled
+ * back to the pre-attempt baseline, then recovered by a staged child that re-runs
+ * `frontend-implement-pi`.
+ *
+ * The runner remains the single-writer coordinator: it captures the baseline via
+ * {@link captureFrontendWriterAttemptIntent} before the writer provider call, and
+ * on a transient partial write runs {@link rollbackFrontendWriter} before writing
+ * the recovery intent and staging the child.
+ */
+/** Rollback intent path inside a run dir (written before the writer provider call). */
+export const FRONTEND_WRITER_ROLLBACK_INTENT_REL = ".runtime/frontend-writer-rollback.json";
+export function frontendWriterRollbackIntentAbsPath(runDir) {
+    return path.join(runDir, FRONTEND_WRITER_ROLLBACK_INTENT_REL);
+}
+/**
+ * AC/P1-9: capture the writeSet baseline and persist the attempt intent BEFORE
+ * the writer provider call. Returns the intent path. Callers must fail the
+ * attempt closed if this throws (no baseline → no rollback → no recovery).
+ */
+export async function captureFrontendWriterAttemptIntent(input) {
+    const baseline = await captureWriterBaseline(input.cwd, input.writeSet);
+    const intentPath = frontendWriterRollbackIntentAbsPath(input.runDir);
+    await writeJournalFile(intentPath, baseline);
+    return intentPath;
+}
+/**
+ * Record the writer attempt's changed paths and per-path attempt hashes into the
+ * rollback intent AFTER the provider call. This is what makes restoreJournal able
+ * to CAS-restore: it compares each changed path's current hash against the
+ * recorded attempt hash before writing back the baseline.
+ */
+export async function recordFrontendWriterAttempt(input) {
+    const intentPath = frontendWriterRollbackIntentAbsPath(input.runDir);
+    const snapshot = await readJournalFile(intentPath);
+    if (!snapshot)
+        return; // no baseline was captured; nothing to record
+    const changed = [...new Set(input.changedPaths)].sort((a, b) => a.localeCompare(b));
+    const fileHashes = {};
+    for (const rel of changed) {
+        try {
+            const bytes = await readFile(path.join(input.cwd, rel));
+            fileHashes[rel] = sha256HexBytes(bytes);
+        }
+        catch {
+            fileHashes[rel] = "absent";
+        }
+    }
+    snapshot.attemptChangedPaths = changed;
+    snapshot.attemptFileHashes = fileHashes;
+    await writeJournalFile(intentPath, snapshot);
+}
+/**
+ * Restore the parent workspace to its pre-attempt baseline using the phase-4 CAS
+ * journal. This must run BEFORE the recovery intent is written and the child is
+ * staged (rollback commit point): a blocked rollback short-circuits to
+ * `auto-recovery-blocked` and never stages a child.
+ */
+export async function rollbackFrontendWriter(input) {
+    const parentRunDir = getDagRunDir(input.cwd, "active", input.parentRunId);
+    const snapshot = await readJournalFile(frontendWriterRollbackIntentAbsPath(parentRunDir));
+    if (!snapshot) {
+        return {
+            ok: false,
+            state: "missing-intent",
+            reason: "auto-recovery-blocked: writer rollback intent missing (baseline was not captured before the provider call)",
+        };
+    }
+    const result = await restoreJournal(snapshot, { repoRoot: input.cwd });
+    if (result.state !== "completed") {
+        return {
+            ok: false,
+            state: "blocked",
+            reason: result.blockedReason ?? "auto-recovery-blocked",
+        };
+    }
+    return {
+        ok: true,
+        state: "completed",
+        restoredPaths: result.restoredPaths,
+        snapshot,
+    };
+}
+/**
+ * Transient failure categories that indicate a writer may have partially written
+ * before the attempt was interrupted. Clean-timeout (zero writes) is handled by
+ * the retry policy and never reaches terminal aggregation as a recovery trigger.
+ */
+const TRANSIENT_WRITER_FAILURE_CATEGORIES = new Set([
+    "timeout",
+    "network",
+    "rate-limit",
+    "unavailable",
+    "terminated",
+    "disconnect",
+    "provider-error",
+]);
+export function isFrontendWriterTransientPartialWrite(input) {
+    return TRANSIENT_WRITER_FAILURE_CATEGORIES.has(input.failureCategory ?? "");
+}