@tea-agent/loop-agent 0.35.1-beta.2 → 0.35.1

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

@@ -20,14 +20,6 @@ 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",
@@ -35,72 +27,12 @@ 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") ||
@@ -188,23 +120,6 @@ 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) {
@@ -220,24 +135,19 @@ 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) {
-        if (!isPathWithinWriteSet(entry, implementWriteSet)) {
+        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))) {
             throw new Error(`repair writeSet entry "${entry}" is not ⊆ implement writeSet`);
         }
     }
@@ -260,63 +170,6 @@ 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 ?? []);
@@ -326,14 +179,12 @@ 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 {
@@ -367,6 +218,7 @@ export async function runFrontendFailureAssessGate(input) {
             // missing optional nodes ok
         }
     }
+    assertWriteSetSubset(implementWriteSet, implementWriteSet);
     if (failed.length === 0) {
         const assessment = {
             schemaVersion: 1,
@@ -389,49 +241,16 @@ 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,
     });
-    // 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 eligible = isFrontendRepairable(failureClass) && attempt <= 1;
+    const reason = eligible
+        ? `repairable failureClass=${failureClass} on ${primary.nodeId}`
+        : `non-repairable or ineligible: failureClass=${failureClass} attempt=${attempt}`;
     const assessment = {
         schemaVersion: 1,
         schemaId: FRONTEND_REPAIR_ASSESSMENT_SCHEMA_ID,
@@ -448,25 +267,6 @@ 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;
@@ -522,8 +322,7 @@ export async function runFrontendRepairContractGate(input) {
     if (!assessment.eligible) {
         throw new Error(`repair-contract: non-repairable failure (${assessment.failureClass}): ${assessment.reason}`);
     }
-    if (!isFrontendRepairable(assessment.failureClass) &&
-        assessment.failureClass !== "review") {
+    if (!isFrontendRepairable(assessment.failureClass)) {
         throw new Error(`repair-contract: failureClass ${assessment.failureClass} is not repairable`);
     }
     return { ok: true, assessment };

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

@@ -40,48 +40,6 @@ 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);
@@ -217,11 +175,38 @@ export async function runFrontendVerificationTraceGate(input) {
             }
         }
     }
-    const { targets, hardIssues } = await evaluateVerificationTargets({
-        contract,
-        labelOwners,
-        workspaceRoot: input.workspaceRoot,
-    });
+    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,
+        });
+    }
     if (hardIssues.length) {
         throw new Error(`trace: ${hardIssues.join("; ")}`);
     }

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

@@ -2199,26 +2199,6 @@ function pruneFrontendTasksForRisk(tasks, risk) {
         return { ...task, depends_on };
     });
 }
