@tea-agent/loop-agent 0.26.5-beta.0 → 0.26.5-beta.2

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -346,12 +346,75 @@ function secretIssues(value, at = "$", issues = []) {
 }
 export function extractFrontendImplementationJson(text) {
     const trimmed = text.trim();
+    const parse = (source) => {
+        try {
+            return JSON.parse(source);
+        }
+        catch (error) {
+            // Models sometimes put ordinary ASCII quotes inside a JSON string
+            // (for example: `reason: "支持..."`). Repair only quotes that are
+            // clearly not structural: a closing quote is followed by JSON
+            // punctuation, while an embedded quote is followed by content.
+            let repaired = "";
+            let inString = false;
+            let escaped = false;
+            for (let index = 0; index < source.length; index += 1) {
+                const character = source[index];
+                if (character !== '"') {
+                    repaired += character;
+                    if (inString && character === "\\" && !escaped)
+                        escaped = true;
+                    else
+                        escaped = false;
+                    continue;
+                }
+                if (escaped) {
+                    repaired += character;
+                    escaped = false;
+                    continue;
+                }
+                if (!inString) {
+                    inString = true;
+                    repaired += character;
+                    continue;
+                }
+                const next = source.slice(index + 1).trimStart()[0];
+                if ([",", "}", "]", ":"].includes(next ?? "") || source.slice(index + 1).trim() === "") {
+                    inString = false;
+                    repaired += character;
+                }
+                else {
+                    repaired += "\\\"";
+                }
+            }
+            try {
+                return JSON.parse(repaired);
+            }
+            catch {
+                throw error;
+            }
+        }
+    };
     if (trimmed.startsWith("{") && trimmed.endsWith("}"))
-        return JSON.parse(trimmed);
+        return parse(trimmed);
     const blocks = [...trimmed.matchAll(/```json\s*\n([\s\S]*?)\n```/gi)];
-    if (blocks.length !== 1)
+    if (blocks.length === 0)
         throw new Error("output must contain exactly one fenced json object");
-    return JSON.parse(blocks[0][1]);
+    const candidates = [];
+    for (const block of blocks) {
+        try {
+            const candidate = parse(block[1]);
+            if (candidate && typeof candidate === "object" && !Array.isArray(candidate))
+                candidates.push(candidate);
+        }
+        catch {
+            // Ignore incomplete model scratch blocks. A later complete contract
+            // block may still be deterministically recoverable.
+        }
+    }
+    if (candidates.length !== 1)
+        throw new Error(`output must contain exactly one valid fenced json object (found ${candidates.length})`);
+    return candidates[0];
 }
 /**
  * Build the authoritative frontend-implementation-contract sourceBinding from

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

@@ -1,7 +1,8 @@
 import { readFile, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
-import { frontendImplementationContractSchema, materializeFrontendImplementationContract, assertFrontendSourceBindingFresh, } from "./frontend-implementation-contract.js";
+import { frontendImplementationContractSchema, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, 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) {
@@ -160,13 +161,20 @@ export async function runFrontendPrewriteGate(input) {
     if (missingIds.length > 0) {
         throw new Error(`frontend prewrite gate missing requirement ids: ${missingIds.join(", ")}`);
     }
-    const artifact = await materializeFrontendImplementationContract({
+    const artifactPath = path.join(input.runDir, input.config.outputDir, input.config.artifactName);
+    const artifact = await stat(artifactPath)
+        .then(async () => ({
+        path: artifactPath,
+        schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
+        sha256: createHash("sha256").update(await readFile(artifactPath)).digest("hex"),
+    }))
+        .catch(() => materializeFrontendImplementationContract({
         runDir: input.runDir,
         fromNodeId: planNodeId,
         artifactName: input.config.artifactName,
         outputDir: input.config.outputDir,
         sourceBinding: input.sourceBinding,
-    });
+    }));
     const raw = JSON.parse(await readFile(artifact.path, "utf8"));
     const contract = frontendImplementationContractSchema.parse(raw);
     if (!input.config.allowedMockStrategies.includes(contract.mockApi.strategy)) {

package/dist/workflows/dag/init-hybrid.js

@@ -2455,9 +2455,62 @@ async function buildFrontendHybridDagFromTask(sources) {
                     sourceContext,
                 ].join("\n\n"),
             },
+            {
+                id: "frontend-contract-json-pi",
+                depends_on: [
+                    "frontend-plan-revision-pi",
+                    "frontend-plan-pi",
+                    "frontend-final-design-review-pi",
+                    "frontend-design-review-pi",
+                ],
+                dependsPolicy: "all-or-condition-skip",
+                role: "planner",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                outputMode: "structured-required",
+                retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                skills: FRONTEND_IMPLEMENTATION_SKILLS,
+                outputContract: "Return exactly one JSON object conforming to frontend-implementation-contract-v1. No Markdown, prose, comments, or code fences.",
+                subtask_prompt: [
+                    "Convert the effective reviewed frontend plan into the canonical frontend-implementation-contract-v1 JSON.",
+                    "Use frontend-plan-revision-pi when it is FINISHED; otherwise use frontend-plan-pi. Confirm the effective design review passed before producing the contract.",
+                    "Return only the JSON object. Do not wrap it in Markdown or a code fence. Do not add explanatory text.",
+                    "Preserve all requirement expectedOutcome, interaction trigger/expectedBehavior, target files, verification targets, Mock/API decisions, and Real Integration Gap from the effective plan.",
+                    frontendContractSchemaBlock,
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-contract-json-validate-shell",
+                depends_on: ["frontend-contract-json-pi"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Validated frontend implementation contract artifact with schema ID and SHA-256.",
+                subtask_prompt: "Materialize and validate the structured frontend contract before prewrite authorization.",
+                shell: {
+                    commands: [],
+                    jsonArtifactGate: {
+                        fromNodeId: "frontend-contract-json-pi",
+                        schemaId: "frontend-implementation-contract-v1",
+                        artifactName: "frontend-implementation-contract.json",
+                        outputDir: "contracts",
+                    },
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            },
             {
                 id: "frontend-prewrite-gate-shell",
                 depends_on: [
+                    "frontend-contract-json-pi",
+                    "frontend-contract-json-validate-shell",
                     "frontend-final-design-review-pi",
                     "frontend-design-review-pi",
                     "frontend-plan-revision-pi",
@@ -2476,8 +2529,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                     commands: [],
                     frontendPrewriteGate: {
                         schemaVersion: 1,
-                        planFromNodeId: "frontend-plan-revision-pi",
-                        planFallbackFromNodeIds: ["frontend-plan-pi"],
+                        planFromNodeId: "frontend-contract-json-pi",
+                        planFallbackFromNodeIds: ["frontend-plan-revision-pi", "frontend-plan-pi"],
                         reviewFromNodeId: "frontend-final-design-review-pi",
                         reviewFallbackFromNodeIds: ["frontend-design-review-pi"],
                         requiredRequirementIds: requirementIds,
@@ -5287,7 +5340,7 @@ async function buildHybridDagForTemplate(sources, template) {
         else if (template === "review-gated-dag")
             spec = buildReviewGatedHybridDag(standard, sources);
         else
-            spec = buildSupervisedHybridDag(standard, sources);
+            spec = await buildSupervisedHybridDag(standard, sources);
     }
     applyProjectGovernanceReview(spec, template, sources);
     // New generate path always emits DagSpec v4 + bindings.
@@ -5721,10 +5774,12 @@ function buildWriteSetGateNode(sources) {
         },
     };
 }
-function buildSoftVerifyNode(sources) {
+async function buildSoftVerifyNode(sources) {
     const implementId = implementationNodeId();
     const strategy = resolveDagVerifyStrategy(sources.taskConfig, "1");
-    const fallbackCommands = ["npm run typecheck"];
+    const fallbackCommands = sources.repoRoot
+        ? (await discoverFrontendFallbackVerifyCommands(sources.repoRoot)).staticCommands
+        : ["npm run typecheck"];
     const focusedIntermediate = sources.verifyCommands?.intermediate.filter((command) => !isFullSuiteVerifyCommand(command));
     const plannedIntermediate = applyMavenVerificationPlanning({
         repoRoot: sources.repoRoot,
@@ -5966,7 +6021,7 @@ function resolveSupervisedConvergence(taskConfig) {
         chainNodeIds: [...SUPERVISED_CONVERGENCE_CHAIN_NODE_IDS],
     };
 }
-function buildSupervisedHybridDag(standard, sources) {
+async function buildSupervisedHybridDag(standard, sources) {
     const contract = getTaskOrThrow(standard, "contract-pi");
     const scoutSrc = getTaskOrThrow(standard, "scout-src");
     const scoutTests = getTaskOrThrow(standard, "scout-tests");
@@ -6018,7 +6073,7 @@ function buildSupervisedHybridDag(standard, sources) {
                     "final-write-set-audit-format-repair-pi",
                 ],
             }),
-            buildSoftVerifyNode(sources),
+            await buildSoftVerifyNode(sources),
             buildProcessSupervisorNode(sources),
             buildProcessGateNode(sources),
             buildRepairNode(sources),

package/harness.json

@@ -58,9 +58,9 @@
   "executors": {
     "pi": {
       "description": "Pi planning, review, diagnosis, and bounded writing when DAG toolProfile=write",
-      "LOW": "minimax-m3",
-      "MED": "grok-4.5",
-      "HIGH": "gpt-5.6-sol"
+      "LOW": {"model": "deepseek/deepseek-v4-flash", "thinking": "high"},
+      "MED": {"model": "deepseek/deepseek-v4-flash", "thinking": "max"},
+      "HIGH": {"model": "deepseek/deepseek-v4-flash", "thinking": "max"}
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.26.5-beta.0",
+  "version": "0.26.5-beta.2",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",