@tea-agent/loop-agent 0.35.1-beta.4 → 0.35.2

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 ?? {
@@ -2359,12 +2339,6 @@ async function buildFrontendHybridDagFromTask(sources) {
             `Every requirement MUST have a non-empty expectedOutcome. Every interaction MUST have non-empty trigger and expectedBehavior. UI states with applicable=true MUST have non-empty expectedBehavior. Empty strings or omitted fields for these will cause contract rejection.`,
         ].join("\n")
         : "";
-    const verificationTargetFileInstruction = [
-        `## Verification target file semantics`,
-        `verificationTargets[].file is the code file that the target verifies (the file the writer changes), NOT where the command is defined.`,
-        `Non-static targets (type unit/component/integration/mock) MUST set file to a concrete code file inside the implementation writeSet (task allowedPaths); the prewrite gate rejects any non-static target whose file falls outside the writeSet.`,
-        `Command-level checks that run project-wide (all tests, typecheck, build, governance) MUST use type "static" and must NOT be bound as non-static targets with file=package.json/tsconfig.json/vite.config.ts/scripts/*. Static targets are exempt from the writeSet containment check.`,
-    ].join("\n");
     const strategy = resolveDagVerifyStrategy(taskConfig);
     const readOnlyPaths = taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"];
     const behaviorPaths = deriveFrontendBehaviorPaths(taskConfig);
@@ -2558,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,
@@ -2575,8 +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.",
-                    verificationTargetFileInstruction,
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
                     fixedVerificationContext,
                     sourceContext,
@@ -2616,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,
@@ -2634,7 +2598,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "End the response with exactly one fenced json object conforming to frontend-implementation-contract-v1. This node is the single contract JSON producer when the design review requests revision: 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. Bind it to the supplied task sources; map every requirement and applicable UI state to concrete implementation and verification targets or an explicit blocking evidence gap. Do not include secrets or unsafe paths.",
                     "Preserve each requirement expectedOutcome and each interaction trigger/expectedBehavior in the revised contract; do not reduce behavior semantics to IDs and paths.",
                     "verificationTargets[].commandLabel MUST be one of the frozen command labels listed above. Any other value will be rejected at contract materialization.",
-                    verificationTargetFileInstruction,
                     fixedVerificationContext,
                     sourceContext,
                     frontendContractSchemaBlock,
@@ -2753,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.",
@@ -2812,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.",
@@ -5679,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,
@@ -6453,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,