-/**
- * AC-1: shared frontend writer node defaults. frontend-implement-pi and
- * frontend-repair-pi share one prompt/contract/writeSet-guard surface and an
- * identical writeSet; only id, depends_on, runIf, outputContract, and
- * subtask_prompt differ per phase.
- */
-function buildFrontendWriterNodeDefaults(input) {
-    return {
-        role: "implementer",
-        executor: "pi",
-        toolProfile: "write",
-        complexity: input.complexity,
-        writePolicy: "exclusive",
-        writeSet: input.writeSet,
-        allowedPaths: input.allowedPaths,
-        forbiddenPaths: input.forbiddenPaths,
-        skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
-        writerOutcomePolicy: { type: "implementation-outcome-v1" },
-    };
-}
 async function buildFrontendHybridDagFromTask(sources) {
     const { taskConfig } = sources;
     const mockCapability = sources.frontendMockCapability ?? {
@@ -2552,10 +2532,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 outputMode: "structured-required",
                 retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
-                structuredContractOutput: {
-                    schemaId: "frontend-implementation-contract-v1",
-                    retryOnInvalid: true,
-                },
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
@@ -2569,7 +2545,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "End with exactly one fenced json object conforming to frontend-implementation-contract-v1. This node is the single contract JSON producer: the fenced block is the authoritative contract the prewrite gate materializes. Do not emit any raw JSON, JSON in prose, or a second fenced block anywhere in the response; the plan text must not contain other balanced JSON objects.",
                     "Each requirement must state its user-observable or logic-observable expectedOutcome. Each interaction must state its trigger and expectedBehavior. IDs plus file paths are not sufficient behavior semantics.",
                     requirementCoverageInstruction,
-                    "verificationTargets[].commandLabel MUST be one of the frozen command labels listed above. Any other value will be rejected at contract materialization.",
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
                     fixedVerificationContext,
                     sourceContext,
@@ -2609,10 +2584,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 outputMode: "structured-required",
                 retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
-                structuredContractOutput: {
-                    schemaId: "frontend-implementation-contract-v1",
-                    retryOnInvalid: true,
-                },
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
@@ -2745,12 +2716,18 @@ async function buildFrontendHybridDagFromTask(sources) {
                         ? ["frontend-lint-baseline-shell"]
                         : []),
                 ],
-                ...buildFrontendWriterNodeDefaults({
-                    complexity: resolveWriterComplexity(taskConfig),
-                    writeSet: implementPaths.writeSet,
-                    allowedPaths: implementPaths.allowedPaths,
-                    forbiddenPaths,
-                }),
+                role: "implementer",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: resolveWriterComplexity(taskConfig),
+                writePolicy: "exclusive",
+                writeSet: implementPaths.writeSet,
+                allowedPaths: implementPaths.allowedPaths,
+                forbiddenPaths,
+                skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
+                writerOutcomePolicy: {
+                    type: "implementation-outcome-v1",
+                },
                 outputContract: "First non-empty line must be exactly one of: IMPLEMENTATION_OUTCOME: changed; IMPLEMENTATION_OUTCOME: already-satisfied; IMPLEMENTATION_OUTCOME: blocked. Then a Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
                 subtask_prompt: [
                     "Implement against the validated run-owned Frontend Implementation Contract from frontend-prewrite-gate-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
@@ -2804,12 +2781,18 @@ async function buildFrontendHybridDagFromTask(sources) {
                 id: "frontend-repair-pi",
                 depends_on: ["frontend-verify-assess-shell", implementId],
                 runIf: "$.nodes['frontend-verify-assess-shell'].json.eligible == true",
-                ...buildFrontendWriterNodeDefaults({
-                    complexity: resolveWriterComplexity(taskConfig),
-                    writeSet: implementPaths.writeSet,
-                    allowedPaths: implementPaths.allowedPaths,
-                    forbiddenPaths,
-                }),
+                role: "implementer",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: resolveWriterComplexity(taskConfig),
+                writePolicy: "exclusive",
+                writeSet: implementPaths.writeSet,
+                allowedPaths: implementPaths.allowedPaths,
+                forbiddenPaths,
+                skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
+                writerOutcomePolicy: {
+                    type: "implementation-outcome-v1",
+                },
                 outputContract: "First non-empty line must be exactly one of: IMPLEMENTATION_OUTCOME: changed; IMPLEMENTATION_OUTCOME: already-satisfied; IMPLEMENTATION_OUTCOME: blocked. Then a repair summary for an eligible repairable assessment. Must not expand writeSet, re-interpret requirements, skip tests, or enable Mock by default.",
                 subtask_prompt: [
                     "Read contracts/frontend-repair-assessment.json and the validated frontend implementation contract.",
@@ -5671,6 +5654,7 @@ export async function buildHybridDagFromTask(sources, options = {}) {
         : sources.frontendProjectCapability;
     const selection = resolveTaskDagTemplateSelection({
         taskKind: sources.taskConfig.taskKind,
+        taskKindExplicit: sources.taskConfig.taskKindExplicit,
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
         allowedPaths: sources.taskConfig.allowedPaths,
@@ -6445,6 +6429,7 @@ export async function writeHybridDagDraft(sources, outputPath, options = {}) {
         : sources.frontendProjectCapability;
     const templateSelection = resolveTaskDagTemplateSelection({
         taskKind: sources.taskConfig.taskKind,
+        taskKindExplicit: sources.taskConfig.taskKindExplicit,
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
         allowedPaths: sources.taskConfig.allowedPaths,

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

@@ -4,7 +4,6 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { recordDecisionEnvelopeForNode, shouldPauseOnHumanEscalation, writeHumanEscalationArtifacts, } from "./decision-envelope.js";
-import { FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT, FRONTEND_WRITER_NODE_IDS, isFrontendWriterAuthorized, readFrontendPrewriteResult, } from "./scheduler.js";
 import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope, formatConvergenceFeedbackBlock, } from "./prompt.js";
@@ -13,8 +12,6 @@ import { buildOutputLimitRecoverySection, loadBackendTestWriterProgressForRetry,
 import { computeBackoffDelayMs, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, } from "./retry-policy.js";
 import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
 import { buildProtocolRetryInstruction, normalizeReviewVerdictAfterRetries, parseJsonReviewVerdict, validateOutputProtocol, } from "./output-protocol.js";
-import { getStructuredContractValidator } from "./contract-output-registry.js";
-import "./contract-validator-registrations.js";
 import { writeDagNodeJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { buildProjectGovernanceContext, readCompletedWriterChangeManifests, writeProjectGovernanceContext, } from "./project-governance-context.js";
 import { assertSkillSnapshotCoversSpec, buildNodePromptFromSnapshot, isDagSkillSnapshotIntegrityError, readSkillSnapshot, } from "./skill-snapshot.js";
@@ -141,20 +138,6 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
             buildProtocolRetryInstruction(task.outputProtocol, previousProtocolReason),
         ].join("\n");
     }
-    if (previousFailureCategory === "invalid-output" &&
-        task.structuredContractOutput &&
-        previousProtocolReason) {
-        return [
-            basePrompt,
-            "",
-            "<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.",
-            "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 === "writer-empty-diff") {
         const maxAttempts = task.retryPolicy?.maxAttempts ?? 3;
         // When a completeness progress exists for this writer, fold the concrete
@@ -412,21 +395,6 @@ export async function executeDagNode(input) {
         await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
     };
     const failSkillSnapshot = (error) => failBeforePrompt(error, "skill-snapshot-integrity");
-    const skipFrontendWriter = async (admission) => {
-        const skippedAt = new Date().toISOString();
-        node.startedAt ??= skippedAt;
-        node.frontendWriterAdmission = admission;
-        node.status = "SKIPPED";
-        node.skippedReason = "frontend-prewrite-not-authorized";
-        node.finishedAt = skippedAt;
-        node.lastActivityAt = skippedAt;
-        node.durationMs = durationBetween(node.startedAt, node.finishedAt);
-        node.timing = { retryBackoffMs: 0, settlementCleanupMs: 0 };
-        state.nodes[nodeId].nodeRecordPath = path.join(runDir, `${nodeId}.json`);
-        await writeNodeRecord(runDir, nodeId, state.nodes[nodeId]);
-        await input.persistState();
-        await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
-    };
     if (task.finalWriteSetApproval) {
         const authorization = parseAndValidateFinalWriteSetApproval({ task, spec, state });
         if (!authorization.ok) {
@@ -455,30 +423,6 @@ export async function executeDagNode(input) {
             effectiveWriteSet: [...authorization.effectiveWriteSet],
         };
     }
-    if (FRONTEND_WRITER_NODE_IDS.includes(nodeId)) {
-        const admission = await readFrontendPrewriteResult(runDir);
-        if (!admission.ok) {
-            await skipFrontendWriter(undefined);
-            return;
-        }
-        const decision = isFrontendWriterAuthorized(admission.result);
-        const record = {
-            schemaVersion: 1,
-            writerNodeId: nodeId,
-            decision,
-            sourceArtifact: FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT,
-            artifactHash: admission.artifactHash,
-            checkedAt: new Date().toISOString(),
-            reason: decision === "denied"
-                ? `classification: ${admission.result.classification}`
-                : null,
-        };
-        if (decision === "denied") {
-            await skipFrontendWriter(record);
-            return;
-        }
-        node.frontendWriterAdmission = record;
-    }
     let projectGovernanceContext;
     if (task.governanceStandardReview) {
         try {
@@ -745,39 +689,6 @@ export async function executeDagNode(input) {
                 previousProtocolReason = undefined;
             }
         }
-        // R1: structured contract nodes self-validate their output so schema,
-        // typo, and null violations surface as retryable invalid-output at the
-        // producing node instead of failing the whole run at the prewrite gate.
-        if (result.ok && task.structuredContractOutput) {
-            const validator = getStructuredContractValidator(task.structuredContractOutput.schemaId);
-            if (validator) {
-                const contractText = canonicalNodeOutput(result);
-                const contractCheck = await validator({
-                    runDir,
-                    text: contractText,
-                    sourceBinding: spec.sourceBinding,
-                });
-                if (!contractCheck.ok) {
-                    result = {
-                        ...result,
-                        ok: false,
-                        failureCategory: "invalid-output",
-                        stderr: [result.stderr, contractCheck.reason]
-                            .filter(Boolean)
-                            .join("\n"),
-                    };
-                    previousProtocolReason = contractCheck.reason;
-                }
-                else {
-                    previousProtocolReason = undefined;
-                }
-            }
-            else {
-                // DAG spec validation rejects unknown schemaIds; this is a
-                // defensive fallback for a registry that has not been populated.
-                console.warn(`[run-dag] warning: no structured contract validator registered for schemaId ${task.structuredContractOutput.schemaId}; skipping node self-check`);
-            }
-        }
         const attemptFinishedAt = new Date().toISOString();
         const attemptWallDurationMs = durationBetween(attemptStartedAt, attemptFinishedAt);
         totalAttemptWallDurationMs += attemptWallDurationMs;