@tea-agent/loop-agent 0.44.0-next.1 → 0.44.0-next.11

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

@@ -9,33 +9,65 @@ import { BoundedTextPreview, classifyPiFailure, createPiJsonlStreamCollector, DE
 import { serializeSessionEvent } from "./pi-event-serializer.js";
 import { PI_RECOMMENDED_COMPACTION, PI_RECOMMENDED_RETRY, } from "../shared/pi-retry-settings.js";
 import { createCompactionController, createContextPressureExtension, createSiftBridgeState, inMemoryCompactionSettings, isDagSiftEnabled, parseCompactionPolicy, parseSiftBridgeConfig, SIFT_RETRIEVE_TOOL_NAME, } from "../shared/pi-context-pressure/index.js";
+import { DAG_TELEMETRY_SESSION_ID_ENV, injectWizardLocalTelemetryHeaders, isTelemetrySessionId, } from "../shared/wizard-local-telemetry.js";
 /** Maximum number of same-session continuations after provider output truncation. */
 export const PI_SDK_OUTPUT_LIMIT_CONTINUE_MAX = 3;
 export const PI_SDK_OUTPUT_LIMIT_CONTINUE_PROMPT = "继续。上一轮因输出长度上限（stopReason=length）截断；当前会话、工具与已完成工作仍保留。只完成尚未完成的部分，不重做已成功的写入或事实提交。";
+export function createDagWizardLocalTelemetryHeadersExtension(telemetrySessionId) {
+    if (!isTelemetrySessionId(telemetrySessionId))
+        return undefined;
+    return {
+        name: "dag-wizard-local-telemetry-headers",
+        hidden: true,
+        factory: (api) => {
+            api.on("before_provider_headers", async (rawEvent, context) => {
+                if (!context ||
+                    !rawEvent.headers ||
+                    typeof rawEvent.headers !== "object") {
+                    return;
+                }
+                await injectWizardLocalTelemetryHeaders({
+                    headers: rawEvent.headers,
+                    context,
+                    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")
-        throw Error("FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: SDK actual request stream unavailable");
+        throw new Error("FRONTEND_PROVIDER_BUDGET_UNSUPPORTED: SDK actual request stream unavailable");
     const { createAssistantMessageEventStream } = await import("@earendil-works/pi-ai");
     agent.streamFunction = async (...args) => {
         try {
             if (args[2]?.signal?.aborted)
-                throw Error("FRONTEND_PROVIDER_REQUEST_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);
                 if (measurement.exceedsEstimate)
-                    throw Error(`FRONTEND_CONTEXT_ESTIMATE_EXCEEDED: estimated=${measurement.estimatedTokens} available=${measurement.availableInputTokens}; estimator=${measurement.estimatorVersion}; registry capability is not a measured gateway limit`);
+                    throw new Error(`FRONTEND_CONTEXT_ESTIMATE_EXCEEDED: estimated=${measurement.estimatedTokens} available=${measurement.availableInputTokens}; estimator=${measurement.estimatorVersion}; registry capability is not a measured gateway limit`);
             }
             await reserve();
             if (args[2]?.signal?.aborted)
-                throw Error("FRONTEND_PROVIDER_REQUEST_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() } });
@@ -101,7 +133,7 @@ export function setPiSdkImportOverrideForTests(fn) {
 export function setPiSdkModuleOverrideForTests(fn) {
     sdkModuleOverrideForTests = fn;
 }
-/** Check whether the Pi SDK runtime dependency satisfies the 0.83.0 runtime contract. */
+/** Check whether the Pi SDK runtime dependency satisfies the 0.84.4 runtime contract. */
 export async function checkPiSdkAvailability(_repoRoot) {
     if (sdkSessionFactoryOverride) {
         return { ok: true, detail: "pi SDK session factory override active" };
@@ -117,10 +149,10 @@ export async function checkPiSdkAvailability(_repoRoot) {
             typeof ModelRuntime?.create !== "function") {
             return {
                 ok: false,
-                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.83.0 contract)",
+                detail: "pi SDK incompatible: requires createAgentSession, getAgentDir, and ModelRuntime.create (0.84.4 contract)",
             };
         }
-        return { ok: true, detail: "pi SDK 0.83.0 contract available" };
+        return { ok: true, detail: "pi SDK 0.84.4 contract available" };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -290,6 +322,8 @@ async function createSdkSession(sdk, input, shared) {
         controller,
         sift,
     });
+    const telemetryExtension = createDagWizardLocalTelemetryHeadersExtension(input.telemetrySessionId);
+    const extensionFactories = [pressureExtension, telemetryExtension].filter((extension) => Boolean(extension));
     const loader = new DefaultResourceLoader({
         cwd: input.cwd,
         agentDir,
@@ -299,7 +333,7 @@ async function createSdkSession(sdk, input, shared) {
         ...(input.additionalExtensionPaths && input.additionalExtensionPaths.length > 0
             ? { additionalExtensionPaths: input.additionalExtensionPaths }
             : {}),
-        ...(pressureExtension ? { extensionFactories: [pressureExtension] } : {}),
+        ...(extensionFactories.length > 0 ? { extensionFactories } : {}),
         ...(settingsManager ? { settingsManager } : {}),
         appendSystemPromptOverride: (base) => [
             ...base,
@@ -625,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");
@@ -718,6 +780,9 @@ async function executeSingleSdkAttemptInternal(options) {
             provider: modelConfig.provider,
             model: modelConfig.model,
             thinking: modelConfig.thinking,
+            telemetrySessionId: isTelemetrySessionId(process.env[DAG_TELEMETRY_SESSION_ID_ENV])
+                ? process.env[DAG_TELEMETRY_SESSION_ID_ENV]
+                : undefined,
             ...(Array.isArray(writerCustomTools) && writerCustomTools.length > 0
                 ? { customTools: writerCustomTools }
                 : {}),
@@ -730,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;
@@ -816,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)
@@ -870,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 () => {
@@ -900,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();
@@ -922,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"
@@ -962,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());
@@ -976,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 });
@@ -996,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/executors/shell-presets.js

@@ -3,7 +3,7 @@ export const DAG_SHELL_PRESETS = {
     "loop-agent-standard-verify": [
         "npm run lint",
         "npm run typecheck",
-        "npx vitest run test/dag-shell-executor.test.ts test/dag-validate.test.ts test/dag-runner.test.ts --reporter=dot",
+        "npx vitest run test/dag-shell-executor.test.ts test/dag-validate.test.ts test/dag-runner.test.ts test/dag-runner-convergence.test.ts test/dag-runner-artifacts.test.ts test/dag-runner-decisions.test.ts --reporter=dot",
     ],
 };
 export function expandShellPreset(preset) {

package/dist/executors/shell-write-guard.js

@@ -4,6 +4,7 @@ import { constants, createReadStream } from "node:fs";
 import { access, lstat, readlink, unlink } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../shared/git-progress.js";
+import { expandWorkspaceStatus, hasGitmodulesFile, synthesizeExpandedPorcelain, } from "../shared/git-workspace-status.js";
 import { ResilientGitCommandError, runResilientGitCommand, } from "../shared/resilient-git.js";
 async function sha256File(filePath) {
     const hash = createHash("sha256");
@@ -411,6 +412,7 @@ async function resolveGitExecutableCandidates(platform, env) {
     return ["git"];
 }
 export async function readGitStatusPorcelain(cwd, options = {}) {
+    let parentPorcelain;
     try {
         const result = await runResilientGitCommand({
             cwd,
@@ -419,9 +421,12 @@ export async function readGitStatusPorcelain(cwd, options = {}) {
             attempts: options.attempts,
             retryDelayMs: options.retryDelayMs,
         });
-        if (result.code === 0)
-            return result.stdout;
-        throw new Error(result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`);
+        if (result.code === 0) {
+            parentPorcelain = result.stdout;
+        }
+        else {
+            throw new Error(result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`);
+        }
     }
     catch (error) {
         if (error instanceof ResilientGitCommandError) {
@@ -436,6 +441,24 @@ export async function readGitStatusPorcelain(cwd, options = {}) {
         }
         throw error;
     }
+    // Submodule workspaces: a parent-only porcelain hides every file inside a
+    // registered submodule behind a single directory-level gitlink entry,
+    // which historically produced false empty-diff and false violations
+    // (plan 2026-09-15-development-workflow-git-submodule). Repositories
+    // without .gitmodules keep the parent bytes verbatim — byte-identical
+    // behavior for every non-submodule workspace.
+    if (!(await hasGitmodulesFile(cwd)))
+        return parentPorcelain;
+    const observation = await expandWorkspaceStatus({
+        rootCwd: cwd,
+        parentPorcelain,
+        hasGitmodulesFile: true,
+    });
+    if (!observation.complete) {
+        const failed = observation.repos.find((repo) => repo.state === "status-read-failed");
+        throw new Error(`workspace status expansion incomplete: submodule ${failed?.repoRelativePath ?? "unknown"} status read failed: ${failed?.errorDetail ?? "unknown error"}`);
+    }
+    return synthesizeExpandedPorcelain(observation.entries);
 }
 export async function readGitStatusPorcelainWithDependencies(cwd, options, dependencies) {
     const candidates = await dependencies.resolveExecutableCandidates();