@tea-agent/loop-agent 0.28.0 → 0.28.1-beta.1

package/dist/executors/dag-pi-executor.js

@@ -681,32 +681,19 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
 export function validateWriterImplementationOutcome(text, changedFiles) {
     const parsed = parseWriterImplementationOutcome(text);
     const diagnostics = writerOutcomeDiagnostics(text, parsed, changedFiles.length);
-    if (parsed.kind !== "valid") {
+    // The workspace diff is authoritative. The model outcome is advisory and
+    // may be missing, malformed, or inconsistent without blocking a completed
+    // writer. An explicit blocked signal remains a hard failure.
+    if (parsed.candidates.some((candidate) => candidate.outcome === "blocked")) {
         return {
             ok: false,
-            reason: `writer outcome validation failed: ${parsed.kind} outcome; ${diagnostics}; expected IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked`,
+            reason: `writer outcome validation failed: explicit blocked outcome; ${diagnostics}`,
         };
     }
-    const outcome = parsed.outcome;
-    if (outcome === "blocked") {
-        return {
-            ok: false,
-            reason: `writer outcome validation failed: IMPLEMENTATION_OUTCOME: blocked cannot complete successfully; ${diagnostics}`,
-        };
-    }
-    if (outcome === "changed" && changedFiles.length === 0) {
-        return {
-            ok: false,
-            reason: `writer outcome validation failed: changed outcome has an empty diff; ${diagnostics}`,
-        };
-    }
-    if (outcome === "already-satisfied" && changedFiles.length > 0) {
-        return {
-            ok: false,
-            reason: `writer outcome validation failed: already-satisfied outcome has a non-empty diff; ${diagnostics}`,
-        };
-    }
-    return { ok: true, outcome };
+    return {
+        ok: true,
+        outcome: changedFiles.length > 0 ? "changed" : "already-satisfied",
+    };
 }
 function parseWriterImplementationOutcome(text) {
     const lines = text.split(/\r?\n/);
@@ -837,6 +824,15 @@ function normalizeProtocolLine(line, firstProtocolLine, nextLine) {
         const value = normalizedProtocolValue(direct[1] ?? "");
         return value ? `${firstProtocolLine} ${value}` : undefined;
     }
+    // Writers sometimes place a short delivery sentence before the protocol
+    // line. Accept the protocol token when it appears inline, while preserving
+    // the candidate value so template repetitions still fail as unknown or
+    // conflicting outcomes.
+    const inline = normalizedLine.match(new RegExp(`${labelPattern}\\s*[:：]\\s*(.+)$`, "i"));
+    if (inline) {
+        const value = normalizedProtocolValue(inline[1] ?? "");
+        return value ? `${firstProtocolLine} ${value}` : undefined;
+    }
     const splitValue = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]?\\s*$`, "i"));
     if (splitValue && nextLine !== undefined) {
         const value = normalizedProtocolValue(nextLine);

package/dist/task/task-demand-routing.js

@@ -334,24 +334,10 @@ export function classifyTaskDemand(input) {
         });
     }
     const backendDelivery = titleSignals.backendDelivery || requirementSignals.backendDelivery;
-    const frontendProjectDefaultImplementation = hasStrongFrontendProjectEvidence &&
-        frontendPath &&
-        !hasBackendTaskType &&
-        !backendDelivery &&
-        !frontendNegated &&
-        !allowedPathsOnlyCoverNonProductArtifacts;
-    if (frontendProjectDefaultImplementation) {
-        addSignal(signals, {
-            id: "frontend-project-default-implementation",
-            source: "project",
-            message: "frontend project evidence selects the frontend implementation workflow by default",
-        });
-    }
     const frontendDelivery = titleSignals.frontendDelivery ||
         requirementSignals.frontendDelivery ||
         pathSupportedFrontendDelivery ||
-        projectSupportedFrontendDelivery ||
-        frontendProjectDefaultImplementation;
+        projectSupportedFrontendDelivery;
     if (allowedPathsOnlyCoverNonProductArtifacts && frontendDelivery) {
         blockers.push("non-product-allowed-paths");
     }

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

@@ -155,7 +155,7 @@ export const frontendImplementationContractSchema = z
             "not-needed",
         ]),
         productionDefaultOff: z.literal(true),
-        activation: z.string().min(1),
+        activation: z.preprocess((value) => (value === "" || value === null ? "explicit activation boundary" : value), z.string().min(1)),
         endpoints: z.array(z
             .object({
             method: z.enum([
@@ -168,7 +168,10 @@ export const frontendImplementationContractSchema = z
                 "OPTIONS",
             ]),
             path: z.string().startsWith("/"),
-            fixture: safePath.optional(),
+            // Models occasionally emit an empty fixture when Mock is
+            // intentionally not needed. Treat it like an omitted optional
+            // field; active Mock strategies still fail the refinement below.
+            fixture: z.preprocess((value) => (value === "" || value === null ? undefined : value), safePath.optional()),
             consumer: safePath.optional(),
         })
             .strict()),
@@ -187,7 +190,7 @@ export const frontendImplementationContractSchema = z
         type: z.enum(["static", "unit", "component", "integration", "mock"]),
         commandLabel: z.string().min(1),
         file: safePath,
-        symbol: z.string().min(1).optional(),
+        symbol: z.preprocess((value) => (value === "" || value === null ? undefined : value), z.string().min(1).optional()),
         requirementIds: z.array(id),
         uiStates: z.array(z.string().min(1)),
     })
@@ -343,12 +346,127 @@ function secretIssues(value, at = "$", issues = []) {
 }
 export function extractFrontendImplementationJson(text) {
     const trimmed = text.trim();
+    const parse = (source) => {
+        try {
+            return JSON.parse(source);
+        }
+        catch (error) {
+            // Models sometimes put ordinary ASCII quotes inside a JSON string
+            // (for example: `reason: "支持..."`). Repair only quotes that are
+            // clearly not structural: a closing quote is followed by JSON
+            // punctuation, while an embedded quote is followed by content.
+            let repaired = "";
+            let inString = false;
+            let escaped = false;
+            for (let index = 0; index < source.length; index += 1) {
+                const character = source[index];
+                if (character !== '"') {
+                    repaired += character;
+                    if (inString && character === "\\" && !escaped)
+                        escaped = true;
+                    else
+                        escaped = false;
+                    continue;
+                }
+                if (escaped) {
+                    repaired += character;
+                    escaped = false;
+                    continue;
+                }
+                if (!inString) {
+                    inString = true;
+                    repaired += character;
+                    continue;
+                }
+                const next = source.slice(index + 1).trimStart()[0];
+                if ([",", "}", "]", ":"].includes(next ?? "") || source.slice(index + 1).trim() === "") {
+                    inString = false;
+                    repaired += character;
+                }
+                else {
+                    repaired += "\\\"";
+                }
+            }
+            try {
+                return JSON.parse(repaired);
+            }
+            catch {
+                throw error;
+            }
+        }
+    };
+    const isContract = (candidate) => {
+        const record = asRecord(candidate);
+        return (record?.schemaVersion === 1 &&
+            asRecord(record.targets) !== null &&
+            Array.isArray(record.requirements) &&
+            Array.isArray(record.verificationTargets));
+    };
     if (trimmed.startsWith("{") && trimmed.endsWith("}"))
-        return JSON.parse(trimmed);
+        return parse(trimmed);
+    const balancedObjects = [];
+    for (let start = 0; start < trimmed.length; start += 1) {
+        if (trimmed[start] !== "{")
+            continue;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let index = start; index < trimmed.length; index += 1) {
+            const character = trimmed[index];
+            if (inString) {
+                if (escaped)
+                    escaped = false;
+                else if (character === "\\")
+                    escaped = true;
+                else if (character === '"')
+                    inString = false;
+                continue;
+            }
+            if (character === '"')
+                inString = true;
+            else if (character === "{")
+                depth += 1;
+            else if (character === "}" && --depth === 0) {
+                try {
+                    const candidate = parse(trimmed.slice(start, index + 1));
+                    if (candidate && typeof candidate === "object" && !Array.isArray(candidate))
+                        balancedObjects.push(candidate);
+                }
+                catch {
+                    // Continue scanning for a later complete JSON object.
+                }
+                break;
+            }
+        }
+    }
+    const balancedContracts = balancedObjects.filter(isContract);
+    if (balancedContracts.length === 1)
+        return balancedContracts[0];
+    if (balancedObjects.length === 1)
+        return balancedObjects[0];
     const blocks = [...trimmed.matchAll(/```json\s*\n([\s\S]*?)\n```/gi)];
-    if (blocks.length !== 1)
+    if (blocks.length === 0)
         throw new Error("output must contain exactly one fenced json object");
-    return JSON.parse(blocks[0][1]);
+    const candidates = [];
+    for (const block of blocks) {
+        try {
+            const candidate = parse(block[1]);
+            if (candidate && typeof candidate === "object" && !Array.isArray(candidate))
+                candidates.push(candidate);
+        }
+        catch {
+            // Ignore incomplete model scratch blocks. A later complete contract
+            // block may still be deterministically recoverable.
+        }
+    }
+    const contractCandidates = candidates.filter(isContract);
+    if (contractCandidates.length === 1)
+        return contractCandidates[0];
+    if (candidates.length === 1)
+        return candidates[0];
+    if (candidates.length === 0)
+        throw new Error("output must contain exactly one valid fenced json object (found 0)");
+    throw new Error(`output must contain exactly one valid frontend contract json object (found ${contractCandidates.length || candidates.length})`);
 }
 /**
  * Build the authoritative frontend-implementation-contract sourceBinding from

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

@@ -1,7 +1,8 @@
 import { readFile, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
 import path from "node:path";
 import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
-import { frontendImplementationContractSchema, materializeFrontendImplementationContract, assertFrontendSourceBindingFresh, } from "./frontend-implementation-contract.js";
+import { frontendImplementationContractSchema, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, materializeFrontendImplementationContract, assertFrontendSourceBindingFresh, } from "./frontend-implementation-contract.js";
 import { captureFrontendWorktreeBaseline } from "./frontend-worktree-diff.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 async function selectNode(runDir, primary, fallbacks) {
@@ -46,7 +47,12 @@ function firstNonEmptyVerdictLine(text) {
     // The prompt requires VERDICT to be the first non-empty line, but model
     // output can still prepend a summary. Keep the protocol strict in the
     // prompt while making the deterministic gate resilient to that drift.
-    return normalizedLines.find((line) => /^VERDICT:/.test(line)) ?? first;
+    const verdictLine = normalizedLines.find((line) => /^VERDICT:/.test(line)) ?? first;
+    if (/^VERDICT:\s*pass(?:\s*[.!?。！？]|\s+|$)/i.test(verdictLine))
+        return "VERDICT: pass";
+    if (/^VERDICT:\s*request-revision(?:\s*[.!?。！？]|\s+|$)/i.test(verdictLine))
+        return "VERDICT: request-revision";
+    return verdictLine;
 }
 function eventArgs(event) {
     return event.args ?? event.toolInput ?? event.input ?? {};
@@ -155,13 +161,20 @@ export async function runFrontendPrewriteGate(input) {
     if (missingIds.length > 0) {
         throw new Error(`frontend prewrite gate missing requirement ids: ${missingIds.join(", ")}`);
     }
-    const artifact = await materializeFrontendImplementationContract({
+    const artifactPath = path.join(input.runDir, input.config.outputDir, input.config.artifactName);
+    const artifact = await stat(artifactPath)
+        .then(async () => ({
+        path: artifactPath,
+        schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
+        sha256: createHash("sha256").update(await readFile(artifactPath)).digest("hex"),
+    }))
+        .catch(() => materializeFrontendImplementationContract({
         runDir: input.runDir,
         fromNodeId: planNodeId,
         artifactName: input.config.artifactName,
         outputDir: input.config.outputDir,
         sourceBinding: input.sourceBinding,
-    });
+    }));
     const raw = JSON.parse(await readFile(artifact.path, "utf8"));
     const contract = frontendImplementationContractSchema.parse(raw);
     if (!input.config.allowedMockStrategies.includes(contract.mockApi.strategy)) {
@@ -183,10 +196,11 @@ export async function runFrontendPrewriteGate(input) {
         reviewNodeId,
         repoRoot: workspaceRoot ?? process.cwd(),
     });
-    if (candidatePaths.length > 0 && openspecReadPaths.length === 0) {
-        const checkedNodes = [planNodeId, reviewNodeId].join(", ");
-        throw new Error(`openspec gate blocked: ${candidatePaths.length} candidate(s) [${candidatePaths.join(", ")}] not read by ${checkedNodes}; writer not authorized.`);
-    }
+    // OpenSpec is advisory design evidence, not an authorization boundary.
+    // Model read behavior is nondeterministic, and a missed read must not block
+    // a contract/schema/write-set-authorized implementation. Preserve any
+    // successful evidence for review context, while allowing unavailable
+    // evidence to be reported downstream.
     return {
         ok: true,
         planNodeId,

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

@@ -1,6 +1,5 @@
 import { createHash } from "node:crypto";
 import { access, readdir, readFile, realpath } from "node:fs/promises";
-import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { assertValidDagSpec } from "./validate.js";
@@ -1080,40 +1079,14 @@ function isFrontendLintVerifyCommand(command) {
     const text = `${command.label}\n${command.args.join(" ")}`;
     return /\b(?:lint|eslint)\b/i.test(text);
 }
-function isManagedCiWrapperVerifyCommand(command) {
-    const text = `${command.label}\n${command.args.join(" ")}`.replaceAll("\\", "/");
-    return /\bscripts\/ci(?:-tests)?\.sh\b/.test(text);
-}
-function repoHasNpmScript(repoRoot, scriptName) {
-    if (!repoRoot)
-        return false;
-    const packagePath = path.join(repoRoot, "package.json");
-    if (!existsSync(packagePath))
-        return false;
-    try {
-        const decoded = JSON.parse(readFileSync(packagePath, "utf8"));
-        return typeof decoded.scripts?.[scriptName] === "string";
-    }
-    catch {
-        return false;
-    }
-}
 function partitionFrontendStaticVerifyCommands(input) {
     const commands = input.commands ?? [];
-    const lintCommands = commands.filter(isFrontendLintVerifyCommand);
+    // Frontend DAGs deliberately never generate lint verification. Existing
+    // project lint debt is allowed to remain outside this workflow, and an
+    // explicitly mentioned lint command must not reintroduce the lint gate.
     const staticCommands = commands.filter((command) => !isFrontendLintVerifyCommand(command));
-    if (lintCommands.length === 0 &&
-        commands.some(isManagedCiWrapperVerifyCommand) &&
-        repoHasNpmScript(input.repoRoot, "lint")) {
-        lintCommands.push({
-            args: ["npm", "run", "lint"],
-            cwd: input.repoRoot,
-            label: "npm run lint",
-        });
-    }
     return {
         lint: {
-            ...(lintCommands.length > 0 ? { commands: lintCommands } : {}),
             commandSource: input.commandSource,
         },
         static: {
@@ -1212,7 +1185,6 @@ async function discoverFrontendFallbackVerifyCommands(repoRoot) {
     const staticCommands = firstExisting([
         "typecheck",
         "check-types",
-        "lint",
         "check",
         "build",
     ]);
@@ -2457,9 +2429,62 @@ async function buildFrontendHybridDagFromTask(sources) {
                     sourceContext,
                 ].join("\n\n"),
             },
+            {
+                id: "frontend-contract-json-pi",
+                depends_on: [
+                    "frontend-plan-revision-pi",
+                    "frontend-plan-pi",
+                    "frontend-final-design-review-pi",
+                    "frontend-design-review-pi",
+                ],
+                dependsPolicy: "all-or-condition-skip",
+                role: "planner",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                outputMode: "structured-required",
+                retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                skills: FRONTEND_IMPLEMENTATION_SKILLS,
+                outputContract: "Return exactly one JSON object conforming to frontend-implementation-contract-v1. No Markdown, prose, comments, or code fences.",
+                subtask_prompt: [
+                    "Convert the effective reviewed frontend plan into the canonical frontend-implementation-contract-v1 JSON.",
+                    "Use frontend-plan-revision-pi when it is FINISHED; otherwise use frontend-plan-pi. Confirm the effective design review passed before producing the contract.",
+                    "Return only the JSON object. Do not wrap it in Markdown or a code fence. Do not add explanatory text.",
+                    "Preserve all requirement expectedOutcome, interaction trigger/expectedBehavior, target files, verification targets, Mock/API decisions, and Real Integration Gap from the effective plan.",
+                    frontendContractSchemaBlock,
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-contract-json-validate-shell",
+                depends_on: ["frontend-contract-json-pi"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Validated frontend implementation contract artifact with schema ID and SHA-256.",
+                subtask_prompt: "Materialize and validate the structured frontend contract before prewrite authorization.",
+                shell: {
+                    commands: [],
+                    jsonArtifactGate: {
+                        fromNodeId: "frontend-contract-json-pi",
+                        schemaId: "frontend-implementation-contract-v1",
+                        artifactName: "frontend-implementation-contract.json",
+                        outputDir: "contracts",
+                    },
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            },
             {
                 id: "frontend-prewrite-gate-shell",
                 depends_on: [
+                    "frontend-contract-json-pi",
+                    "frontend-contract-json-validate-shell",
                     "frontend-final-design-review-pi",
                     "frontend-design-review-pi",
                     "frontend-plan-revision-pi",
@@ -2478,8 +2503,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                     commands: [],
                     frontendPrewriteGate: {
                         schemaVersion: 1,
-                        planFromNodeId: "frontend-plan-revision-pi",
-                        planFallbackFromNodeIds: ["frontend-plan-pi"],
+                        planFromNodeId: "frontend-contract-json-pi",
+                        planFallbackFromNodeIds: ["frontend-plan-revision-pi", "frontend-plan-pi"],
                         reviewFromNodeId: "frontend-final-design-review-pi",
                         reviewFallbackFromNodeIds: ["frontend-design-review-pi"],
                         requiredRequirementIds: requirementIds,
@@ -5363,7 +5388,7 @@ async function buildHybridDagForTemplate(sources, template) {
         else if (template === "review-gated-dag")
             spec = buildReviewGatedHybridDag(standard, sources);
         else
-            spec = buildSupervisedHybridDag(standard, sources);
+            spec = await buildSupervisedHybridDag(standard, sources);
     }
     applyProjectGovernanceReview(spec, template, sources);
     // New generate path always emits DagSpec v4 + bindings.
@@ -5807,10 +5832,12 @@ function buildWriteSetGateNode(sources) {
         },
     };
 }
-function buildSoftVerifyNode(sources) {
+async function buildSoftVerifyNode(sources) {
     const implementId = implementationNodeId();
     const strategy = resolveDagVerifyStrategy(sources.taskConfig, "1");
-    const fallbackCommands = ["npm run typecheck"];
+    const fallbackCommands = sources.repoRoot
+        ? (await discoverFrontendFallbackVerifyCommands(sources.repoRoot)).staticCommands
+        : ["npm run typecheck"];
     const focusedIntermediate = sources.verifyCommands?.intermediate.filter((command) => !isFullSuiteVerifyCommand(command));
     const plannedIntermediate = applyMavenVerificationPlanning({
         repoRoot: sources.repoRoot,
@@ -6052,7 +6079,7 @@ function resolveSupervisedConvergence(taskConfig) {
         chainNodeIds: [...SUPERVISED_CONVERGENCE_CHAIN_NODE_IDS],
     };
 }
-function buildSupervisedHybridDag(standard, sources) {
+async function buildSupervisedHybridDag(standard, sources) {
     const contract = getTaskOrThrow(standard, "contract-pi");
     const scoutSrc = getTaskOrThrow(standard, "scout-src");
     const scoutTests = getTaskOrThrow(standard, "scout-tests");
@@ -6104,7 +6131,7 @@ function buildSupervisedHybridDag(standard, sources) {
                     "final-write-set-audit-format-repair-pi",
                 ],
             }),
-            buildSoftVerifyNode(sources),
+            await buildSoftVerifyNode(sources),
             buildProcessSupervisorNode(sources),
             buildProcessGateNode(sources),
             buildRepairNode(sources),

package/dist/workflows/dag/output-protocol.js

@@ -148,6 +148,29 @@ export function validateOutputProtocol(protocol, text) {
             reason: `missing first non-empty line; expected one of: ${protocol.validLines.map((l) => JSON.stringify(l)).join(" or ")}`,
         };
     }
+    const isReviewVerdict = protocol.validLines.length === 2 && protocol.validLines.includes("VERDICT: pass") && protocol.validLines.includes("VERDICT: request-revision");
+    // Models frequently prepend a short explanation despite the protocol
+    // instruction. Recover only when there is exactly one unambiguous protocol
+    // line; conflicting or repeated verdicts remain fail-closed.
+    const candidates = isReviewVerdict ? text
+        .split("\n")
+        .map((line) => normalizeVerdictCandidateLine(line.trim()))
+        .filter((line) => protocol.validLines.includes(line)) : [];
+    const uniqueCandidates = [...new Set(candidates)];
+    if (uniqueCandidates.length > 1) {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: `conflicting protocol lines found: ${uniqueCandidates.map((line) => JSON.stringify(line)).join(" and ")}`,
+            firstNonEmptyLine: first,
+        };
+    }
+    if (protocol.validLines.includes(first)) {
+        return { ok: true, matchedLine: first };
+    }
+    if (uniqueCandidates.length === 1) {
+        return { ok: true, matchedLine: uniqueCandidates[0] };
+    }
     if (!protocol.validLines.includes(first)) {
         return {
             ok: false,

package/docs/templates/frontend-implementation-contract.schema.json

@@ -13,9 +13,9 @@
     "requirements": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "expectedOutcome", "implementationTargets", "verificationTargetIds"], "properties": { "id": { "$ref": "#/$defs/requirementId" }, "expectedOutcome": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "evidenceGap": { "$ref": "#/$defs/gap" } } } },
     "uiStates": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "applicable"], "properties": { "name": { "type": "string", "minLength": 1 }, "applicable": { "type": "boolean" }, "expectedBehavior": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }, "notApplicableReason": { "type": "string", "minLength": 1 } }, "allOf": [{ "if": { "properties": { "applicable": { "const": true } }, "required": ["applicable"] }, "then": { "required": ["expectedBehavior", "implementationTargets", "verificationTargetIds"], "properties": { "implementationTargets": { "minItems": 1 }, "verificationTargetIds": { "minItems": 1 } } } }, { "if": { "properties": { "applicable": { "const": false } }, "required": ["applicable"] }, "then": { "required": ["notApplicableReason"] } }] } },
     "interactions": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["name", "trigger", "expectedBehavior", "implementationTargets", "verificationTargetIds"], "properties": { "name": { "type": "string", "minLength": 1 }, "trigger": { "type": "string", "minLength": 1 }, "expectedBehavior": { "type": "string", "minLength": 1 }, "implementationTargets": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "verificationTargetIds": { "type": "array", "items": { "type": "string" } } } } },
-    "mockApi": { "type": "object", "additionalProperties": false, "required": ["strategy", "productionDefaultOff", "activation", "endpoints"], "properties": { "strategy": { "enum": ["native", "browser-intercept", "request-adapter", "not-needed"] }, "productionDefaultOff": { "const": true }, "activation": { "type": "string", "minLength": 1 }, "endpoints": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["method", "path"], "properties": { "method": { "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] }, "path": { "type": "string", "pattern": "^/" }, "fixture": { "$ref": "#/$defs/path" }, "consumer": { "$ref": "#/$defs/path" } } } } } },
+    "mockApi": { "type": "object", "additionalProperties": false, "required": ["strategy", "productionDefaultOff", "activation", "endpoints"], "properties": { "strategy": { "enum": ["native", "browser-intercept", "request-adapter", "not-needed"] }, "productionDefaultOff": { "const": true }, "activation": { "type": ["string", "null"], "minLength": 1 }, "endpoints": { "type": "array", "items": { "type": "object", "additionalProperties": false, "required": ["method", "path"], "properties": { "method": { "enum": ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"] }, "path": { "type": "string", "pattern": "^/" }, "fixture": { "anyOf": [{ "$ref": "#/$defs/path" }, { "type": "null" }] }, "consumer": { "anyOf": [{ "$ref": "#/$defs/path" }, { "type": "null" }] } } } } } },
     "designEvidence": { "type": "object", "additionalProperties": false, "required": ["source", "paths", "conflicts"], "properties": { "source": { "type": "string", "minLength": 1 }, "paths": { "type": "array", "items": { "$ref": "#/$defs/path" } }, "conflicts": { "type": "array", "items": { "type": "string", "minLength": 1 } } } },
-    "verificationTargets": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "type", "commandLabel", "file", "requirementIds", "uiStates"], "properties": { "id": { "type": "string", "minLength": 1 }, "type": { "enum": ["static", "unit", "component", "integration", "mock"] }, "commandLabel": { "type": "string", "minLength": 1 }, "file": { "$ref": "#/$defs/path" }, "symbol": { "type": "string", "minLength": 1 }, "requirementIds": { "type": "array", "items": { "$ref": "#/$defs/requirementId" } }, "uiStates": { "type": "array", "items": { "type": "string", "minLength": 1 } } } } },
+    "verificationTargets": { "type": "array", "minItems": 1, "items": { "type": "object", "additionalProperties": false, "required": ["id", "type", "commandLabel", "file", "requirementIds", "uiStates"], "properties": { "id": { "type": "string", "minLength": 1 }, "type": { "enum": ["static", "unit", "component", "integration", "mock"] }, "commandLabel": { "type": "string", "minLength": 1 }, "file": { "$ref": "#/$defs/path" }, "symbol": { "anyOf": [{ "type": "string", "minLength": 1 }, { "type": "null" }] }, "requirementIds": { "type": "array", "items": { "$ref": "#/$defs/requirementId" } }, "uiStates": { "type": "array", "items": { "type": "string", "minLength": 1 } } } } },
     "evidenceGaps": { "type": "array", "items": { "$ref": "#/$defs/gap" } }
   },
   "allOf": [{ "if": { "properties": { "mockApi": { "properties": { "strategy": { "enum": ["native", "browser-intercept", "request-adapter"] } } } } }, "then": { "properties": { "mockApi": { "properties": { "endpoints": { "minItems": 1, "items": { "required": ["method", "path", "fixture", "consumer"] } } } } } } }],

package/package.json

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