@tea-agent/loop-agent 0.44.0-next.8 → 0.44.0-next.9

package/dist/executors/pi-executor.js

@@ -790,7 +790,7 @@ export async function executePiStep(options) {
             reuseRuntimeActive,
         });
     }
-    if (options.reserveProviderRequest || !shouldFallbackSdkToCli(sdkResult, validationIssues, options)) {
+    if (options.frontendPlanControl || options.reserveProviderRequest || !shouldFallbackSdkToCli(sdkResult, validationIssues, options)) {
         const failureCategory = validationIssues.length > 0
             ? "invalid-output"
             : sdkResult.failureCategory;
@@ -1104,6 +1104,11 @@ export function classifyPiFailure(input) {
     // Provider/transport verdicts read error-shaped channels only; the raw stdout
     // stream embeds assistant text, tool arguments and findings verbatim.
     const combined = `${input.stderr}\n${extractProviderFailureText(input.stdout)}`.toLowerCase();
+    // An explicit spend-budget stop is terminal even if a transport wrapper also
+    // reports a closed connection. Read only the error channels above, never
+    // assistant/tool prose; generic quota and context limits keep their categories.
+    if (/(?<![\w-])(?:frontend_provider_budget_exhausted|budget_exhausted|budget_breach|budget exhausted)(?![\w-])/.test(combined))
+        return "budget_breach";
     // Context overflow (400 request-too-large / context window exceeded).
     // Must be detected BEFORE the generic rate-limit/quota phrases: an overflow
     // error often contains "too many tokens" / "maximum context" which would

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

@@ -36,7 +36,7 @@ export function createDagWizardLocalTelemetryHeadersExtension(telemetrySessionId
     };
 }
 /** Wrap the actual stream seam: tool turns, retries and compaction all await it. */
-export async function installPiProviderRequestBudget(session, reserve, onFailure, capacity) {
+export async function installPiProviderRequestBudget(session, reserve, onFailure, capacity, plan) {
     const agent = session.agent;
     const original = agent?.streamFunction;
     if (!agent || typeof original !== "function")
@@ -46,6 +46,9 @@ export async function installPiProviderRequestBudget(session, reserve, onFailure
         try {
             if (args[2]?.signal?.aborted)
                 throw new Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+            const protocolStop = plan?.readStop();
+            if (protocolStop)
+                throw Object.assign(new Error(`${protocolStop.code}: ${protocolStop.error}`), { frontendPlanStop: true });
             if (capacity) {
                 const measurement = measureFrontendRequestEnvelope(args[1], args[0], capacity.policy);
                 capacity.observe(measurement);
@@ -55,10 +58,16 @@ export async function installPiProviderRequestBudget(session, reserve, onFailure
             await reserve();
             if (args[2]?.signal?.aborted)
                 throw new Error("FRONTEND_PROVIDER_REQUEST_ABORTED");
+            const stoppedDuringReservation = plan?.readStop();
+            if (stoppedDuringReservation)
+                throw Object.assign(new Error(`${stoppedDuringReservation.code}: ${stoppedDuringReservation.error}`), { frontendPlanStop: true });
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            onFailure(message);
+            if (error.frontendPlanStop)
+                plan?.onStop();
+            else
+                onFailure(message);
             const stream = createAssistantMessageEventStream();
             const model = args[0] ?? {};
             stream.push({ type: "error", reason: "error", error: { role: "assistant", content: [], api: model.api ?? "unknown", provider: model.provider ?? "unknown", model: model.id ?? "unknown", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }, stopReason: "error", errorMessage: message, timestamp: Date.now() } });
@@ -650,6 +659,34 @@ async function executeSingleSdkAttemptInternal(options) {
     let terminationConfirmed = true;
     let stderr = "";
     let providerBudgetFailure;
+    let providerBudgetAbort = false;
+    let providerBudgetStopRequested = false;
+    let resolveProviderBudgetStop;
+    const providerBudgetStopPromise = new Promise(resolve => { resolveProviderBudgetStop = resolve; });
+    const frontendBudgetEnabled = Boolean(options.reserveProviderRequest || options.frontendExecutionPolicy || options.frontendPlanControl);
+    const observeProviderBudgetError = (message) => {
+        if (!frontendBudgetEnabled || typeof message !== "string" || providerBudgetStopRequested)
+            return;
+        if (classifyPiFailure({ assistantText: "", exitCode: 1, outputTooLarge: false, stderr: message, stdout: "", timedOut: false }) !== "budget_breach")
+            return;
+        providerBudgetFailure = message;
+        providerBudgetStopRequested = true;
+        if (!stderr.includes(message))
+            appendStderr(message);
+        resolveProviderBudgetStop("provider-budget");
+    };
+    let protocolStop;
+    let protocolAbort = false;
+    let unsubscribePlan;
+    let resolveProtocolStop;
+    const protocolStopPromise = new Promise(resolve => { resolveProtocolStop = resolve; });
+    const requestProtocolStop = () => {
+        const stop = options.frontendPlanControl?.readStop();
+        if (stop && stopReason !== "aborted" && !providerBudgetFailure) {
+            protocolStop = stop;
+            resolveProtocolStop("protocol-stop");
+        }
+    };
     let capabilitiesObservation = frontendModelCapabilities(undefined);
     const requestEnvelopeObservation = { peakBytes: 0, peakEstimatedTokens: 0, estimatorVersion: "utf8-bytes-div3-v1-estimate" };
     const stdoutPreview = new BoundedTextPreview("stdout");
@@ -758,12 +795,14 @@ async function executeSingleSdkAttemptInternal(options) {
                 : {}),
         });
         capabilitiesObservation = frontendModelCapabilities(session.agent?.state?.model);
-        if (options.reserveProviderRequest || options.frontendExecutionPolicy)
-            await installPiProviderRequestBudget(session, options.reserveProviderRequest ?? (async () => { }), message => { providerBudgetFailure = message; appendStderr(message); }, options.frontendExecutionPolicy ? { policy: options.frontendExecutionPolicy, observe: measurement => {
+        if (options.frontendPlanControl || options.reserveProviderRequest || options.frontendExecutionPolicy)
+            await installPiProviderRequestBudget(session, options.reserveProviderRequest ?? (async () => { }), message => { if (protocolAbort && message.includes("REQUEST_ABORTED"))
+                return; providerBudgetFailure = message; appendStderr(message); observeProviderBudgetError(message); }, options.frontendExecutionPolicy ? { policy: options.frontendExecutionPolicy, observe: measurement => {
                     capabilitiesObservation = measurement.capabilities;
                     requestEnvelopeObservation.peakBytes = Math.max(requestEnvelopeObservation.peakBytes, measurement.bytes);
                     requestEnvelopeObservation.peakEstimatedTokens = Math.max(requestEnvelopeObservation.peakEstimatedTokens, measurement.estimatedTokens);
-                } } : undefined);
+                } } : undefined, options.frontendPlanControl ? { readStop: options.frontendPlanControl.readStop, onStop: requestProtocolStop } : undefined);
+        unsubscribePlan = options.frontendPlanControl?.subscribe(requestProtocolStop);
         let resolveStall;
         let resolveSettlement;
         let resolveContextBudget;
@@ -844,13 +883,23 @@ async function executeSingleSdkAttemptInternal(options) {
                 }
             }
             const observationMessage = isRecord(event.message) ? event.message : undefined;
-            if (typeof observationMessage?.errorMessage === "string")
+            observeProviderBudgetError(observationMessage?.errorMessage ?? (event.type === "auto_retry_start" ? event.errorMessage : undefined));
+            if (providerBudgetStopRequested && event.type === "auto_retry_start") {
+                // Pi emits the notification before installing its retry controller.
+                // Cancel after that synchronous setup, including when abort() already
+                // ran on message_end and is still waiting for the session to idle.
+                queueMicrotask(() => { try {
+                    session?.abortRetry?.();
+                }
+                catch { /* abort/dispose confirmation remains authoritative */ } });
+            }
+            if (typeof observationMessage?.errorMessage === "string" && !(protocolStop && observationMessage.errorMessage === `${protocolStop.code}: ${protocolStop.error}`))
                 providerErrorMessage = observationMessage.errorMessage;
             try {
                 readObservation.observe(event);
             }
             catch { /* observation must not change execution */ }
-            if (!(typeof observationMessage?.errorMessage === "string" && observationMessage.errorMessage.startsWith("FRONTEND_PROVIDER_")) && (event.usage || observationMessage?.usage || event.tokenUsage))
+            if (!(typeof observationMessage?.errorMessage === "string" && /^(FRONTEND_PROVIDER_|FRONTEND_PLAN_NO_PROGRESS|FRONTEND_CONTEXT_ESTIMATE_EXCEEDED)/.test(observationMessage.errorMessage)) && (event.usage || observationMessage?.usage || event.tokenUsage))
                 observationEvents.push({ responseId: event.responseId, messageId: event.messageId, usage: event.usage, tokenUsage: event.tokenUsage, message: observationMessage ? { role: observationMessage.role, id: observationMessage.id, responseId: observationMessage.responseId, usage: observationMessage.usage } : undefined });
             const usageSample = extractSdkUsageSample(event);
             if (usageSample)
@@ -898,8 +947,10 @@ async function executeSingleSdkAttemptInternal(options) {
                 promptPromise.then(() => "done"),
                 settlementPromise,
                 ...(timeoutPromise ? [timeoutPromise] : []),
+                ...(frontendBudgetEnabled ? [providerBudgetStopPromise] : []),
                 ...(stallPromise ? [stallPromise] : []),
                 ...(contextBudgetPromise ? [contextBudgetPromise] : []),
+                ...(options.frontendPlanControl ? [protocolStopPromise] : []),
             ]);
         };
         const disposeSession = async () => {
@@ -928,7 +979,18 @@ async function executeSingleSdkAttemptInternal(options) {
         let continuesSent = 0;
         let raced = await runTurn(promptMessage);
         while (true) {
-            if (raced === "context-budget") {
+            if (providerBudgetStopRequested) {
+                providerBudgetAbort = true;
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+                await disposeSession();
+            }
+            else if ((raced === "protocol-stop" || ((raced === "done" || raced === "settled") && protocolStop)) && !providerBudgetFailure && !contextBudgetExhausted && stopReason !== "aborted") {
+                protocolAbort = true;
+                appendStderr(`${protocolStop.code}: ${protocolStop.error}; fingerprint=${protocolStop.fingerprint}`);
+                abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
+                await disposeSession();
+            }
+            else if (raced === "context-budget" || contextBudgetExhausted) {
                 appendStderr(contextBudgetDetail);
                 abortConfirmed = await runSessionActionWithGrace("abort", () => session.abort());
                 await disposeSession();
@@ -950,6 +1012,8 @@ async function executeSingleSdkAttemptInternal(options) {
                         maxContinues: PI_SDK_STALL_CONTINUE_MAX,
                     });
                     raced = await runTurn(PI_SDK_STALL_CONTINUE_PROMPT);
+                    if (raced === "protocol-stop" || raced === "context-budget" || raced === "provider-budget")
+                        continue;
                     if (raced !== "done" && raced !== "settled") {
                         await failClosedAfterWait(raced === "stall" ? "stall" : "absolute-timeout", raced === "stall"
                             ? "pi SDK stall continue did not recover; treating as timeout"
@@ -990,6 +1054,7 @@ async function executeSingleSdkAttemptInternal(options) {
         if (stallHandle)
             clearTimeout(stallHandle);
         unsubscribe?.();
+        unsubscribePlan?.();
         if (session && !disposeAttempted) {
             disposeAttempted = true;
             const disposeConfirmed = await runSessionActionWithGrace("dispose", () => session.dispose());
@@ -1004,7 +1069,7 @@ async function executeSingleSdkAttemptInternal(options) {
             }
         }
     }
-    if (providerErrorMessage && stopReason === "error" && !stderr)
+    if (providerErrorMessage && stopReason === "error" && !stderr.includes(providerErrorMessage))
         appendStderr(providerErrorMessage);
     if (options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && outputContinuesSent >= PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX) {
         const note = serializeSessionEvent({ type: "loop-agent-output-limit-exhausted", maxContinues: PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX });
@@ -1024,9 +1089,9 @@ async function executeSingleSdkAttemptInternal(options) {
         ? collected.parsedEvents
         : (fallbackParsed?.parsedEvents ?? 0);
     const tokensUsed = aggregateSdkTokenUsage(usageSamples);
-    const cancelled = stopReason === "aborted";
+    const cancelled = stopReason === "aborted" && !protocolAbort && !providerBudgetAbort;
     const outputLimitExhausted = Boolean(options.outputLimitRecovery && stopReason === "length" && !committedTerminalObserved && !timedOut && !stderr);
-    const failureCategory = !terminationConfirmed ? "termination-unconfirmed" : stopReason === "aborted" ? "cancelled" : outputLimitExhausted ? "output-limit" : providerBudgetFailure ? (providerBudgetFailure.includes("REQUEST_ABORTED") ? "interrupted" : providerBudgetFailure.startsWith("FRONTEND_CONTEXT_ESTIMATE_EXCEEDED") ? "context-budget-exhausted" : "budget_breach") : terminationConfirmed
+    const failureCategory = !terminationConfirmed ? "termination-unconfirmed" : cancelled ? "cancelled" : outputLimitExhausted ? "output-limit" : providerBudgetFailure ? (providerBudgetFailure.includes("REQUEST_ABORTED") ? "interrupted" : providerBudgetFailure.startsWith("FRONTEND_CONTEXT_ESTIMATE_EXCEEDED") ? "context-budget-exhausted" : "budget_breach") : contextBudgetExhausted ? "context-budget-exhausted" : protocolStop && !providerErrorMessage && !timedOut ? "invalid-output" : terminationConfirmed
         ? classifyPiFailure({
             assistantText,
             exitCode: timedOut ? 1 : stderr ? 1 : 0,

package/dist/executors/shell-executor.js

@@ -1,6 +1,7 @@
+import { collectExistingFrontendVerificationPaths } from "../workflows/dag/frontend-implementation-contract.js";
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { withFrontendTestReporter, parseFrontendTestExecutionReport } from "../workflows/dag/frontend-test-execution-evidence.js";
+import { inspectFrontendTestCommand, compareFrontendTestObservation, parseFrontendTestExecutionReport } from "../workflows/dag/frontend-test-execution-evidence.js";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -493,6 +494,25 @@ export function buildFrontendVerificationEvidence(input) {
         lintCommandTexts: input.bundle.lintEvidence?.commandTexts ?? [],
     });
     const entryByCommand = new Map(directory.map((entry) => [entry.command.trim(), entry]));
+    const entryForExecutedCommand = (command) => {
+        const normalized = command.trim();
+        const exact = entryByCommand.get(normalized);
+        if (exact)
+            return exact;
+        // Behavior commands with Vitest JSON capability are executed with the
+        // runtime-owned reporter/outputFile suffix. Preserve their frozen command
+        // identity in review evidence, but accept *only* that exact suffix so an
+        // arbitrary command sharing a textual prefix is never attributed to a
+        // verification-directory entry.
+        return directory.find((entry) => {
+            if (entry.lane !== "behavior")
+                return false;
+            if (!normalized.startsWith(entry.command.trim()))
+                return false;
+            const suffix = normalized.slice(entry.command.trim().length);
+            return /^(?:\s+--)?\s+--reporter=json\s+--outputFile=(?:'[^']*'|"[^"]*"|\S+)$/u.test(suffix);
+        });
+    };
     return {
         schemaVersion: 1,
         schemaId: "frontend-verification-evidence-v1",
@@ -503,7 +523,7 @@ export function buildFrontendVerificationEvidence(input) {
         lintStatus: input.lintStatus,
         lintConfigured: input.lintConfigured,
         commands: input.results.map((result, index) => {
-            const entry = entryByCommand.get(result.command.trim());
+            const entry = entryForExecutedCommand(result.command);
             return {
                 index: index + 1,
                 commandId: entry?.commandId ?? null,
@@ -1993,12 +2013,29 @@ async function deriveUnresolvedVerificationEntrypointRefs(runDir, frozenCommandI
         return [];
     }
 }
+async function inspectFrontendBundleTests(bundle, cwd, workspaceRoot, phase, writeSet = []) {
+    const inspected = new Map();
+    const failures = [];
+    for (const [index, command] of bundle.behaviorCommands.entries()) {
+        const label = bundle.behaviorEvidence.commandLabels[index];
+        const frozen = bundle.behaviorEvidence.preflight.find(entry => entry.label === label)?.testObservation;
+        const observed = await inspectFrontendTestCommand({ command, cwd, workspaceRoot, allowedPaths: writeSet });
+        const reason = frozen ? compareFrontendTestObservation(frozen, observed.observation, phase, writeSet) : "missing frozen test observation preflight; regenerate the DAG";
+        if (reason)
+            failures.push({ code: "FRONTEND_TEST_OBSERVATION_INVALID", commandId: frozen?.commandId, command, reason });
+        else
+            inspected.set(command, observed);
+    }
+    return { inspected, failures };
+}
 async function executeFrontendVerificationBundle(input, meta) {
     const started = Date.now();
     const shell = input.task.shell;
     const bundle = shell.frontendVerificationBundle;
     const cwd = resolveShellCwd(input.cwd, shell.cwd);
     const results = [];
+    const testPreflight = await inspectFrontendBundleTests(bundle, cwd, input.cwd, "execution");
+    let testObservationFailure = testPreflight.failures[0];
     const commandResultsByKey = new Map();
     const commandKey = (command) => `${cwd}\u0000${command.trim()}`;
     const reuseCommandResult = (result, command) => {
@@ -2027,8 +2064,9 @@ async function executeFrontendVerificationBundle(input, meta) {
     const successfulLabels = new Map();
     const successfulCommandTexts = new Map();
     const executedTests = new Map();
+    const testExecutionEvidence = [];
     const commandExecutionEvidence = new Map();
-    for (const command of bundle.lintCommands ?? []) {
+    for (const command of testObservationFailure ? [] : bundle.lintCommands ?? []) {
         const key = commandKey(command);
         const cached = commandResultsByKey.get(key);
         let result = cached ? reuseCommandResult(cached, command) : undefined;
@@ -2085,17 +2123,26 @@ async function executeFrontendVerificationBundle(input, meta) {
     ];
     const failedGroups = new Set();
     const groupFailures = [];
-    for (const group of lintBlocked ? [] : groups) {
+    for (const group of lintBlocked || testObservationFailure ? [] : groups) {
         for (const [index, command] of group.commands.entries()) {
-            if (failedGroups.has(group.name))
+            if (failedGroups.has(group.name) || testObservationFailure)
                 break;
+            if (testPreflight.inspected.has(command)) {
+                const fresh = await inspectFrontendBundleTests(bundle, cwd, input.cwd, "execution");
+                testObservationFailure = fresh.failures[0];
+                if (testObservationFailure)
+                    break;
+                for (const [text, observed] of fresh.inspected)
+                    testPreflight.inspected.set(text, observed);
+            }
             const key = commandKey(command);
             const cached = commandResultsByKey.get(key);
             let result = cached ? reuseCommandResult(cached, command) : undefined;
             if (!result) {
                 const commandNumber = results.length + 1;
                 const reportPath = path.join(meta.runDir, input.task.id, "commands", `${commandNumber}-${randomUUID()}.vitest.json`);
-                const observedCommand = await withFrontendTestReporter({ command, cwd, reportPath });
+                const observedTest = testPreflight.inspected.get(command);
+                const observedCommand = observedTest?.withReporter?.(reportPath);
                 if (observedCommand)
                     await mkdir(path.dirname(reportPath), { recursive: true });
                 result = await executeShellCommand({
@@ -2116,7 +2163,17 @@ async function executeFrontendVerificationBundle(input, meta) {
                         // Vitest reports physical paths (e.g. /private/var on macOS).
                         // Match those in workspace coordinates even when shell.cwd is
                         // a subdirectory or the caller used a directory alias.
-                        commandExecutionEvidence.set(key, parseFrontendTestExecutionReport(JSON.parse(await readFile(reportPath, "utf8")), await realpath(cwd), await realpath(input.cwd)));
+                        const rawReport = await readFile(reportPath, "utf8");
+                        const reportSha256 = createHash("sha256").update(rawReport).digest("hex");
+                        commandExecutionEvidence.set(key, parseFrontendTestExecutionReport(JSON.parse(rawReport), await realpath(observedTest?.effectiveCwd ?? cwd), await realpath(input.cwd)));
+                        const actual = commandExecutionEvidence.get(key);
+                        for (let offset = 0; offset < actual.length; offset += 24) {
+                            const relative = `${input.task.id}/commands/${commandNumber}-execution-${offset / 24}.json`;
+                            const excerpt = { schemaVersion: 1, commandSha256: observedTest.observation.commandSha256, cwd: observedTest.observation.cwd, reportSha256, offset, total: actual.length, behaviorCoverage: "unconfirmed", tests: actual.slice(offset, offset + 24).map(test => ({ file: test.file, status: test.status, title: test.title.slice(0, 500), ...(test.title.length > 500 ? { titleTruncated: true } : {}) })) };
+                            await writeDagRunJsonArtifact(meta.runDir, relative, excerpt);
+                            const bytes = await readFile(path.join(meta.runDir, relative));
+                            testExecutionEvidence.push({ path: relative, sha256: createHash("sha256").update(bytes).digest("hex"), reportPath: path.relative(meta.runDir, reportPath).replace(/\\/g, "/"), reportSha256 });
+                        }
                     }
                     catch (error) {
                         reportError = `frontend test execution report unavailable: ${error instanceof Error ? error.message : String(error)}`;
@@ -2212,6 +2269,8 @@ async function executeFrontendVerificationBundle(input, meta) {
         : undefined;
     let traceError;
     try {
+        if (testObservationFailure)
+            throw new Error(`${testObservationFailure.code}: ${testObservationFailure.reason}`);
         await runFrontendVerificationTraceGate({
             runDir: meta.runDir,
             workspaceRoot: input.cwd,
@@ -2229,6 +2288,7 @@ async function executeFrontendVerificationBundle(input, meta) {
                     nodeId: input.task.id,
                     commandLabels: successfulLabels.get("behavior") ?? [],
                     executedTests,
+                    testExecutionEvidence,
                 },
             },
         });
@@ -2261,9 +2321,10 @@ async function executeFrontendVerificationBundle(input, meta) {
             nodeId: failedNodeId,
             rawFailureCategory: failureCategory,
         });
-        const failureOwner = classifiedOwner === "unknown" &&
-            ["typecheck", "build", "lint", "component-test", "unit-test", "trace"].includes(failureClass)
-            ? "implementation" : classifiedOwner;
+        const failureOwner = testObservationFailure ? "verification-config" :
+            classifiedOwner === "unknown" &&
+                ["typecheck", "build", "lint", "component-test", "unit-test", "trace"].includes(failureClass)
+                ? "implementation" : classifiedOwner;
         const restartPhase = classifyRestartPhase(failureOwner);
         // A+B (AC-008): verification-config routing. Produce structured
         // unresolved entrypoint refs from committed plan facts and the frozen
@@ -2325,6 +2386,7 @@ async function executeFrontendVerificationBundle(input, meta) {
             ...(verificationConfigRoute
                 ? { verificationConfigRoute }
                 : {}),
+            ...(testObservationFailure ? { testObservationFailure, commandsExecuted: results.some(result => !result.reused) } : {}),
             commandResults,
             failedAt: new Date().toISOString(),
         };
@@ -2689,8 +2751,9 @@ async function executeFrontendDesignPolicy(input, meta) {
                     durationMs: Date.now() - started,
                 };
             }
+            const existingVerificationPaths = await collectExistingFrontendVerificationPaths(input.cwd, contract);
             const uncoveredVTs = contract.verificationTargets
-                .filter((vt) => vt.mode !== "static")
+                .filter((vt) => vt.mode !== "static" && !existingVerificationPaths.includes(vt.file))
                 .filter((vt) => ![...writeSet].some((pattern) => pathMatchesPattern(vt.file, pattern) || vt.file === pattern));
             if (uncoveredVTs.length > 0) {
                 return {
@@ -2757,6 +2820,7 @@ async function executeFrontendDesignPolicy(input, meta) {
                 [],
             allowedDependencies: config.allowedDependencies,
             writeSetPatterns: config.implementationWriteSet ?? [],
+            existingVerificationPaths: await collectExistingFrontendVerificationPaths(input.cwd, contract),
             // Fresh-existence evidence at gate time (Scout pathEvidence.fresh
             // semantics): a reuse-existing evidencePath must name a file that
             // exists NOW; greenfield paths are decision=new only.
@@ -2894,12 +2958,21 @@ async function executeFrontendWriterAdmission(input, meta) {
         const workspaceFiles = await collectWorkspaceFiles(input.cwd);
         const admission = deriveFrontendWriterAdmissionShell({
             contract,
+            existingVerificationPaths: await collectExistingFrontendVerificationPaths(input.cwd, contract),
             designPolicyResult,
             baseline,
             frozenCommandLabels: config.frozenCommandLabels,
             allowedMockStrategies: config.allowedMockStrategies,
             workspaceFiles,
         });
+        const testObservationFindings = [];
+        for (const node of meta.spec.tasks) {
+            const verification = node.shell?.frontendVerificationBundle;
+            if (!verification)
+                continue;
+            const checked = await inspectFrontendBundleTests(verification, resolveShellCwd(input.cwd, node.shell?.cwd), input.cwd, "admission", admission.writeSet);
+            testObservationFindings.push(...checked.failures.map(failure => ({ code: failure.code, message: failure.reason })));
+        }
         // 6. Design verdict enforcement: request_design_changes is a blocked
         // admission. This keeps the writer fail-closed until the recovery plan
         // has incorporated the reviewer's concrete findings.
@@ -2907,9 +2980,10 @@ async function executeFrontendWriterAdmission(input, meta) {
             ? "frontend-design-policy-shell"
             : "frontend-writer-admission-shell";
         const findings = verdictPass
-            ? admission.findings
+            ? [...admission.findings, ...testObservationFindings]
             : [
                 ...admission.findings,
+                ...testObservationFindings,
                 {
                     code: designRequested
                         ? "design-review-requested"
@@ -3101,6 +3175,8 @@ async function executeFrontendCloseout(input, meta) {
                 status: target.status === "ok" ? "passed" : "failed",
                 evidence: trace?.targets?.[index]?.evidence ?? "unavailable",
                 behaviorCoverage: "unconfirmed",
+                plannedEvidenceLevel: contract.verificationTargets.find(entry => entry.id === trace?.targets?.[index]?.id)?.evidenceLevel ?? "unknown",
+                boundary: contract.verificationTargets.find(entry => entry.id === trace?.targets?.[index]?.id)?.boundary,
             })),
             lintStatus: "unavailable",
             integrationFacts,

package/dist/infrastructure/console/operation-store.js

@@ -11,6 +11,8 @@ export const TERMINAL_OPERATION_STATES = new Set(["succeeded", "failed", "timed-
  * inspection but does not itself prove a live operation; callers still check
  * DAG/Worker/chat activity separately. restarting is the terminal receipt of
  * a successful Console handoff, retained across boots, not a live slot.
+ * A needs-reconcile record remains visible as a non-business outcome, but
+ * must never strand later mutations after its runtime is gone.
  */
 export const OCCUPIED_OPERATION_STATES = new Set(["queued", "starting", "running"]);
 /** True when the state can still make progress and therefore holds the slot. */

package/dist/infrastructure/evaluation/corpus-store.js

@@ -1,3 +1,4 @@
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
 import { access, mkdir, readdir, readFile, rename, rm } from "node:fs/promises";
 import path from "node:path";
 import { mkdtemp } from "node:fs/promises";
@@ -30,28 +31,27 @@ async function pathExists(filePath) {
 function serializeManifest(manifest) {
     return `${JSON.stringify(manifest, null, 2)}\n`;
 }
+function compareArtifactPaths(a, b) {
+    return a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
+}
 function normalizeTasksForStorage(tasks) {
     return [...tasks]
         .map((task) => ({
         ...task,
         taskRef: task.taskRef.replace(/\\/g, "/"),
         seeds: [...task.seeds].sort((a, b) => a - b),
+        ...("category" in task ? {
+            requirements: [...task.requirements].sort(compareArtifactPaths),
+            initialFiles: [...task.initialFiles].sort(compareArtifactPaths),
+            oracleFiles: [...task.oracleFiles].sort(compareArtifactPaths),
+        } : {}),
     }))
         .sort((a, b) => a.taskRef < b.taskRef ? -1 : a.taskRef > b.taskRef ? 1 : 0);
 }
 export async function materializeCorpusManifest(raw) {
     const input = corpusManifestInputSchema.parse(raw);
     const tasks = normalizeTasksForStorage(input.tasks);
-    const withoutHash = {
-        schemaVersion: 1,
-        corpusId: input.corpusId,
-        createdAt: input.createdAt,
-        ...(input.description !== undefined
-            ? { description: input.description }
-            : {}),
-        tasks,
-    };
-    const corpusHash = computeCorpusHash(withoutHash);
+    const corpusHash = computeCorpusHash(input);
     if (input.corpusHash) {
         const provided = formatContentSha(normalizeContentSha(input.corpusHash));
         if (provided !== corpusHash) {
@@ -59,10 +59,30 @@ export async function materializeCorpusManifest(raw) {
         }
     }
     return corpusManifestSchema.parse({
-        ...withoutHash,
+        ...input,
+        tasks,
         corpusHash,
     });
 }
+export async function assertCorpusArtifacts(repoRoot, manifest) {
+    if (manifest.schemaVersion !== 2)
+        return;
+    const snapshots = new Map();
+    for (const task of manifest.tasks)
+        for (const ref of [...task.requirements, ...task.initialFiles, ...task.oracleFiles]) {
+            const bytes = await readFileBoundarySafe({ boundaryRoot: repoRoot,
+                targetPath: path.resolve(repoRoot, ref.path), label: "frontend corpus artifact" });
+            if (sha256Hex(bytes) !== ref.sha256)
+                throw Error(`corpus artifact hash mismatch: ${ref.path}`);
+            snapshots.set(ref.path, bytes);
+        }
+    for (const [file, expected] of snapshots) {
+        const actual = await readFileBoundarySafe({ boundaryRoot: repoRoot,
+            targetPath: path.resolve(repoRoot, file), label: "frontend corpus artifact recheck" });
+        if (!actual.equals(expected))
+            throw Error(`corpus artifact changed during collection: ${file}`);
+    }
+}
 async function assertManifestIntegrity(repoRoot, corpusId, rawManifest) {
     const integrityPath = path.join(corpusDir(repoRoot, corpusId), MANIFEST_INTEGRITY_FILE);
     const expected = (await readFile(integrityPath, "utf-8")).trim();
@@ -98,6 +118,7 @@ export async function readCorpusManifest(repoRoot, corpusId) {
     if (recomputed !== stored.corpusHash) {
         throw new Error(`corpusHash mismatch for ${corpusId}: expected ${recomputed}, got ${stored.corpusHash}`);
     }
+    await assertCorpusArtifacts(repoRoot, stored);
     return stored;
 }
 export async function listCorpusIds(repoRoot) {
@@ -117,7 +138,11 @@ export async function listCorpusIds(repoRoot) {
     }
 }
 export async function registerCorpusManifest(input) {
-    const { repoRoot, manifest } = input;
+    const repoRoot = input.repoRoot;
+    const manifest = corpusManifestSchema.parse(input.manifest);
+    if (computeCorpusHash(manifest) !== manifest.corpusHash)
+        throw Error("corpusHash mismatch");
+    await assertCorpusArtifacts(repoRoot, manifest);
     assertCorpusId(manifest.corpusId);
     const manifestPath = corpusManifestPath(repoRoot, manifest.corpusId);
     if (await pathExists(manifestPath)) {

package/dist/shared/operator/capabilities.js

@@ -863,9 +863,9 @@ export function buildOperatorCapabilitiesDocument() {
                 },
                 {
                     name: "capabilityBoundary",
-                    type: "array",
+                    type: "object",
                     required: false,
-                    description: "optional frozen test capability boundary {allowed?, forbidden?} composed into dependencyPolicy by the runtime",
+                    description: "optional frozen test capability boundary {allowed?, forbidden?, requiredClauses?} composed into dependencyPolicy by the runtime",
                 },
                 {
                     name: "interactionIds",
@@ -1237,10 +1237,9 @@ export function buildOperatorCapabilitiesDocument() {
                 },
                 {
                     name: "capabilityBoundary",
-                    type: "array",
-                    itemsType: "string",
+                    type: "object",
                     required: false,
-                    description: "frozen test capability boundary {allowed?, forbidden?} composed into dependencyPolicy by the runtime",
+                    description: "frozen test capability boundary {allowed?, forbidden?, requiredClauses?} composed into dependencyPolicy by the runtime",
                 },
                 {
                     name: "interactionIds",
@@ -1950,6 +1949,12 @@ export const OPERATOR_COMMAND_COVERAGE = Object.freeze([
         action: "doctor",
         source: "loop-agent",
     },
+    {
+        command: "loop-agent promote-run",
+        coverage: "excluded",
+        action: null,
+        source: "loop-agent",
+    },
     {
         command: "loop-agent task advance",
         coverage: "model-callable",

package/dist/task/config-types.js

@@ -1,6 +1,20 @@
 import { z } from "zod";
 import { frontendExecutionPolicySchema } from "../shared/frontend-execution-policy.js";
 import { DEFAULT_FRONTEND_SPEC_ROOTS, isFrontendSpecFilePath, isValidFrontendSpecRoot, } from "../shared/openspec-spec.js";
+/** Frozen user-authored clauses. Preserve wording/line breaks; normalize only
+ * line endings and surrounding whitespace, with explicit bounded payloads. */
+const capabilityClauses = z.array(z.string().transform(value => value.replace(/\r\n?/g, "\n").trim()).pipe(z.string().min(1).max(4096))).max(64).transform(values => [...new Set(values)]);
+export const capabilityBoundarySchema = z.object({
+    allowed: capabilityClauses.optional(),
+    forbidden: capabilityClauses.optional(),
+    requiredClauses: capabilityClauses.optional(),
+}).strict().superRefine((boundary, ctx) => {
+    const clauses = [...(boundary.allowed ?? []), ...(boundary.forbidden ?? []), ...(boundary.requiredClauses ?? [])];
+    if (!clauses.length)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "capabilityBoundary needs allowed, forbidden or requiredClauses entries" });
+    if (clauses.reduce((total, clause) => total + clause.length, 0) > 32768)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "capabilityBoundary exceeds 32768 characters" });
+});
 export const taskFlowSchema = z.enum([
     "auto",
     "micro",
@@ -39,6 +53,13 @@ export const taskVerifyCommandSchema = z.object({
     label: z.string().min(1),
     command: z.string().min(1),
     timeoutMs: z.number().int().positive().optional(),
+    /** Explicit verification lane for this command. Omit to keep automatic
+     * classification. Declaring `static` is the escape hatch for commands that
+     * provably cannot emit a test report (governance/lint scripts): the behavior
+     * lane requires test-observation capability at writer admission, so a
+     * non-test command misclassified into it blocks admission deterministically.
+     * Static commands still execute and their exit code is still checked. */
+    mode: z.enum(["static", "behavior"]).optional(),
 });
 export const dagVerifyStrategySchema = z
     .object({
@@ -304,15 +325,7 @@ const taskConfigObjectSchema = z.object({
         .optional(),
     /** Generation-frozen test capability boundary composed into the canonical
      * dependencyPolicy by the runtime (planner never maintains it). */
-    capabilityBoundary: z
-        .object({
-        allowed: z.array(z.string().min(1)).optional(),
-        forbidden: z.array(z.string().min(1)).optional(),
-        requiredClauses: z.array(z.string().min(1)).optional(),
-    })
-        .strict()
-        .refine((entry) => (entry.allowed?.length ?? 0) > 0 || (entry.forbidden?.length ?? 0) > 0 || (entry.requiredClauses?.length ?? 0) > 0, { message: "capabilityBoundary needs allowed or forbidden entries" })
-        .optional(),
+    capabilityBoundary: capabilityBoundarySchema.optional(),
     /** Generation-frozen interaction id vocabulary. Contract interaction names
      * must come from this set (plan finalize deterministic check). */
     interactionIds: z.array(z.string().min(1)).optional(),