@tea-agent/loop-agent 0.43.0-next.10 → 0.43.0-next.11

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

@@ -699,7 +699,6 @@ export function frontendSourceMentionsMock(sources) {
  */
 export function resolveFrontendMockMode(capability, taskConfig, hasApiDep) {
     const policy = taskConfig.frontendMock?.policy ?? "auto";
-    const hasDeterministicMockVerification = capability.verifyCommands.length > 0;
     if (capability.safetyViolation ||
         !frontendMockServiceRootAllowed(taskConfig)) {
         return "blocked";
@@ -715,7 +714,7 @@ export function resolveFrontendMockMode(capability, taskConfig, hasApiDep) {
     }
     // required policy
     if (policy === "required") {
-        if (capability.status === "present" && hasDeterministicMockVerification) {
+        if (capability.status === "present") {
             return "required";
         }
         return "blocked";
@@ -724,13 +723,8 @@ export function resolveFrontendMockMode(capability, taskConfig, hasApiDep) {
     if (!hasApiDep) {
         return "not-required";
     }
-    // In auto mode, frontend Mock is optional. Only enter Mock-backed "required"
-    // mode when the project has a confirmed native Mock capability AND
-    // deterministic Mock verification commands. Without executable verification
-    // commands a non-not-needed strategy could never be verified, so auto falls
-    // back to not-required; the prewrite gate then forces not-needed and the
-    // plan records the Real Integration Gap instead of inventing commands.
-    return capability.status === "present" && hasDeterministicMockVerification
+    // Confirmed Mock capability permits implementation; tests are deferred.
+    return capability.status === "present"
         ? "required"
         : "not-required";
 }
@@ -2544,7 +2538,7 @@ function resolveFrontendMockContextBlock(sources) {
         parts.push(`Evidence Paths: ${capability.evidencePaths.join(", ")}`);
     }
     if (capability.verifyCommands.length > 0) {
-        parts.push(`Frozen Mock Verify Commands: ${capability.verifyCommands
+        parts.push(`Deferred frontend-test Mock Commands: ${capability.verifyCommands
             .map((command) => command.label)
             .join(", ")}`);
     }
@@ -2555,13 +2549,13 @@ function resolveFrontendMockContextBlock(sources) {
         parts.push(`Reasons: ${capability.reasons.join("; ")}`);
     }
     if (mode === "required") {
-        parts.push("Mock-backed frontend verification is required. Prefer the detected native service; otherwise the assessment may select an existing browser interception harness or reversible request adapter. Any handler, fixture, adapter, and UI changes stay in the single frontend-implement-pi writeSet.");
+        parts.push("Implement the selected Mock strategy within authorized paths and keep production-default-off isolation. Mock behavior verification is deferred to frontend-test; it is not an implementation gate.");
     }
     if (mode === "not-required") {
         parts.push("Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed when Mock is intentionally skipped, or select a safe Mock strategy if project evidence supports one.");
         if (frontendMockStrategyMustBeNotNeeded(sources)) {
-            parts.push('Auto mode has no confirmed project Mock capability or no deterministic Mock verification command. The structured contract must set mockApi.strategy to "not-needed". Keep the real request path as the default, record any unproved backend behavior as Real Integration Gap, and do not add Mock files or dependencies within this run.');
-            parts.push('HARD CONSTRAINT (frozen at generation time): this DAG allows only mockApi.strategy "not-needed"; the prewrite gate rejects any other strategy. If project governance (openspec / ai_workspace / decision records, e.g. a DEC rule requiring native) demands Mock-backed verification, that is a generation-time contract gap, not a plan-revision defect: declare frontendMock.verifyCommands (or policy: "required") in task.json and regenerate the DAG.');
+            parts.push('Auto mode has no confirmed project Mock capability. The structured contract must set mockApi.strategy to "not-needed". Keep the real request path as the default, record any unproved backend behavior as Real Integration Gap, and do not add Mock files or dependencies within this run.');
+            parts.push('HARD CONSTRAINT (frozen at generation time): this DAG allows only mockApi.strategy "not-needed"; the prewrite gate rejects any other strategy. If project governance (openspec / ai_workspace / decision records, e.g. a DEC rule requiring native) demands Mock-backed verification, that is a generation-time contract gap, not a plan-revision defect: confirm the project Mock capability and policy: "required" in task.json and regenerate the DAG.');
         }
     }
     if (mode === "blocked") {
@@ -2573,12 +2567,10 @@ function frontendMockStrategyMustBeNotNeeded(sources) {
     const policy = sources.taskConfig.frontendMock?.policy ?? "auto";
     const capability = sources.frontendMockCapability;
     const capabilityStatus = capability?.status;
-    const hasDeterministicMockVerification = (capability?.verifyCommands.length ?? 0) > 0;
     return (policy === "auto" &&
         (sources.frontendMockMode ?? "not-required") === "not-required" &&
         (capabilityStatus === "absent" ||
-            capabilityStatus === "ambiguous" ||
-            !hasDeterministicMockVerification));
+            capabilityStatus === "ambiguous"));
 }
 /**
  * 候选规范懒加载：prompt 只内联与任务相关的候选，不全部塞给模型。
@@ -3073,12 +3065,8 @@ async function buildFrontendHybridDagFromTask(sources) {
             includeReferenceDocuments: false,
         }),
     };
-    const hasMockVerifyCommands = (taskConfig.frontendMock?.verifyCommands.length ?? 0) > 0 ||
-        mockCapability.verifyCommands.length > 0;
     const requirementIds = frontendSourceBinding.requirementIds;
-    const strategy = resolveDagVerifyStrategy(taskConfig);
     const readOnlyPaths = taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"];
-    const behaviorPaths = deriveFrontendBehaviorPaths(taskConfig);
     const globalConstraints = [
         ...taskConfig.hardConstraints,
         ...(sources.constraintMarkdown
@@ -3092,7 +3080,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         "Frontend planning must consume the read-only Mock assessment strategy produced after scouting; MOCK_STRATEGY: blocked must not pass the deterministic Mock contract gate.",
         "Mock implementations must preserve the real request path as the default, require explicit test/dev activation, and never rely on commenting out the real request.",
         "Mock-backed behavior evidence proves only the documented frontend contract, never real API integration.",
-        "frontend-implementation DAGs must complete deterministic static verification before final review. Behavior verification is also required when the task declares a behavior entrypoint or the implementation contract contains a behavior-mode verification target; static-only contracts must map every target to the declared static entrypoint.",
+        "frontend-implementation completes requirement-to-code coverage and npm run build only. Behavior correctness and all testing are deferred to frontend-test; build success is never behavior-test success.",
         "Frontend closeout renders only from committed facts; a weak status (failed / not-run / baseline-debt / mock-backed / pending) can never be rewritten into a stronger one (passed / real-integrated).",
         `Frontend risk classification: ${frontendRisk.selectedRisk} — ${frontendRisk.reason}`,
         frontendRisk.forceFullGates
@@ -3104,111 +3092,34 @@ async function buildFrontendHybridDagFromTask(sources) {
         const blockedReason = mockCapability.safetyViolation
             ? `Mock contract blocked: ${mockCapability.safetyViolation}`
             : (taskConfig.frontendMock?.policy ?? "auto") === "required"
-                ? "Mock strategy is required, but no authorized Mock verification command was found."
+                ? "Mock strategy is required, but no authorized Mock capability was found."
                 : "Mock contract is blocked by deterministic generation-time Mock safety constraints.";
         return buildBlockedFrontendMockDag(frontendSources, readOnlyPaths, forbiddenPaths, globalConstraints, blockedReason);
     }
-    const fallbackVerifyCommands = await discoverFrontendFallbackVerifyCommands(sources.repoRoot);
-    // The verification bundle schema requires at least one static command. When
-    // a real project exposes no usable verification command at all, run an
-    // explicit no-op marker instead of a command that is guaranteed to fail:
-    // the trace then records not-run honestly and the advisory asks the task
-    // to declare verification commands and regenerate.
-    const staticFallbackCommands = fallbackVerifyCommands.staticCommands.length > 0
-        ? fallbackVerifyCommands.staticCommands
-        : [FRONTEND_NO_STATIC_VERIFICATION_MARKER];
-    const behaviorFallbackCommands = fallbackVerifyCommands.behaviorCommands;
-    const parsedFrontendVerifyCommands = extractFrontendVerifyCommandsFromMarkdown({
-        repoRoot: sources.repoRoot,
-        requirementMarkdown: sources.requirementMarkdown,
-        constraintMarkdown: sources.constraintMarkdown,
-    });
-    const explicitFrontendVerifyCommands = buildExplicitFrontendVerifyCommands(taskConfig, sources.repoRoot);
-    const explicitCommandKeys = new Set([
-        ...explicitFrontendVerifyCommands.staticCommands,
-        ...explicitFrontendVerifyCommands.behaviorCommands,
-    ].map(verifyCommandKey));
-    const adapterVerifyCommands = (sources.verifyCommands?.final ?? []).filter((command) => !explicitCommandKeys.has(verifyCommandKey(command)));
-    const hasDeclaredFrontendVerification = explicitFrontendVerifyCommands.staticCommands.length > 0 ||
-        explicitFrontendVerifyCommands.behaviorCommands.length > 0 ||
-        parsedFrontendVerifyCommands.staticCommands.length > 0 ||
-        parsedFrontendVerifyCommands.behaviorCommands.length > 0;
-    const staticVerifyCommands = chooseFrontendVerifyCommands({
-        explicitCommands: explicitFrontendVerifyCommands.staticCommands,
-        parsedCommands: parsedFrontendVerifyCommands.staticCommands,
-        adapterCommands: adapterVerifyCommands,
-    });
-    const partitionedStaticVerifyCommands = partitionFrontendStaticVerifyCommands({
-        repoRoot: sources.repoRoot,
-        commands: staticVerifyCommands.commands,
-        commandSource: staticVerifyCommands.commandSource,
-    });
-    const behaviorVerifyCommands = chooseFrontendVerifyCommands({
-        explicitCommands: explicitFrontendVerifyCommands.behaviorCommands,
-        parsedCommands: parsedFrontendVerifyCommands.behaviorCommands,
-        adapterCommands: adapterVerifyCommands,
-        // A declared task verifier owns this task's verification boundary. A
-        // static-only task must not inherit unrelated root-level test commands.
-        allowAdapter: !hasDeclaredFrontendVerification,
-    });
+    // Implementation verifies buildability only. Tests (including task-declared
+    // and Mock commands) belong to the independent frontend-test workflow.
+    // Keep a real failing command when build is unavailable; never use a no-op.
+    const buildCommands = [{
+            label: "build",
+            args: ["bash", "-lc", "npm run build"],
+            cwd: sources.repoRoot ?? process.cwd(),
+        }];
     const staticShellCommands = buildVerifyShellCommands({
-        repoRoot: sources.repoRoot,
-        commands: partitionedStaticVerifyCommands.static.commands,
-        fallbackCommands: staticFallbackCommands,
-    });
-    const lintShellCommands = buildVerifyShellCommands({
-        repoRoot: sources.repoRoot,
-        commands: partitionedStaticVerifyCommands.lint.commands,
-        fallbackCommands: [],
+        repoRoot: sources.repoRoot ?? process.cwd(), commands: buildCommands, fallbackCommands: [],
     });
-    const behaviorShellCommands = buildVerifyShellCommands({
-        repoRoot: sources.repoRoot,
-        commands: behaviorVerifyCommands.commands,
-        fallbackCommands: hasDeclaredFrontendVerification
-            ? []
-            : behaviorFallbackCommands,
-    });
-    const effectiveBehaviorFallbackCommands = hasDeclaredFrontendVerification
-        ? []
-        : behaviorFallbackCommands;
     const staticVerifyEvidence = buildVerifyEvidence({
-        phase: "intermediate",
-        quota: strategy.intermediateQuota ?? "full",
-        commandSource: partitionedStaticVerifyCommands.static.commandSource,
-        commands: partitionedStaticVerifyCommands.static.commands,
-        fallbackCommands: staticFallbackCommands,
-        commandTexts: staticShellCommands,
-        commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
-        preflight: sources.verificationPreflight,
+        phase: "final", quota: "full", commandSource: "inline",
+        commands: buildCommands, fallbackCommands: [], commandTexts: staticShellCommands,
+        finalFullRequired: true, commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
     });
-    const lintVerifyEvidence = lintShellCommands.length > 0
-        ? buildVerifyEvidence({
-            phase: "intermediate",
-            quota: strategy.intermediateQuota ?? "full",
-            commandSource: partitionedStaticVerifyCommands.lint.commandSource,
-            commands: partitionedStaticVerifyCommands.lint.commands,
-            fallbackCommands: [],
-            commandTexts: lintShellCommands,
-            commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
-            preflight: sources.verificationPreflight,
-        })
-        : undefined;
+    const behaviorShellCommands = [];
+    const lintShellCommands = [];
+    const mockShellCommands = [];
     const behaviorVerifyEvidence = buildVerifyEvidence({
-        phase: "final",
-        quota: "full",
-        commandSource: behaviorVerifyCommands.commandSource,
-        commands: behaviorVerifyCommands.commands,
-        fallbackCommands: effectiveBehaviorFallbackCommands,
-        commandTexts: behaviorShellCommands,
-        finalFullRequired: true,
+        phase: "final", quota: "full", commandSource: "inline",
+        commands: [], fallbackCommands: [], commandTexts: [],
         commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
-        preflight: sources.verificationPreflight,
     });
-    const mockVerifyTemplate = mockMode === "required" && hasMockVerifyCommands
-        ? buildFrontendMockVerifyNode(frontendSources, implementId, readOnlyPaths, forbiddenPaths)
-        : undefined;
-    const mockShellCommands = mockVerifyTemplate?.shell?.commands ?? [];
-    const mockVerifyEvidence = mockVerifyTemplate?.shell?.verifyEvidence;
     // Contract v2: the frozen command directory is the only command reference
     // the plan may use. Modes are assigned here once from the generation-time
     // lane split; downstream materialization resolves the same directory from
@@ -3216,28 +3127,23 @@ async function buildFrontendHybridDagFromTask(sources) {
     const frontendVerifyDirectory = buildFrontendVerifyCommandDirectory({
         staticLabels: staticVerifyEvidence.commandLabels,
         behaviorLabels: behaviorVerifyEvidence.commandLabels,
-        mockLabels: mockVerifyEvidence?.commandLabels ?? [],
+        mockLabels: [],
         staticCommandTexts: staticVerifyEvidence.commandTexts,
         behaviorCommandTexts: behaviorVerifyEvidence.commandTexts,
-        mockCommandTexts: mockVerifyEvidence?.commandTexts ?? [],
+        mockCommandTexts: [],
     });
     const fixedVerificationContext = [
         "## Fixed frontend verification entrypoints",
-        "These shell entrypoints are fixed at DAG generation and are the only commands the static and behavior shell nodes execute. A strategy or plan may add tests behind an existing entrypoint inside writeSet, but must not invent or replace commands or assume subtask_prompt executes a command.",
+        "Implementation verification is npm run build only. Map requirements to implementation files and the shared static build target. Test design, test execution, behavior correctness, edge cases, regression, accessibility and Mock-backed testing are deferred to the independent frontend-test workflow; missing test plans or test evidence never block this implementation workflow.",
         "Reference frozen commands ONLY by commandId (record_plan_verification_target entry.commandId). The runtime resolves mode and label; never invent a mode or type.",
         ...frontendVerifyDirectory.map((entry) => `  - ${entry.commandId} [${entry.mode}]: ${JSON.stringify(entry.label)}`),
         `- Static command source: ${staticVerifyEvidence.commandSource}`,
         `- Behavior command source: ${behaviorVerifyEvidence.commandSource}`,
     ].join("\n");
     const advisories = [];
-    if (!hasDeclaredFrontendVerification &&
-        fallbackVerifyCommands.staticCommands.length === 0 &&
-        fallbackVerifyCommands.behaviorCommands.length === 0) {
-        advisories.push("未发现可用的前端验证命令：目标项目没有可读取的 package.json scripts，也未探测到本地 TypeScript，verify 节点将没有静态/行为命令可执行。请在 task.json --verify 或执行约束.md 的验证约束中显式声明命令（例如 node --check src/app.js），然后重新生成 DAG。");
-    }
     if (frontendSourceMentionsMock(frontendSources) &&
         frontendMockStrategyMustBeNotNeeded(frontendSources)) {
-        advisories.push("auto 模式已将 Mock 策略收窄为 not-needed：任务源提到接口/API/Mock 需求，但仓库无确认 Mock 能力或无确定性 Mock 验证命令。若项目规范要求 Mock，请声明 frontendMock.verifyCommands 或 policy:required 后重新生成 DAG。");
+        advisories.push("auto 模式已将 Mock 策略收窄为 not-needed：任务源提到接口/API/Mock 需求，但仓库无确认 Mock 能力。若项目规范要求 Mock，请确认项目 Mock 能力与 policy:required 后重新生成 DAG。");
     }
     const openspecGate = await resolveFrontendOpenspecGateConfig(sources);
     const requiresOpenspecClassification = openspecGate.openspecPolicy === "cited" &&
@@ -3349,7 +3255,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Consume the complete injected input scope and produce a concise frontend implementation contract as typed requirement facts from complete injected scopes.",
                     "Confirm each requirement by the SAME id as the ledger canonical requirement it covers (sourceBinding.requirementIds, e.g. AC-001) — do NOT invent new REQ/BR prefixed ids for canonical requirements: the compiled contract must match the ledger canonical requirement ids exactly or schema validation rejects it (unknown requirement id). record_requirement takes the canonical id and optional execution:{groupId,kind,summary}; the runtime commits the authoritative text and sourceFragmentIds from the frozen ledger. Never pass text/statement/sourceFragmentIds yourself — model rewrites and JSON-stringified fragment arrays are rejected.",
                     "Requirement semantics, source spans, dispositions, and fragment bindings are ledger/runtime-owned. If a canonical requirement is genuinely blocked, say so in the Markdown contract narrative and finalize with the matching disposition instead of trying to encode it in the requirement fact.",
-                    "Register evidence expectations for each requirement across static, behavior, Mock, and real integration as required | optional | not-applicable; required must follow from user requirements, task risk, or project governance, never from model convenience. For UI-visible or interactive requirements, register a non-blocking frontend-test handoff intent.",
+                    "Register source evidence expectations without treating them as this implementation run's test gates. Always register a non-blocking frontend-test handoff intent for behavior, regression, Mock, and integration testing. This run checks requirement implementation coverage and npm run build only; test methods and results belong to the separate testing workflow.",
                     'Use record_evidence_expectation with {requirementId,evidence:{static,behavior,mock,"real-integration"}}; every lane is required | optional | not-applicable. Requirement text and provenance remain runtime-owned.',
                     'Before finalize_contract ready, call record_required_deliverables once with the complete {items:[{path,requirementId,sourceFragmentId}]} inventory, or {items:[]} when no file delivery is mandatory. Interpret the original source, including lists and tables: allowedPaths/only-allowed-to-modify is permission, not an obligation; do not promote prohibited files, examples or references into deliverables. Paths must occur exactly in a frozen source fragment bound to that canonical requirement. Correct the whole inventory before finalizing if needed.',
                     "Authoritative UI states: when the task source declares a UI-state table (state id / trigger / observable outcome), extract it VERBATIM through record_ui_state, one call per state, using the source's own state ids. The planner must bind these ids later — do not rename, merge, or invent states.",
@@ -3409,10 +3315,10 @@ async function buildFrontendHybridDagFromTask(sources) {
                 },
                 outputContract: "Typed decision patch only: map frozen requirements to implementation/verification targets and select the needed component, state, data/Mock, styling, and dependency decisions. Use only the record_* tools needed to express those decisions, then call finalize_plan; correct rejected facts until one successful terminal. Contract owns requirement semantics; Scout owns repository discovery; deterministic runtime owns schema, protected fields, path containment, and command validation. No Markdown narrative or file writes.",
                 subtask_prompt: [
-                    "Plan only the delta between the frozen frontend-contract-pi facts and frontend-scout-pi target surface. Do not reinterpret the task, repeat requirements, search the repository, or choose implementation order.",
+                    "List the implementation plan from frozen Contract requirements and Scout paths: what to change, where, and the needed component/state/data decisions. Submit those concrete actions in finalize_plan implementationSteps: [{requirementIds, action}]; cover every frozen requirement, sharing steps across related IDs when appropriate. Do not design tests, prescribe DOM harnesses, or require test evidence.",
                     "Record only: requirement-to-file/verification coverage; component/styling choices; applicable UI state and interaction behavior; data/Mock strategy; and a dependency policy or genuine evidence gap. Reuse Scout paths. If scope is missing, record a blocking gap instead of inventing a path.",
                     "Use the typed tool schemas as the field contract. Runtime owns schemaVersion, sourceBinding, riskLevel, targets.files, mockApi.productionDefaultOff, aliases, command allowlisting, path containment, and final validation; do not restate those rules or emit a full JSON contract.",
-                    `Cover each frozen requirement ID exactly once: ${requirementIds.join(", ") || "(none)"}. Bind every verification target to a frozen commandId from the directory above plus a Scout-confirmed file. Behavior commands prove observable behavior: one target may cover multiple related requirementIds when one test behavior proves them together; do not mechanically create one target per requirement. A behavior target id is the stable machine trace token and its file must be a test file. Static commands are project-wide checks traced by file and command only.`,
+                    `Cover each frozen requirement ID exactly once: ${requirementIds.join(", ") || "(none)"}. Bind every verification target to a frozen commandId from the directory above plus a Scout-confirmed file. Use the shared static build target for implementation files; do not create behavior test targets or test plans. Static commands are project-wide checks traced by file and command only.`,
                     "UX vocabulary protocol: record_state_registry FIRST with the full global vocabulary — one stable kebab-case behavior-domain name per UI state/interaction (e.g. planner-task-edit, focus-queue-move), never one name per AC number and never a rename of an already-recorded concept. Details consume complete execution-group scopes and reuse the same global names across scopes. Constraints/exclusions must not manufacture UI. Then record_state_flow entries whose names all come from that registry; uiState names must use the contract's declared authoritative ids (declaredUiStates in the plan input) when present. Retry attempts see committedUx in this input — reuse those exact names. Components: one choice may cover many state/interaction ids via covers; reuse-existing requires evidencePath naming an existing repo file (greenfield must be decision=new).",
                     ...(requiresOpenspecClassification ? ["When a component choice uses an OpenSpec selection, cite that selection; otherwise do not classify unrelated candidates."] : []),
                     "Call finalize_plan; correct rejected facts until one successful terminal after the necessary typed facts. Return no Markdown narrative.",
@@ -3457,7 +3363,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                                     "request-adapter",
                                     "not-needed",
                                 ],
-                        mockCommandLabels: mockVerifyEvidence?.commandLabels ?? [],
+                        mockCommandLabels: [],
                         artifactName: "frontend-implementation-contract.json",
                         outputDir: "contracts",
                         requireSourceFreshness: true,
@@ -3501,15 +3407,15 @@ async function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_DESIGN_REVIEW_SKILLS,
                 outputContract: "Authoritative typed design terminal via approve_design / request_design_changes tools. No JSON verdict; the committed typed design fact is the only authority. No file writes.",
                 subtask_prompt: [
-                    "Submit findings individually with record_design_finding and stable IDs; terminal tools aggregate saved findings. Correct rejected calls, stop after a successful terminal. Check execution groups against every member source outcome, including permission, threshold and failure-path differences; shared verification is valid only when it proves each independent AC.",
+                    "Submit findings individually with record_design_finding and stable IDs; terminal tools aggregate saved findings. Correct rejected calls, stop after a successful terminal. Check execution groups against every member source outcome, including permission, threshold and failure-path differences; each independent AC needs corresponding planned implementation; shared build evidence checks buildability only.",
                     "Audit the frontend plan before implementation. frontend-plan-pi is emitted to you as canonical full-contract JSON after the runtime applied and validated the planner's editable patch against its protected skeleton; there is no separate plan prose.",
                     "Your authoritative terminal verdict is exactly one committed typed tool call: approve_design or request_design_changes. Call exactly one of them; after calling one, do not call the other.",
                     "request_design_changes must carry a typed issueCategory, at least one evidenceRef, and non-empty findings.",
                     "Your verdict is consumed as deterministic data input by frontend-writer-admission-shell. approve_design permits admission; request_design_changes blocks writer admission until a recovery plan incorporates every Critical/Important finding.",
-                    "Request design changes when the Mock strategy is blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for a declared behavior target or selected Mock strategy. Mock strategies require Mock-backed evidence; a static-only contract is allowed only when every verification target is static and maps to a declared static entrypoint; not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists, in which case the plan must preserve the real request path and record the Real Integration Gap.",
-                    "Also request design changes for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
+                    "Request design changes only for missing requirement implementation coverage or unauthorized scope/dependencies. Preserve declared production-default-off Mock boundaries. Missing test methods, test cases, DOM/state-transition verification, Mock-backed evidence or behavior correctness evidence are not design blockers; defer them to frontend-test.",
+                    "Check whether every required feature/state has an implementation plan and whether paths and dependencies are authorized. Do not turn behavior correctness or regression concerns into implementation blockers; record them for frontend-test.",
                     "Component selection conformance is a hard blocking condition: request_design_changes when the frontend spec (component/theme/rule.components bucket) already defines a component for a purpose but the plan selects another or self-invents one without a declared deviation; when uiComponentChoices is missing/empty for UI-visible work while the frozen component/theme bucket is non-empty; when a decision=specified specReference.path is missing a ledger OpenSpec reference or successful read event; or when a decision=new component lacks a traceable task-source/PRD specReference. A PRD reference for decision=new is not an OpenSpec citation and must not be rejected merely for lacking an OpenSpec read event. For uiComponentChoices, purpose is the stable coverage key and must match interaction.name or uiState.name; responsibility is expressed by the matched expectedBehavior plus rationale, and you must not reject it merely for matching an interaction or component identifier.",
-                    "You must NOT make authoritative assertions about the execution result of frozen verification commands: command results are deterministically established by frontend-verify-shell. Record a verification-feasibility concern only as a non-blocking finding (severity must not be Critical, and it must never be the sole fatal basis for request_design_changes). Only semantic design defects (component selection, state flow, interaction contract, or conflicts with the specification) may be Critical; a pure command-will-fail prediction must not be classified as contract-requirement-gap.",
+                    "The only executable verification in this workflow is npm run build. A missing test plan, missing behavior evidence, or prediction that tests will fail is non-blocking and belongs to frontend-test. Only requirement omissions, scope violations and a failed build block implementation completion.",
                     "Read-only: do not modify repository files.",
                     "LARGE-FILE AUDIT (avoid full reads): style/theme audit files can be large (e.g. styles.css is often hundreds of KB). Prefer grep to locate the exact rules/variables you must verify (e.g. grep the oc- class, is-* modifier, or --oc- theme variables with their line numbers), then read only the narrow line range when surrounding context is needed. Do not read a large style/test file in full — a single full read can exhaust the read budget and fail the attempt.",
                     "Canonical contract reading: frontend-design-policy-shell prints absolute paths for Contract, Contract index, and the non-blocking Capacity diagnostic. Read the capacity diagnostic first. When it recommends full-contract, read the exact Contract path. When it recommends indexed-sections, read the Contract index and its hash-bound section files instead of opening the full contract. Never resolve a bare contracts/... path against the repository root or hunt for substitutes. Implementation target files inside the writeSet are created later by the implement node: do not read them and do not treat their absence as a design defect.",
@@ -3535,11 +3441,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     frontendWriterAdmission: {
                         schemaVersion: 1,
                         designReviewFromNodeId: "frontend-design-review-pi",
-                        frozenCommandLabels: [
-                            ...staticVerifyEvidence.commandLabels,
-                            ...behaviorVerifyEvidence.commandLabels,
-                            ...(mockVerifyEvidence?.commandLabels ?? []),
-                        ],
+                        frozenCommandLabels: staticVerifyEvidence.commandLabels,
                         allowedMockStrategies: taskConfig.frontendMock?.policy === "disabled" ||
                             frontendMockStrategyMustBeNotNeeded(frontendSources)
                             ? ["not-needed"]
@@ -3555,12 +3457,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                                     "request-adapter",
                                     "not-needed",
                                 ],
-                        ...(lintShellCommands.length > 0 && lintVerifyEvidence
-                            ? {
-                                lintCommands: lintShellCommands,
-                                lintEvidence: lintVerifyEvidence,
-                            }
-                            : {}),
                     },
                     cwd: ".",
                     timeoutMs: 60000,
@@ -3576,18 +3472,16 @@ async function buildFrontendHybridDagFromTask(sources) {
                     forbiddenPaths,
                     writerOutcomePolicyType: "frontend-facts-v1",
                 }),
-                outputContract: "The implementation status is derived by the executor from mechanical facts (write-tool events, run delta, write guard, requirement coverage, focused-check), not from any IMPLEMENTATION_OUTCOME first line. Deliver a Markdown 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.",
+                outputContract: "The executor derives implementation status from write events, diff, write guard and build checks. Report changed files, requirement-to-code coverage, build result and pending frontend-test handoff; do not claim tested behavior correctness.",
                 subtask_prompt: [
                     "Implement against the validated run-owned Frontend Implementation Contract materialized by frontend-design-policy-shell (path/schema/hash) and authorized by frontend-writer-admission-shell. Do not rebuild the contract from Markdown alone.",
                     "WRITER TOOL PROTOCOL (hard): the response text is not delivery. Never paste source code, test code, or full file contents into chat. After reading the canonical contract, make the first implementation change with the structured write/edit tool (one file per call); continue writing through those tools until the writeSet is complete. If a write/edit tool is unavailable, stop and report the blocked capability instead of drafting code in the response.",
                     "The canonical contract already contains the approved requirement, target-file, UI-state, verification, design, and Mock/API decisions. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, or design-review prose, and do not repeat broad repository research. Inspect only contract target files and directly related local code needed to implement them.",
-                    "Execute in fixed stages and report each in the delivery summary: (1) Contract confirm, (2) Tests sync, (3) Component/UI state implementation, (4) API/Mock wiring per contract.mockApi, (5) Focused checks behind frozen entrypoints only, (6) Diff cleanup.",
-                    "Map every requirement id, expectedOutcome, interaction trigger/expectedBehavior, and applicable UI state from the contract to concrete files. Do not invent shell verification commands; only frozen static/behavior entrypoints will run.",
-                    "For every behavior verification target, treat target.id as a stable trace token and include that exact token in a real describe/it/test literal title (for example, it('[VT-DASHBOARD-SHELL] renders the dashboard', ...)). One test title may carry multiple target ids when it proves multiple grouped behaviors; comments and ordinary strings do not count as trace evidence.",
-                    "Before reporting Tests Changed as done, self-audit with the executor's rule: collect ONLY the string literals passed directly to describe(/it(/test( calls in each test file and confirm every behavior target id for that file appears inside one of those literals. A token in a comment, a variable, or a non-title string does not satisfy the trace check; if any id is missing from the literal titles, edit the title strings before finishing.",
+                    "Implement the planned requirements and report where each is realized. Do not add a test-first stage or require tests for completion. The independent frontend-test workflow owns tests; the only frozen command here is npm run build.",
+                    "Map every requirement id, expectedOutcome, interaction and applicable UI state to concrete implementation files. The shared static build target is a buildability check, not proof of behavior correctness.",
                     "Begin implementation after the contract and its target files are confirmed. Do not spend the turn collecting optional context. If the canonical contract lacks behavior needed to edit safely, stop and state the blocking reason in the summary instead of reopening broad discovery.",
                     "Your implementation status is derived by the executor from mechanical facts (persisted write-tool events, run delta, write guard, requirement coverage, focused-check failures), never from any IMPLEMENTATION_OUTCOME first line. Do not emit an IMPLEMENTATION_OUTCOME first line.",
-                    "The node runs a bounded micro-loop: after each write attempt the executor re-runs frozen focused checks and records a per-round diff checkpoint; the write guard stays active every round. Only repair local issues attributable to the current diff (syntax/type/import/format/unit-assert/obvious omission). Never change requirements, design, writeSet, or verification strictness inside the loop.",
+                    "The node uses bounded build checks and diff checkpoints. Repair local syntax/type/import/build errors within the writeSet; do not expand into behavior testing, regression testing or test repair.",
                     "Implement only the approved Mock strategy carried by the validated contract. Preserve the real request path as the default, require explicit test/dev activation, and never comment out or replace the real request with inline data.",
                     "frontend-design-policy-shell materialized and validated the canonical contract; frontend-writer-admission-shell authorized the writeSet. Stay within writeSet and preserve unrelated files.",
                     "For native, browser-intercept, or request-adapter, implement contract-aligned fixtures/states and a dev/test-only activation boundary in this same writer. For not-needed, do not add Mock files or a framework and state the positive reason.",
@@ -3595,7 +3489,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Edit existing files with the structured edit/write tools. NEVER rewrite Markdown (or any file with quoting/backticks/indentation-sensitive content) via bash sed/awk/echo redirection: escaping mistakes silently corrupt the file and self-repair loops burn the run.",
                     ...(implementPaths.docIndexCompanions.length > 0
                         ? [
-                            `Doc index sync is MANDATORY: ${implementPaths.docIndexCompanions.join(", ")} are catalog index files for this writeSet. When you add, rename, or remove any indexed file, you MUST also update ${implementPaths.docIndexCompanions.join(" and ")} in the same run (append or fix the matching index entry following the existing line style). Verification runs check-doc-index and fails the run when a new file is missing from the index.`,
+                            `Doc index sync is MANDATORY: ${implementPaths.docIndexCompanions.join(", ")} are catalog index files for this writeSet. When you add, rename, or remove any indexed file, you MUST also update ${implementPaths.docIndexCompanions.join(" and ")} in the same run (append or fix the matching index entry following the existing line style). Keep these index updates within the authorized writeSet.`,
                         ]
                         : []),
                     writerDeliveryContract(taskConfig),
@@ -3612,7 +3506,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Run frozen Mock/static/behavior commands and materialize the verification trace. Any failure is terminal: no same-run repair branch, failure ownership facts are materialized for recovery.",
+                outputContract: "Run npm run build and preserve its exit status. No test, lint or separate typecheck commands; any build failure remains terminal and eligible for existing bounded recovery.",
                 subtask_prompt: "Execute the frontend verification bundle. Preserve per-command evidence; a failure fails this node (terminal) and routes to recovery.",
                 shell: {
                     commands: [],
@@ -3622,8 +3516,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                         lintCommands: lintShellCommands,
                         staticCommands: staticShellCommands,
                         behaviorCommands: behaviorShellCommands,
-                        mockEvidence: mockVerifyEvidence,
-                        lintEvidence: lintVerifyEvidence,
                         staticEvidence: staticVerifyEvidence,
                         behaviorEvidence: behaviorVerifyEvidence,
                         lintBaselineNodeId: lintShellCommands.length > 0
@@ -3667,20 +3559,20 @@ async function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_REVIEW_SKILLS,
                 outputContract: 'Authoritative typed review terminal via approve_review / request_review_changes tools. No JSON verdict is required in the response text; the typed terminal fact is the only authority. No file writes.',
                 subtask_prompt: [
-                    "Submit findings individually with record_review_finding and stable IDs; terminal tools aggregate saved findings. Correct rejected calls, stop after a successful terminal. Check execution groups against every member source outcome, including permission, threshold and failure-path differences; shared verification is valid only when it proves each independent AC.",
-                    "Review the frontend implementation and verification evidence.",
+                    "Submit findings individually with record_review_finding and stable IDs; terminal tools aggregate saved findings. Correct rejected calls, stop after a successful terminal. Check execution groups against every member source outcome, including permission, threshold and failure-path differences; each independent AC needs corresponding planned implementation; shared build evidence checks buildability only.",
+                    "Check requirement-to-code coverage, authorized files/dependencies and the npm run build result. Behavior correctness, edge cases, regressions and test design/execution belong to frontend-test; their missing evidence is not a blocker here.",
                     "Your authoritative terminal verdict is exactly one committed typed tool call: approve_review or request_review_changes. Call it once and do not call the other afterwards.",
                     "approve_review means the implementation passes; it must not carry Critical or Important findings. request_review_changes must carry a typed issueCategory, at least one evidenceRef, and non-empty findings.",
                     "Do NOT emit an equivalent JSON verdict in the response text: the committed typed terminal fact is the only authority and no branch or gate reads response-text JSON verdicts.",
                     "Read contracts/frontend-review-context.json from frontend-review-context-shell. It binds a hash-verified canonical contract reference, a field-to-section index, frontend lint assessment when configured, the effective verification trace, and the run-owned actual diff. Read contractRef.capacityDiagnosticPath first: use contractRef.path only when full-contract is recommended; otherwise read only the hash-bound contractRef.sections needed for the changed surface and verification claims. Then read diff.reviewSummaryPath. The full artifacts/diff_patch.patch is retained only as audit evidence: do NOT read it in full. For semantic review, read only the named per-file diff fragment in the summary/index (in part order when needed) and then the current source file when necessary. Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/stable-target-id binding only—not semantic correctness.",
-                    "Treat lint status exactly as passed | baseline-debt | failed | unavailable. baseline-debt may continue only with intact evidence and zero diagnostics on writer-changed files; report the tolerated debt count and never rewrite it as lint passed. Typecheck, build, and test still require successful final exits.",
+                    "This run requires only a successful npm run build exit. Other test/lint/typecheck evidence is not required. Do not claim absent evidence passed; report independent testing as not-run.",
                     "Flag .skip/.only, deleted or weakened tests, unauthorized config changes, Mock-only evidence claimed as real integration, and Browser/visual claims (always not-run in this workflow).",
                     "The contract referenced and hash-bound by frontend-review-context.json is the effective plan materialized by frontend-design-policy-shell. Do not re-open task sources, OpenSpec, AI workspace, design-review, writer summary, or verification node prose. Inspect only the canonical review context, its indexed contract sections, its bound diff, and diff-referenced files when semantic review requires source code.",
                     "For uiComponentChoices, purpose is the stable coverage key and must match interaction.name or uiState.name. Responsibility is expressed by the matched expectedBehavior plus rationale; you must not reject it merely for matching an interaction or component identifier.",
-                    "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case verify that the real request remains the default and the Real Integration Gap is preserved.",
+                    "Check implementation of source requirements and declared production Mock isolation in the diff. Missing Mock-backed or real API test evidence is a non-blocking frontend-test handoff, not an implementation rejection.",
                     "Inspect the frontend-verify-shell evidence in the review context directly, including the production/default-real-path static check, and require Mock activation to be off for that check.",
                     "Distinguish Mock-backed evidence from real API integration evidence and preserve the Real Integration Gap when the backend was not exercised.",
-                    "Review implementation quality, behavior/state coverage, verification evidence, and maintainability. Read-only: do not modify files.",
+                    "Review requirement implementation coverage and write authorization. Runtime behavior correctness and quality testing are deferred to frontend-test. Read-only: do not modify files.",
                 ].join("\n\n"),
             },
             {

package/docs/templates/frontend-implementation-dag.json

@@ -6,10 +6,11 @@
   "successCriteria": [
     "The contract covers every required user-visible behavior, state, and interaction.",
     "The implementation is admitted only after a concrete, narrow writeSet is reviewed.",
-    "Static and behavior verification are recorded before final review.",
+    "Build verification are recorded before final review.",
     "The final closeout distinguishes passed, not-run, and residual-risk evidence."
   ],
   "globalConstraints": [
+    "frontend-implementation plans and reviews requirement implementation coverage; npm run build is the only verification command. Tests and behavior correctness are deferred to frontend-test, non-blocking; preserve existing tests and production Mock isolation.",
     "This is a self-contained static template: do not generate, import, or merge a DAG from a runtime builder before execution.",
     "Replace every REPLACE/WITH/... placeholder with concrete repository paths or deterministic commands before execution.",
     "Do not commit runtime traces under .harness/dag-runs/.",
@@ -38,7 +39,7 @@
     {
       "id":"frontend-plan-pi", "depends_on":["frontend-scout-pi"], "complexity":"MED", "executor":"pi", "role":"planner", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/SOURCE/PATH/**","REPLACE/WITH/FRONTEND/TEST/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
       "outputContract":"Plan record_* tools for scoped coverage, shared execution groups and UX, one mock endpoint per record, then one successful finalize_plan. Runtime derives canonical JSON and Markdown. No file writes.",
-      "subtask_prompt":"Turn the contract and reconnaissance into a minimal implementation plan. Every target file and verification step must be concrete. Preserve existing design and accessibility conventions. If any behavior lacks a verifiable target, report it as blocked instead of guessing."
+      "subtask_prompt":"List the requirement implementation plan: what to change and in which authorized files. Map requirements to the shared static build target. Do not require test plans or behavior correctness evidence; tests may be added later in frontend-test."
     },
     {
       "id":"frontend-design-policy-shell", "depends_on":["frontend-plan-pi"], "complexity":"LOW", "executor":"shell", "role":"verifier", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/SOURCE/PATH/**","REPLACE/WITH/FRONTEND/TEST/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
@@ -49,7 +50,7 @@
     {
       "id":"frontend-design-review-pi", "depends_on":["frontend-design-policy-shell"], "complexity":"MED", "executor":"pi", "role":"reviewer", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/SOURCE/PATH/**","REPLACE/WITH/FRONTEND/TEST/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
       "outputContract":"record_design_finding for individual findings; approve_design or request_design_changes provides the sole committed terminal. Independently review execution-group member differences. No file writes.",
-      "subtask_prompt":"Review the approved plan against the frontend contract and design-policy result. Reject missing visible states, interaction behavior, accessibility obligations, or unsupported design claims. Do not edit files."
+      "subtask_prompt":"Review the approved plan against the frontend contract and design-policy result. Reject missing visible states, interaction behavior, accessibility obligations, or unsupported design claims. Do not edit files. Scope: requirement implementation coverage and authorized paths/dependencies only; do not require test plans, tests or behavior correctness evidence. Preserve existing tests. Only npm run build is required; test work is deferred to frontend-test."
     },
     {
       "id":"frontend-writer-admission-shell", "depends_on":["frontend-design-review-pi"], "complexity":"LOW", "executor":"shell", "role":"verifier", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
@@ -60,13 +61,13 @@
     {
       "id":"frontend-implement-pi", "depends_on":["frontend-writer-admission-shell"], "complexity":"HIGH", "executor":"pi", "role":"implementer", "toolProfile":"write", "writePolicy":"exclusive", "writeSet":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
       "outputContract":"Implementation summary with changed files, contract coverage, focused checks run, and residual risks.",
-      "subtask_prompt":"Implement only the admitted frontend changes. Preserve established component, styling, accessibility, and state-management conventions. Cover every approved behavior, state, and interaction, then report changed files and focused verification. Do not broaden writeSet or add undeclared dependencies."
+      "subtask_prompt":"Implement only the admitted frontend changes. Preserve established component, styling, accessibility, and state-management conventions. Cover every approved behavior, state, and interaction, then report changed files and focused verification. Do not broaden writeSet or add undeclared dependencies. Scope: requirement implementation coverage and authorized paths/dependencies only; do not require test plans, tests or behavior correctness evidence. Preserve existing tests. Only npm run build is required; test work is deferred to frontend-test."
     },
     {
       "id":"frontend-verify-shell", "depends_on":["frontend-implement-pi"], "complexity":"LOW", "executor":"shell", "role":"verifier", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
-      "outputContract":"Archived static and behavior verification output with command exit codes; no worktree writes.",
-      "subtask_prompt":"Run the contract-selected deterministic static and behavior verification commands. Record all exit codes. A failed required command is terminal for this DAG run; do not silently substitute a different command.",
-      "shell":{"preset":"loop-agent-standard-verify","cwd":".","timeoutMs":300000}
+      "outputContract":"Archived build verification output with command exit codes; no worktree writes.",
+      "subtask_prompt":"Run npm run build and record the actual exit code. Missing or failed builds must fail; never substitute a no-op.",
+      "shell":{"commands":["npm run build"],"cwd":".","timeoutMs":300000}
     },
     {
       "id":"frontend-review-context-shell", "depends_on":["frontend-verify-shell"], "complexity":"LOW", "executor":"shell", "role":"verifier", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
@@ -77,7 +78,7 @@
     {
       "id":"frontend-review-pi", "depends_on":["frontend-review-context-shell"], "complexity":"MED", "executor":"pi", "role":"reviewer", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],
       "outputContract":"record_review_finding for individual findings; approve_review or request_review_changes provides the sole committed terminal. No file writes.",
-      "subtask_prompt":"Review the actual diff and archived verification evidence against the frontend contract. Do not treat missing, weak, mock-only, or not-run evidence as passed. Report explicit residual risks; do not edit files."
+      "subtask_prompt":"Review the actual diff and archived verification evidence against the frontend contract. Do not treat missing, weak, mock-only, or not-run evidence as passed. Report explicit residual risks; do not edit files. Scope: requirement implementation coverage and authorized paths/dependencies only; do not require test plans, tests or behavior correctness evidence. Preserve existing tests. Only npm run build is required; test work is deferred to frontend-test."
     },
     {
       "id":"frontend-closeout-shell", "depends_on":["frontend-review-pi"], "complexity":"LOW", "executor":"shell", "role":"closeout", "writePolicy":"read-only", "allowedPaths":["REPLACE/WITH/FRONTEND/TARGET/PATH/**"], "forbiddenPaths":[".harness/**","artifacts/**"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.43.0-next.10",
+  "version": "0.43.0-next.11",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/frontend-bounded-implement/SKILL.md

@@ -35,15 +35,15 @@ canonical targets and do not authorize additional discovery.
 
 ## Implementation Discipline
 
-- Work test-first where behavior changes. Preserve unrelated files and stay inside
+- Implement the planned requirements without a test-first stage. Preserve existing tests and unrelated files; stay inside
   `allowedPaths` and `writeSet`.
 - Implement every requirement outcome, interaction, and applicable UI state
   assigned to the writer. Keep the real request path enabled by default and use
   only the approved Mock/API strategy.
 - Do not add dependencies unless the contract approves them. Never relax lint,
   type, test, or build configuration; never add `.skip` or `.only`.
-- Run only the focused checks already frozen by the task. Leave full verification
-  to downstream deterministic nodes.
+- Run only npm run build, frozen by this workflow. Do not add or run unit tests;
+  testing can be added later in the independent frontend-test workflow.
 
 ## Completion Summary
 

package/skills/frontend-bounded-implement/references/code-standards.md

@@ -4,16 +4,16 @@ Apply the canonical contract and the conventions visible in target files and the
 direct local dependencies. Do not reopen task sources, OpenSpec, `ai_workspace`, or
 unrelated repository areas to discover new rules or redesign approved decisions.
 
-- Work test-first when behavior changes and preserve unrelated behavior.
+- Implement requirement coverage and preserve existing tests and unrelated behavior.
 - Reuse existing public helpers, APIs, components, tokens, schemas, and test
   patterns that are directly available from the bounded target surface.
 - Keep rendering, transitions, validation, request lifecycle, errors, and side
-  effects testable; cover relevant races and boundaries.
+  effects clear; defer race and boundary tests to frontend-test.
 - Keep real API behavior enabled by default. Mock activation must follow the
   approved strategy, remain explicit and dev/test-only, and never import test mocks
   into production code.
 - Trace fixtures to the approved API/schema evidence and never store secrets.
 - Do not add unapproved dependencies, relax lint/type/test/build configuration,
   add `.skip`/`.only`, comment out real requests, or write outside `writeSet`.
-- Run only frozen focused checks and report their real status. Downstream shell
+- Run only npm run build and report its real status. Downstream shell
   verification remains authoritative.

package/skills/frontend-contract/references/contract-protocol.md

@@ -15,7 +15,9 @@
 
 - Register static, behavior, Mock, and real-integration evidence expectations as
   required, optional, or not-applicable. The classification follows the source and
-  risk; it is not selected for model convenience.
+  risk; it is not selected for model convenience. These are source expectations
+  for the non-blocking frontend-test handoff, not implementation test gates.
+  This implementation workflow executes only npm run build.
 - Register a non-blocking frontend-test handoff for UI-visible or interactive work.
 - Preserve exact command labels and referenced paths. Do not invent evidence,
   connector results, APIs, or verification commands.