@tea-agent/loop-agent 0.39.0-next.2 → 0.39.0-next.20

package/dist/workflows/dag/node-execution.js

@@ -129,6 +129,26 @@ export function buildNodePrompt(spec, task, upstream, options) {
         convergenceFeedback: options?.convergenceFeedback,
     });
 }
+function frontendStructuredArtifactRetryGuidance(schemaId) {
+    if (schemaId === "frontend-implementation-contract-plan-patch-v1") {
+        return [
+            "Return exactly this artifact and nothing else: one short lead-in line, then exactly one fenced json block containing only the editable RFC 7386 plan patch, immediately followed by exactly one fenced openspec-citations block.",
+            "The runtime applies your patch to its protected contract skeleton. Do not emit schemaVersion, sourceBinding, riskLevel, targets.files, or mockApi.productionDefaultOff; do not emit the full contract.",
+            "Do not emit Markdown headings, bullets, plan prose, explanations, raw JSON, or any other fenced block.",
+        ];
+    }
+    if (schemaId === "frontend-implementation-contract-revision-patch-v1") {
+        return [
+            "Return exactly this artifact and nothing else: one short lead-in line, then exactly one fenced json block containing the RFC 7386 merge-patch delta, immediately followed by exactly one fenced openspec-citations block.",
+            "The delta contains only the fields you change; null deletes a key, arrays and scalars replace, and plain objects merge recursively. Do not emit a full contract or a schemaVersion/targets section.",
+            "Do not emit Markdown headings, bullets, plan prose, explanations, raw JSON, or any other fenced block.",
+        ];
+    }
+    return [
+        "Return exactly this artifact and nothing else: one short lead-in line, then exactly one fenced json block conforming to frontend-implementation-contract-v1, immediately followed by exactly one fenced openspec-citations block.",
+        "The contract JSON fields are the complete implementation plan. Do not emit a separate plan document, Markdown headings, bullets, plan prose, explanations, raw JSON, or any other fenced block.",
+    ];
+}
 function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCategory, previousProtocolReason, recoveryTargetPaths, recoveryDiagnostics) {
     if (attemptNumber <= 1)
         return basePrompt;
@@ -150,11 +170,23 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
             "<retry_instruction>",
             "Previous attempt produced an invalid frontend implementation contract:",
             previousProtocolReason,
-            "Return exactly one fenced json block conforming to the frontend-implementation-contract-v1 schema.",
+            ...frontendStructuredArtifactRetryGuidance(task.structuredContractOutput.schemaId),
             "Fix every reported field violation: do not emit null for optional fields, do not misspell field names, and match the required types exactly.",
             "</retry_instruction>",
         ].join("\n");
     }
+    if (previousFailureCategory === "structured-output-truncated" &&
+        task.structuredContractOutput) {
+        return [
+            basePrompt,
+            "",
+            "<retry_instruction>",
+            "Previous attempt was truncated by the provider (stopReason=length) before the JSON contract was completed.",
+            ...frontendStructuredArtifactRetryGuidance(task.structuredContractOutput.schemaId),
+            "The JSON artifact must be complete; omit evidence excerpts and duplicated upstream context.",
+            "</retry_instruction>",
+        ].join("\n");
+    }
     if (previousFailureCategory === "writer-empty-diff") {
         const maxAttempts = task.retryPolicy?.maxAttempts ?? 3;
         // When a completeness progress exists for this writer, fold the concrete
@@ -220,6 +252,17 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
         return basePrompt;
     }
     if (task.outputMode === "structured-required") {
+        if (task.structuredContractOutput) {
+            return [
+                basePrompt,
+                "",
+                "<retry_instruction>",
+                "Previous attempt exceeded the structured output size limit.",
+                ...frontendStructuredArtifactRetryGuidance(task.structuredContractOutput.schemaId),
+                "Keep every required field but make values concise; omit evidence excerpts and duplicated upstream context.",
+                "</retry_instruction>",
+            ].join("\n");
+        }
         return [
             basePrompt,
             "",
@@ -766,12 +809,21 @@ export async function executeDagNode(input) {
                     runDir,
                     text: contractText,
                     sourceBinding: spec.sourceBinding,
+                    nodeId,
+                    attempt: attemptNumber,
+                    structuredContractOutput: task.structuredContractOutput,
                 });
                 if (!contractCheck.ok) {
+                    // A provider stopReason=length means the response was cut before the
+                    // JSON contract could complete; separate it from an ordinary bad
+                    // contract so the retry switches to a JSON-only output strategy.
+                    const attemptStopReason = result.stopReason;
                     result = {
                         ...result,
                         ok: false,
-                        failureCategory: "invalid-output",
+                        failureCategory: attemptStopReason === "length"
+                            ? "structured-output-truncated"
+                            : "invalid-output",
                         stderr: [result.stderr, contractCheck.reason]
                             .filter(Boolean)
                             .join("\n"),
@@ -779,6 +831,13 @@ export async function executeDagNode(input) {
                     previousProtocolReason = contractCheck.reason;
                 }
                 else {
+                    if (contractCheck.normalizedText) {
+                        result = {
+                            ...result,
+                            assistantText: contractCheck.normalizedText,
+                            stdout: contractCheck.normalizedText,
+                        };
+                    }
                     previousProtocolReason = undefined;
                 }
             }

package/dist/workflows/dag/retry-policy.js

@@ -21,6 +21,8 @@ export const STRUCTURED_OUTPUT_RETRY_CATEGORY = "output-too-large";
 export const PROTOCOL_INVALID_RETRY_CATEGORY = "protocol-invalid";
 /** Recoverable model artifact/schema formatting failure on read-only structured nodes. */
 export const STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY = "invalid-output";
+/** Provider stopReason=length truncated the response before the JSON contract completed. */
+export const STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY = "structured-output-truncated";
 /** Retry only a proven no-op from an explicitly opt-in bounded Pi writer. */
 export const WRITER_EMPTY_DIFF_RETRY_CATEGORY = "writer-empty-diff";
 /** Retry when a backend-test writer finished but Completeness Gate found missing/broken targets. */
@@ -36,6 +38,7 @@ export const STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES = [
     ...DEFAULT_DAG_RETRY_CATEGORIES,
     STRUCTURED_OUTPUT_RETRY_CATEGORY,
     STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
 ];
 /** Categories allowed on nodes that declare a machine-readable outputProtocol. */
 export const PROTOCOL_AWARE_DAG_RETRY_CATEGORIES = [
@@ -48,6 +51,7 @@ export const ALL_DAG_RETRY_CATEGORIES = [
     STRUCTURED_OUTPUT_RETRY_CATEGORY,
     PROTOCOL_INVALID_RETRY_CATEGORY,
     STRUCTURED_ARTIFACT_INVALID_RETRY_CATEGORY,
+    STRUCTURED_OUTPUT_TRUNCATED_RETRY_CATEGORY,
     WRITER_EMPTY_DIFF_RETRY_CATEGORY,
     INCOMPLETE_WRITE_SET_RETRY_CATEGORY,
     WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY,

package/dist/workflows/dag/types.js

@@ -193,12 +193,38 @@ export const dagFrontendPrewriteGateSchema = z.object({
     requireSourceFreshness: z.literal(true),
     implementationWriteSet: z.array(z.string().min(1)).min(1).optional(),
     openspecCandidatePaths: z.array(openspecCandidatePathSchema).default([]),
+    /**
+     * Generation-frozen component/theme specification bucket. Derived from
+     * `designEvidence.classified.component ∪ theme ∪ rule.components` at DAG
+     * generation. When non-empty and the canonical contract has UI-visible
+     * work, the prewrite gate requires a non-empty `uiComponentChoices` and
+     * cross-checks each `specReference.path` against this set + the effective
+     * plan openspec-citations block. Legacy DAGs without this field keep the
+     * field-absent semantics (component-choices-missing is not enforced).
+     */
+    componentSpecCandidatePaths: z.array(openspecCandidatePathSchema).optional(),
     /**
      * OpenSpec gate policy. Omitted on legacy DAGs: the runtime treats
      * undefined as scan-strict so pre-existing full-read semantics are
      * preserved. Generation always writes it explicitly for new DAGs.
      */
     openspecPolicy: z.enum(["cited", "scan-strict"]).optional(),
+    /**
+     * When true, the effective plan node (planFromNodeId when it is selected
+     * over the fallback) emits an RFC 7386 merge-patch delta instead of a full
+     * contract. The gate applies it on the original contract node
+     * (planFallbackFromNodeIds[0]) before analysis/materialization. Legacy DAGs
+     * without this field keep full-contract semantics.
+     */
+    revisionPatch: z.boolean().optional(),
+    /**
+     * Deterministically rendered plan.md artifact name (same outputDir as the
+     * contract). Defaults to frontend-plan.md at runtime.
+     */
+    planMdArtifactName: z
+        .string()
+        .regex(/^[a-z0-9][a-z0-9._-]*\.md$/)
+        .optional(),
     /**
      * Generation-frozen candidate source metadata (diagnostic). cited mode
      * candidates are declared ∪ taskSourceCited; scan-strict candidates are
@@ -397,6 +423,8 @@ export const dagBackendTestPipelineSchema = z.enum([
     "markdown-scenario-param",
     "markdown-execute-html",
     "markdown-manifest",
+    "markdown-report",
+    "ingest-backend-test-gap",
 ]);
 export const dagFrontendBrowserToolPreflightSchema = z.object({}).strict();
 export const dagFrontendTestEvidenceValidationSchema = z.object({}).strict();
@@ -574,6 +602,13 @@ export const dagDynamicExpansionSchema = z.object({
         maxTotalTokens: z.number().int().positive().optional(),
     })
         .optional(),
+    /**
+     * When true, any child blocked by the aggregate token budget fails the map
+     * barrier instead of being retained as a case-level blocked outcome.
+     * Backend-test enables this because partial Markdown/pytest module sets are
+     * invalid generation assets; frontend-test keeps the default false.
+     */
+    failOnTokenBudgetExhaustion: z.boolean().optional(),
     /**
      * When true, map child ERROR/auth/timeout is recorded as case-level
      * failed/blocked evidence and the map barrier still succeeds (frontend-test).
@@ -678,6 +713,8 @@ export const dagConvergenceSpecSchema = z
  */
 export const structuredContractOutputSchemaIds = [
     "frontend-implementation-contract-v1",
+    "frontend-implementation-contract-plan-patch-v1",
+    "frontend-implementation-contract-revision-patch-v1",
 ];
 export const dagTaskSchema = z.object({ id: z.string().regex(/^[a-z][a-z0-9-]*$/, "task id must be kebab-case"),
     depends_on: z.array(z.string()).default([]),
@@ -739,8 +776,25 @@ export const dagTaskSchema = z.object({ id: z.string().regex(/^[a-z][a-z0-9-]*$/
         .object({
         schemaId: z.enum(structuredContractOutputSchemaIds),
         retryOnInvalid: z.boolean().default(true),
+        /**
+         * Optional deterministic base object for patch-producing structured
+         * nodes. The frontend plan patch validator applies the model delta to
+         * this run-owned skeleton before strict contract validation.
+         */
+        skeleton: z.record(z.string(), z.unknown()).optional(),
     })
         .strict()
+        .superRefine((value, ctx) => {
+        if (value.schemaId ===
+            "frontend-implementation-contract-plan-patch-v1" &&
+            !value.skeleton) {
+            ctx.addIssue({
+                code: "custom",
+                message: "frontend plan patch output requires a runtime skeleton",
+                path: ["skeleton"],
+            });
+        }
+    })
         .optional(),
     /**
      * Fail-closed outcome/diff consistency contract for bounded Pi writers.
@@ -830,6 +884,26 @@ export const dagSpecSchema = z
     sourceBinding: dagSourceBindingSchema.optional(),
     /** v4 managed Task Contract binding; only valid on version 4. */
     taskContractBinding: dagTaskContractBindingSchema.optional(),
+    /** Frozen backend-test artifact layout (plan A); absent = historical default testcase/ layout. */
+    backendTestLayout: z
+        .object({
+        testRoot: z.string(),
+        markdownRel: z.string(),
+        scriptRel: z.string(),
+        markdownDir: z.string(),
+        scriptDir: z.string(),
+        readmePath: z.string(),
+        isDefault: z.boolean(),
+    })
+        .optional(),
+    /** Bound user shared-setup document (plan B); absent = no shared setup references expected. */
+    backendTestSharedSetup: z
+        .object({
+        path: z.string(),
+        readPath: z.string(),
+        sha256: z.string(),
+    })
+        .optional(),
     outputLanguage: dagOutputLanguageSchema.optional(),
     objective: z.string().optional(),
     successCriteria: z.array(z.string()).optional(),