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

package/dist/workflows/dag/frontend-session-budget.js

@@ -0,0 +1,249 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { readFrontendToolProgress } from "./frontend-durable-tools.js";
+import { frontendModelCapabilities } from "../../shared/frontend-execution-policy.js";
+/** Count returned text only after a successful native read. No filesystem reads or raw content retention. */
+export function createFrontendReadObservation() {
+    const pending = new Map();
+    const finished = new Set();
+    const seen = new Set();
+    let bytes = 0, duplicates = 0, complete = 0, rejected = 0, unknown = false;
+    return {
+        observe(raw) {
+            const event = record(raw);
+            const id = event.toolCallId;
+            if (typeof id !== "string")
+                return;
+            if (event.type === "tool_execution_start" && event.toolName === "read")
+                pending.set(id, record(event.args ?? event.input));
+            if (event.type !== "tool_execution_end" || !pending.has(id) || finished.has(id))
+                return;
+            const args = pending.get(id);
+            pending.delete(id);
+            finished.add(id);
+            const result = record(event.result);
+            if (event.isError === true || result.isError === true || result.ok === false || result.error || record(result.details).ok === false) {
+                rejected++;
+                return;
+            }
+            const content = result.content;
+            if (!Array.isArray(content) || content.some(item => record(item).type !== "text" || typeof record(item).text !== "string") || typeof args.path !== "string") {
+                unknown = true;
+                return;
+            }
+            const text = content.map(item => record(item).text).join("\n");
+            const size = Buffer.byteLength(text);
+            const key = createHash("sha256").update(JSON.stringify([args.path.replaceAll("\\", "/").replace(/^\.\//, ""), args.offset ?? null, args.limit ?? null, text])).digest("hex");
+            bytes += size;
+            complete++;
+            if (seen.has(key))
+                duplicates += size;
+            seen.add(key);
+        },
+        snapshot() { return { successfulReadBytes: unknown ? null : bytes, duplicateReadBytes: unknown ? null : duplicates, completedReads: complete, rejectedReads: rejected, incompleteReads: pending.size }; },
+    };
+}
+export function classifyFrontendSessionFailure(result) {
+    const errorCode = /\b(?:FRONTEND_[A-Z_]+|TOOL_SCHEMA_INVALID|FACT_IDENTITY_CONFLICT|REQUEST_ID_REUSE_CONFLICT|TERMINAL_CONFLICT|[A-Z_]+_INCOMPLETE|[A-Z_]+_EXHAUSTED)\b/.exec(result.stderr)?.[0] ?? null;
+    const category = result.failureCategory;
+    const failureLayer = result.stopReason === "length" || /context|budget-exhausted/.test(category) ? "capacity"
+        : result.ok ? "none"
+            : errorCode?.includes("LEDGER") || errorCode === "FRONTEND_COMMIT_FAILED" ? "persistence"
+                : errorCode === "TOOL_SCHEMA_INVALID" ? "schema"
+                    : /binding|source|permission|write-guard|tool-policy/.test(category) ? "governance"
+                        : /timeout|rate-limit|provider|transport|network|auth/.test(category) ? "provider"
+                            : /invalid-output|structured-output/.test(category) ? "protocol-or-coverage"
+                                : "unknown";
+    return { failureLayer, errorCode };
+}
+const fields = ["inputTokens", "outputTokens", "reasoningTokens", "cacheReadTokens", "cacheWriteTokens", "totalTokens", "peakRequestContextTokens"];
+const record = (v) => v !== null && typeof v === "object" ? v : {};
+const number = (r, ...keys) => {
+    for (const key of keys)
+        if (typeof r[key] === "number" && Number.isFinite(r[key]) && r[key] >= 0)
+            return r[key];
+    return null;
+};
+const sumKnown = (values) => values.length && values.every(v => v !== null) ? values.reduce((s, v) => s + v, 0) : null;
+/** Observation only. Never feed this projection into the SDK execution guard. */
+export function collectFrontendUsage(events) {
+    const samples = new Map();
+    const aliases = new Map();
+    let anonymous = false;
+    let observed = false;
+    for (const raw of events) {
+        const event = record(raw);
+        const message = record(event.message);
+        if (typeof message.role === "string" && message.role !== "assistant")
+            continue;
+        const usage = record(event.usage ?? message.usage ?? event.tokenUsage);
+        if (!Object.keys(usage).length)
+            continue;
+        observed = true;
+        const ids = [event.responseId, event.messageId, message.responseId, message.id].filter((v) => typeof v === "string" && v.length > 0);
+        const roots = [...new Set(ids.map(id => aliases.get(id) ?? id))];
+        const key = roots[0];
+        if (!key) {
+            anonymous = true;
+            continue;
+        }
+        const input = number(usage, "input", "input_tokens", "inputTokens", "prompt_tokens", "promptTokens");
+        const output = number(usage, "output", "output_tokens", "outputTokens", "completion_tokens", "completionTokens");
+        const cacheRead = number(usage, "cacheRead", "cache_read_input_tokens");
+        const cacheWrite = number(usage, "cacheWrite", "cache_creation_input_tokens");
+        // Pi's native input excludes cache tokens; OpenAI-compatible input includes them.
+        const context = input === null ? null : "input" in usage ? sumKnown([input, cacheRead, cacheWrite]) : input;
+        const sample = {
+            inputTokens: input, outputTokens: output,
+            reasoningTokens: number(usage, "reasoning", "reasoning_tokens", "reasoningTokens") ?? number(record(usage.completion_tokens_details ?? usage.output_tokens_details), "reasoning_tokens"),
+            cacheReadTokens: cacheRead, cacheWriteTokens: cacheWrite,
+            totalTokens: number(usage, "total_tokens", "totalTokens") ?? sumKnown([context, output]),
+            peakRequestContextTokens: context,
+        };
+        for (const root of roots) {
+            const previous = samples.get(root);
+            if (previous)
+                for (const field of fields)
+                    sample[field] = previous[field] === null ? sample[field] : sample[field] === null ? previous[field] : Math.max(previous[field], sample[field]);
+            samples.delete(root);
+        }
+        for (const [alias, root] of aliases)
+            if (roots.includes(root))
+                aliases.set(alias, key);
+        for (const id of ids)
+            aliases.set(id, key);
+        samples.set(key, sample);
+    }
+    const result = Object.fromEntries(fields.map(field => [field, anonymous ? null : field === "peakRequestContextTokens" ? (samples.size && [...samples.values()].every(s => s[field] !== null) ? Math.max(...[...samples.values()].map(s => s[field])) : null) : sumKnown([...samples.values()].map(s => s[field]))]));
+    return { ...result, requestCount: anonymous || !observed ? null : samples.size,
+        completeness: !observed ? "unknown" : !anonymous && result.inputTokens !== null && result.outputTokens !== null && result.totalTokens !== null ? "complete" : "partial" };
+}
+function aggregateAttempts(attempts) {
+    const usages = attempts.map(a => a.actual ?? collectFrontendUsage([]));
+    const totals = Object.fromEntries(fields.map(field => [field, field === "peakRequestContextTokens"
+            ? usages.every(u => u[field] !== null) ? Math.max(...usages.map(u => u[field])) : null
+            : sumKnown(usages.map(u => u[field]))]));
+    return { ...totals, requestCount: sumKnown(usages.map(u => u.requestCount)), completeness: usages.every(u => u.completeness === "complete") ? "complete" : usages.every(u => u.completeness === "unknown") ? "unknown" : "partial" };
+}
+/** Captures every transport attempt, including an SDK failure before CLI fallback. */
+export async function observeFrontendAttempt(input, execute) {
+    const event = { id: randomUUID(), backend: input.backend, model: input.model, startedAt: new Date().toISOString(), completion: "incomplete" };
+    const notify = () => { try {
+        input.observer?.(structuredClone(event));
+    }
+    catch { /* observation cannot change execution */ } };
+    notify();
+    const result = await execute();
+    event.completion = "complete";
+    event.actual = result.usageObservation ?? collectFrontendUsage([]);
+    event.reads = result.readObservation;
+    event.capabilities = result.capabilitiesObservation;
+    event.requestEnvelope = result.requestEnvelopeObservation;
+    event.terminal = { ok: result.ok, failureCategory: result.failureCategory, stopReason: result.stopReason ?? null, durationMs: result.durationMs };
+    notify();
+    return result;
+}
+const measure = (text) => ({ sha256: createHash("sha256").update(text).digest("hex"), chars: text.length, bytes: Buffer.byteLength(text), estimatedTokens: Math.ceil(Buffer.byteLength(text) / 3) });
+function safeObservation(read, fallback) { try {
+    return read();
+}
+catch {
+    return fallback;
+} }
+/** One logical dispatch and its real transport attempts; no raw prompt or tool output is stored. */
+export async function observeFrontendSession(input, execute) {
+    const durableBefore = safeObservation(() => input.durableCommittedCount?.(), undefined);
+    const before = safeObservation(() => input.committedCount?.(), undefined);
+    const toolsBefore = readFrontendToolProgress(input.customTools);
+    const receipt = {
+        schemaVersion: 1, policyVersion: "frontend-session-observation-v1",
+        identity: { sessionId: randomUUID(), phase: input.phase, scopeIds: input.scopeIds ?? [], taskId: input.taskId ?? null, runId: input.runId ?? null, nodeId: input.nodeId ?? null, attempt: input.attempt ?? null, sourceDigest: input.sourceDigest ?? null, contractDigest: input.contractDigest ?? null },
+        startedAt: new Date().toISOString(), finishedAt: null, completion: "incomplete",
+        planned: { prompt: measure(input.prompt), userMessage: measure(input.userMessage ?? ""), toolSchemas: input.customTools ? safeObservation(() => measure(JSON.stringify(input.customTools.map(t => { const tool = record(t); return { name: tool.name, description: tool.description, parameters: tool.parameters }; }))), null) : null,
+            estimatorVersion: "utf8-bytes-div3-v1-estimate", capabilities: { ...frontendModelCapabilities(undefined), model: input.model ?? null }, unmeasuredComponents: ["sdk-system-overhead", "built-in-tools", "history", "tool-results", "attachments"] },
+        actual: collectFrontendUsage([]), attempts: [],
+        progress: { memoryCommittedDelta: null, durableCommittedDelta: null, failedRecords: null, duplicateRecords: null, durableSubmissions: null, durableReplacements: null, successfulReadBytes: null, duplicateReadBytes: null }, terminal: null,
+    };
+    let writes = Promise.resolve();
+    let abandoned = false;
+    const writeObservation = async (file, snapshot) => {
+        // Never recreate a run that the runner has already archived.
+        await mkdir(path.dirname(file)).catch(error => { if (error.code !== "EEXIST")
+            throw error; });
+        const temporary = `${file}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, JSON.stringify(snapshot), { flag: "wx" });
+            await rename(temporary, file);
+        }
+        finally {
+            await rm(temporary, { force: true }).catch(() => { });
+        }
+    };
+    const save = () => {
+        const snapshot = structuredClone(receipt);
+        writes = writes.then(async () => {
+            if (abandoned)
+                return;
+            if (input.sink)
+                await input.sink(snapshot);
+            else if (input.artifactPath)
+                await writeObservation(input.artifactPath, snapshot);
+        }).catch(() => { });
+        return writes;
+    };
+    const waitForWrite = async (pending) => {
+        let timer;
+        try {
+            await Promise.race([pending, new Promise(resolve => { timer = setTimeout(() => { abandoned = true; resolve(); }, 100); })]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    };
+    await waitForWrite(save());
+    const result = await execute(event => {
+        const index = receipt.attempts.findIndex(a => a.id === event.id);
+        if (index < 0)
+            receipt.attempts.push(event);
+        else
+            receipt.attempts[index] = event;
+        void save();
+    });
+    receipt.finishedAt = new Date().toISOString();
+    receipt.completion = "complete";
+    receipt.actual = receipt.attempts.length ? aggregateAttempts(receipt.attempts) : result.usageObservation ?? collectFrontendUsage([]);
+    receipt.planned.capabilities = receipt.attempts[0]?.capabilities ?? result.capabilitiesObservation ?? receipt.planned.capabilities;
+    receipt.progress.memoryCommittedDelta = before !== undefined && input.committedCount ? safeObservation(() => Math.max(0, input.committedCount() - before), null) : null;
+    const durableAfter = safeObservation(() => input.durableCommittedCount?.(), undefined);
+    receipt.progress.durableCommittedDelta = durableBefore !== undefined && durableAfter !== undefined ? Math.max(0, durableAfter - durableBefore) : null;
+    const toolsAfter = readFrontendToolProgress(input.customTools);
+    if (toolsBefore && toolsAfter)
+        for (const key of ["failedRecords", "duplicateRecords", "durableSubmissions", "durableReplacements"])
+            receipt.progress[key] = Math.max(0, toolsAfter[key] - toolsBefore[key]);
+    const reads = receipt.attempts.length ? receipt.attempts.map(a => a.reads) : [result.readObservation];
+    for (const key of ["successfulReadBytes", "duplicateReadBytes"])
+        receipt.progress[key] = sumKnown(reads.map(r => r?.[key] ?? null));
+    receipt.terminal = { ok: result.ok, failureCategory: result.failureCategory, stopReason: result.stopReason ?? null, durationMs: Date.parse(receipt.finishedAt) - Date.parse(receipt.startedAt), ...classifyFrontendSessionFailure(result) };
+    await waitForWrite(save());
+    return result;
+}
+export function summarizeFrontendSessions(receipts) {
+    const byId = new Map();
+    for (const receipt of receipts) {
+        const previous = byId.get(receipt.identity.sessionId);
+        const rank = (r) => [r.completion === "complete" ? 1 : 0, Date.parse(r.finishedAt ?? r.startedAt), r.attempts.filter(a => a.completion === "complete").length, r.attempts.length];
+        const candidateRank = rank(receipt);
+        const previousRank = previous ? rank(previous) : [];
+        const difference = candidateRank.map((v, i) => v - (previousRank[i] ?? 0)).find(v => v !== 0) ?? 0;
+        if (!previous || difference > 0)
+            byId.set(receipt.identity.sessionId, receipt);
+    }
+    const unique = [...byId.values()];
+    return { sessions: unique.length, failedSessions: unique.filter(r => r.terminal?.ok === false).length, incompleteSessions: unique.filter(r => r.completion === "incomplete").length,
+        failureLayers: Object.fromEntries([...new Set(unique.flatMap(r => r.terminal && r.terminal.failureLayer !== "none" ? [r.terminal.failureLayer] : []))].sort().map(layer => [layer, unique.filter(r => r.terminal?.failureLayer === layer).length])),
+        progress: Object.fromEntries(["durableCommittedDelta", "durableSubmissions", "durableReplacements", "failedRecords", "duplicateRecords", "successfulReadBytes", "duplicateReadBytes"].map(key => [key, sumKnown(unique.map(r => r.progress[key]))])),
+        totalTokens: sumKnown(unique.flatMap(r => r.attempts.length ? r.attempts.map(a => a.actual?.totalTokens ?? null) : [r.actual.totalTokens])),
+        sessionDurationSumMs: sumKnown(unique.map(r => r.terminal?.durationMs ?? null)) };
+}

package/dist/workflows/dag/frontend-shadow-dual-write.js

@@ -236,6 +236,7 @@ export const PLAN_LEDGER_FACT_KINDS = [
     "plan-requirement",
     "plan-verification-target",
     "plan-evidence-gap",
+    "mock-endpoint",
 ];
 function skeletonTargetFiles(skeleton) {
     if (!isRecord(skeleton))
@@ -386,8 +387,25 @@ export function assemblePlanPatchFromCommittedFacts(records, contractRequirement
         patch.interactions = [...interactionByName.values(), ...unnamedInteractions];
     }
     const mockApi = lastByKind("mock-api");
+    if (!mockApi && facts.some(f => f.kind === "mock-endpoint" && f.removed !== true))
+        throw Error("MOCK_POLICY_MISSING: endpoint has no policy");
     if (mockApi && isRecord(mockApi.mockApi)) {
-        patch.mockApi = mockApi.mockApi;
+        const endpoints = new Map();
+        for (const endpoint of Array.isArray(mockApi.mockApi.endpoints) ? mockApi.mockApi.endpoints : []) {
+            if (isRecord(endpoint))
+                endpoints.set(`${endpoint.method}:${endpoint.path}`, endpoint);
+        }
+        for (const fact of facts)
+            if (fact.kind === "mock-endpoint" && isRecord(fact.endpoint)) {
+                const key = `${fact.endpoint.method}:${fact.endpoint.path}`;
+                if (fact.removed === true)
+                    endpoints.delete(key);
+                else
+                    endpoints.set(key, fact.endpoint);
+            }
+        if (mockApi.mockApi.strategy === "not-needed" && endpoints.size)
+            throw Error("MOCK_POLICY_CONFLICT: withdraw endpoints before declaring Mock/API not needed");
+        patch.mockApi = { ...mockApi.mockApi, endpoints: [...endpoints.values()] };
     }
     const deviation = lastByKind("design-deviation");
     if (deviation) {
@@ -433,7 +451,7 @@ export function assemblePlanPatchFromCommittedFacts(records, contractRequirement
         const inherited = contractRequirements.get(id);
         if (!inherited)
             return entry;
-        const merged = { ...entry };
+        const merged = { ...entry, ...(inherited.text ? { expectedOutcome: inherited.text } : {}), ...(inherited.execution ? { execution: inherited.execution } : {}) };
         // Inherit the contract-declared provenance only when the plan did
         // not already declare it (model override wins; missing inherits).
         if (!Array.isArray(entry.sourceFragmentIds)) {

package/dist/workflows/dag/frontend-shape-facts.js

@@ -1,4 +1,5 @@
 import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
+import { FRONTEND_MAX_IMPLEMENTATION_FILES, frontendConcreteDeliveryFiles } from "./frontend-capacity.js";
 import { buildFrontendShapeTransitionCapsule, deriveFrontendRuntimeShapeFacts, evaluateFrontendShapeEscalation, parseFrontendShapeTransitionCapsule, } from "./frontend-shape.js";
 import { createTypedEventStore, readCommittedEvents, } from "./frontend-typed-event-store.js";
 import { adoptTypedEventFact, stageTypedEventFact, } from "./frontend-typed-event-transaction.js";
@@ -222,7 +223,13 @@ function extractRuntimeShapeEvidence(input) {
         !sourceText.includes(path) &&
         /(?:\.[A-Za-z0-9]+|\*\*)$/.test(path));
     const routes = canonicalStrings(text.match(/\/(?:[A-Za-z0-9_:[\]-]+\/?)+/g) ?? []);
-    const splitRequired = /["']splitRequired["']\s*:\s*true|\bsplit-required\s+shape\b/i.test(text);
+    // The frozen delivery inventory is available before Plan. Do not spend
+    // coverage/UX sessions building a contract the same capacity gate will reject.
+    // allowedPaths and text mentions are permissions/evidence, never this count.
+    const skeleton = input.tasksById.get("frontend-plan-pi")?.structuredContractOutput?.skeleton;
+    const deliveryFiles = frontendConcreteDeliveryFiles(skeleton?.targets?.files);
+    const capacitySplit = deliveryFiles.length > FRONTEND_MAX_IMPLEMENTATION_FILES;
+    const splitRequired = capacitySplit || /["']splitRequired["']\s*:\s*true|\bsplit-required\s+shape\b/i.test(text);
     return {
         sourceNodeId: input.sourceNodeId,
         sourceNodeDigest: computeFrontendShapeNodeDigest(node),
@@ -232,7 +239,10 @@ function extractRuntimeShapeEvidence(input) {
         targetPaths,
         routes,
         splitRequired,
-        evidenceRefs: [`node:${input.sourceNodeId}:stdout`],
+        evidenceRefs: [
+            ...(capacitySplit ? ["dag:frontend-plan-pi:structuredContractOutput.skeleton.targets.files"] : []),
+            `node:${input.sourceNodeId}:stdout`,
+        ],
     };
 }
 /** Commit a typed, structured runtime fact immediately after a canonical source

package/dist/workflows/dag/frontend-shape.js

@@ -61,7 +61,7 @@ function pathSpreadScore(paths) {
 function collectEscalationSignals(blob, supervised) {
     const signals = [];
     for (const pattern of SHAPE_ESCALATION_PATTERNS) {
-        if (pattern.re.test(blob))
+        if (hasAffirmativeShapeSignal(blob, pattern))
             signals.push(pattern.id);
     }
     if (supervised)
@@ -72,6 +72,35 @@ function collectEscalationSignals(blob, supervised) {
     }
     return [...new Set(signals)];
 }
+function isExplicitShapeExclusion(clause, pattern) {
+    const match = new RegExp(pattern.re.source, "i").exec(clause);
+    if (!match)
+        return false;
+    const prefix = clause.slice(0, match.index).trim();
+    const suffix = clause.slice(match.index + match[0].length).trim();
+    const actionInSignal = ["new-route", "new-dependency"].includes(pattern.id);
+    if (suffix && !(actionInSignal && /^no$/i.test(prefix) && /^is\s+(?:required|needed)$/i.test(suffix)))
+        return false;
+    if (/^(?:不涉及|不(?:修改|变更|调整|改变|新增|添加)|无需(?:修改|变更|调整|改变|新增|添加)|no\s+changes?\s+to|(?:do\s+not|don't)\s+(?:change|modify))$/i.test(prefix))
+        return true;
+    return actionInSignal && /^(?:不|禁止|无需|无须|不需要|no|without|do\s+not|don't)$/i.test(prefix);
+}
+/** Only a complete, independent scope exclusion can suppress a risk signal.
+ * Nested negation, conditions and trailing consequences remain risk evidence;
+ * an excluded occurrence never cancels another occurrence elsewhere. */
+function hasAffirmativeShapeSignal(blob, pattern) {
+    for (const sentence of blob.split(/[\n。.;；!?！？]/)) {
+        if (!pattern.re.test(sentence))
+            continue;
+        // Commas can attach a condition to an exclusion. A comma-separated list
+        // is independent only when every item is itself an explicit exclusion.
+        const clauses = sentence.split(/[，,、]/).map(part => part.trim().replace(/^(?:[-*+]|\d+\))\s+/, ""));
+        if (clauses.every(clause => SHAPE_ESCALATION_PATTERNS.some(candidate => isExplicitShapeExclusion(clause, candidate))))
+            continue;
+        return true;
+    }
+    return false;
+}
 /** Negation applies to the API mention itself, never to unrelated Mock policy. */
 function hasFrontendRemoteSignal(blob) {
     const remaining = blob

package/dist/workflows/dag/frontend-test-execution-evidence.js

@@ -39,9 +39,10 @@ const resultSchema = z.object({
         })),
     })),
 });
-export function parseFrontendTestExecutionReport(raw, cwd) {
+/** Resolve runner paths against its cwd, then use the contract workspace coordinates. */
+export function parseFrontendTestExecutionReport(raw, cwd, workspaceRoot = cwd) {
     return resultSchema.parse(raw).testResults.flatMap((suite) => suite.assertionResults.map((test) => ({
-        file: path.relative(cwd, path.resolve(cwd, suite.name)).replace(/\\/g, "/"),
+        file: path.relative(workspaceRoot, path.resolve(cwd, suite.name)).replace(/\\/g, "/"),
         title: test.fullName ?? [...(test.ancestorTitles ?? []), test.title].join(" "),
         status: test.status,
     })));

package/dist/workflows/dag/frontend-typed-event-store.js

@@ -128,6 +128,7 @@ export const PLAN_RECORD_FACT_KINDS = [
     "plan-evidence-gap",
     "state-registry",
 ];
+export const INCREMENTAL_DETAIL_FACT_KINDS = ["mock-endpoint", "review-finding", "design-finding", "contract-scope-completed", "plan-group-coverage", "scout-scope", "review-scope-completed", "design-scope-completed"];
 /**
  * A+B (AC-009): typed issue category shared by review and design change
  * requests. The five-value enum replaces free-form issueCategory strings.
@@ -159,6 +160,7 @@ const ALL_TYPED_EVENT_FACT_KIND_VALUES = [
         ...CONTRACT_FACT_KINDS,
         ...PLAN_TERMINAL_FACT_KINDS,
         ...PLAN_RECORD_FACT_KINDS,
+        ...INCREMENTAL_DETAIL_FACT_KINDS,
     ]),
 ];
 export const typedEventFactKindSchema = z.enum(ALL_TYPED_EVENT_FACT_KIND_VALUES);
@@ -261,6 +263,15 @@ export const typedEventRecordSchema = z
     revision: z.number().int().nonnegative(),
     recordedAt: z.string().min(1),
     quarantineReason: z.string().min(1).optional(),
+    submission: z.object({
+        version: z.literal(1),
+        bindingSha256: z.string().regex(/^[a-f0-9]{64}$/),
+        tool: z.string(),
+        callId: z.string(),
+        identity: z.string(),
+        paramsSha256: z.string().regex(/^[a-f0-9]{64}$/),
+        receipt: z.record(z.unknown()).optional(),
+    }).strict().optional(),
 })
     .strict()
     .superRefine((value, ctx) => {

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

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { frontendExecutionPolicySchema } from "../../shared/frontend-execution-policy.js";
 import { access, readdir, readFile, realpath } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
 import { deflateRawSync } from "node:zlib";
@@ -3061,7 +3062,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             .filter(Boolean)
             .join("\n\n"),
         scout: [
-            buildSourceContextBlock(sources, { includeReferenceDocuments: false }),
+            buildSourceContextBlock(sources, { includeRequirementExcerpt: false, includeConstraintExcerpt: false, includeReferenceDocuments: false }),
             capabilityContextBlock,
         ]
             .filter(Boolean)
@@ -3342,11 +3343,11 @@ async function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_CONTRACT_SKILLS,
-                outputContract: "Typed requirement facts plus a concise Markdown contract. Submit through the incremental typed tools record_requirement / record_constraint / record_evidence_expectation / record_handoff_intent / record_open_question / record_split_proposal / record_ui_state / record_required_deliverables / record_openspec_selection, then call finalize_contract exactly once. record_requirement takes only the canonical ledger requirement id — the runtime owns the authoritative text, source spans, fragment bindings, and disposition. UI-visible or interactive requirements register a non-blocking frontend-test handoff intent, and any source-declared UI-state table is extracted verbatim through record_ui_state. End finalize_contract with a single contract disposition of ready | ready-with-assumptions | blocked. Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations; do not fix target files, components, or implementation methods as requirements. When OpenSpec candidates exist, classify only the ones you actually use: call record_openspec_selection once per required/relevant path; never enumerate irrelevant candidates (unmentioned defaults to irrelevant) and never emit a fenced selection JSON. No file writes.",
+                outputContract: "Incremental typed requirement facts; narrative is display-only. Submit through the incremental typed tools record_requirement / record_constraint / record_evidence_expectation / record_handoff_intent / record_open_question / record_split_proposal / record_ui_state / record_required_deliverables / record_openspec_selection, then complete each input scope with complete_contract_scope, then call finalize_contract; correct rejected calls until one successful terminal. record_requirement takes the canonical ledger requirement id and optional execution:{groupId,kind,summary} — the runtime owns the authoritative text, source spans, fragment bindings, and disposition. UI-visible or interactive requirements register a non-blocking frontend-test handoff intent, and any source-declared UI-state table is extracted verbatim through record_ui_state. End finalize_contract with a single contract disposition of ready | ready-with-assumptions | blocked. Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations; do not fix target files, components, or implementation methods as requirements. When OpenSpec candidates exist, classify only the ones you actually use: call record_openspec_selection once per required/relevant path; never enumerate irrelevant candidates (unmentioned defaults to irrelevant) and never emit a fenced selection JSON. No file writes.",
                 subtask_prompt: [
-                    "OUTPUT BUDGET DISCIPLINE (hard requirement, extreme-environment safe): the provider output window is small — NEVER attempt to emit the whole contract in one response; a single large JSON dump will be truncated and rejected. Incremental submission through the typed tools is the ONLY supported output mode. Start submitting with the FIRST tool call: after each read, call record_requirement for the requirements you have already confirmed, one or a few per call. Every tool-call round MUST make progress by submitting at least one record_* fact. Do not re-read the same source file that is already materialized in this session; read each file at most once.",
-                    "Read task source and produce a concise frontend implementation contract as typed requirement facts plus narrative Markdown.",
-                    "Confirm each requirement by the SAME id as the ledger canonical requirement it covers (sourceBinding.requirementIds, e.g. AC-001) — do NOT invent new REQ/BR prefixed ids for canonical requirements: the compiled contract must match the ledger canonical requirement ids exactly or schema validation rejects it (unknown requirement id). record_requirement takes ONLY the canonical id; the runtime commits the authoritative text and sourceFragmentIds from the frozen ledger. Never pass text/statement/sourceFragmentIds yourself — model rewrites and JSON-stringified fragment arrays are rejected.",
+                    "OUTPUT BUDGET DISCIPLINE: provider capacity is discovered at runtime; use small records — NEVER attempt to emit the whole contract in one response; a single large JSON dump will be truncated and rejected. Incremental submission through the typed tools is the ONLY supported output mode. Start submitting with the FIRST tool call: after each read, call record_requirement for the requirements you have already confirmed, one or a few per call. Every tool-call round MUST make progress by submitting at least one record_* fact. Do not re-read the same source file that is already materialized in this session; read each file at most once.",
+                    "Consume the complete injected input scope and produce a concise frontend implementation contract as typed requirement facts from complete injected scopes.",
+                    "Confirm each requirement by the SAME id as the ledger canonical requirement it covers (sourceBinding.requirementIds, e.g. AC-001) — do NOT invent new REQ/BR prefixed ids for canonical requirements: the compiled contract must match the ledger canonical requirement ids exactly or schema validation rejects it (unknown requirement id). record_requirement takes the canonical id and optional execution:{groupId,kind,summary}; the runtime commits the authoritative text and sourceFragmentIds from the frozen ledger. Never pass text/statement/sourceFragmentIds yourself — model rewrites and JSON-stringified fragment arrays are rejected.",
                     "Requirement semantics, source spans, dispositions, and fragment bindings are ledger/runtime-owned. If a canonical requirement is genuinely blocked, say so in the Markdown contract narrative and finalize with the matching disposition instead of trying to encode it in the requirement fact.",
                     "Register evidence expectations for each requirement across static, behavior, Mock, and real integration as required | optional | not-applicable; required must follow from user requirements, task risk, or project governance, never from model convenience. For UI-visible or interactive requirements, register a non-blocking frontend-test handoff intent.",
                     'Use record_evidence_expectation with {requirementId,evidence:{static,behavior,mock,"real-integration"}}; every lane is required | optional | not-applicable. Requirement text and provenance remain runtime-owned.',
@@ -3406,17 +3407,17 @@ async function buildFrontendHybridDagFromTask(sources) {
                     retryOnInvalid: true,
                     skeleton: frontendContractSkeleton,
                 },
-                outputContract: "Typed decision patch only: map frozen requirements to implementation/verification targets and select the needed component, state, data/Mock, styling, and dependency decisions. Use only the record_* tools needed to express those decisions, then call finalize_plan exactly once. Contract owns requirement semantics; Scout owns repository discovery; deterministic runtime owns schema, protected fields, path containment, and command validation. No Markdown narrative or file writes.",
+                outputContract: "Typed decision patch only: map frozen requirements to implementation/verification targets and select the needed component, state, data/Mock, styling, and dependency decisions. Use only the record_* tools needed to express those decisions, then call finalize_plan; correct rejected facts until one successful terminal. Contract owns requirement semantics; Scout owns repository discovery; deterministic runtime owns schema, protected fields, path containment, and command validation. No Markdown narrative or file writes.",
                 subtask_prompt: [
                     "Plan only the delta between the frozen frontend-contract-pi facts and frontend-scout-pi target surface. Do not reinterpret the task, repeat requirements, search the repository, or choose implementation order.",
                     "Record only: requirement-to-file/verification coverage; component/styling choices; applicable UI state and interaction behavior; data/Mock strategy; and a dependency policy or genuine evidence gap. Reuse Scout paths. If scope is missing, record a blocking gap instead of inventing a path.",
                     "Use the typed tool schemas as the field contract. Runtime owns schemaVersion, sourceBinding, riskLevel, targets.files, mockApi.productionDefaultOff, aliases, command allowlisting, path containment, and final validation; do not restate those rules or emit a full JSON contract.",
                     `Cover each frozen requirement ID exactly once: ${requirementIds.join(", ") || "(none)"}. Bind every verification target to a frozen commandId from the directory above plus a Scout-confirmed file. Behavior commands prove observable behavior: one target may cover multiple related requirementIds when one test behavior proves them together; do not mechanically create one target per requirement. A behavior target id is the stable machine trace token and its file must be a test file. Static commands are project-wide checks traced by file and command only.`,
-                    "UX vocabulary protocol: record_state_registry FIRST with the full global vocabulary — one stable kebab-case behavior-domain name per UI state/interaction (e.g. planner-task-edit, focus-queue-move), never one name per AC number and never a rename of an already-recorded concept. Coverage slices by requirement; UX does not. Then record_state_flow entries whose names all come from that registry; uiState names must use the contract's declared authoritative ids (declaredUiStates in the plan input) when present. Retry attempts see committedUx in this input — reuse those exact names. Components: one choice may cover many state/interaction ids via covers; reuse-existing requires evidencePath naming an existing repo file (greenfield must be decision=new).",
+                    "UX vocabulary protocol: record_state_registry FIRST with the full global vocabulary — one stable kebab-case behavior-domain name per UI state/interaction (e.g. planner-task-edit, focus-queue-move), never one name per AC number and never a rename of an already-recorded concept. Details consume complete execution-group scopes and reuse the same global names across scopes. Constraints/exclusions must not manufacture UI. Then record_state_flow entries whose names all come from that registry; uiState names must use the contract's declared authoritative ids (declaredUiStates in the plan input) when present. Retry attempts see committedUx in this input — reuse those exact names. Components: one choice may cover many state/interaction ids via covers; reuse-existing requires evidencePath naming an existing repo file (greenfield must be decision=new).",
                     ...(requiresOpenspecClassification ? ["When a component choice uses an OpenSpec selection, cite that selection; otherwise do not classify unrelated candidates."] : []),
-                    "Call finalize_plan exactly once after the necessary typed facts. Return no Markdown narrative.",
-                    "TOOL-ONLY PLAN: Do not read Contract/Scout stdout, task sources, or Scout-confirmed target files. Contract and Scout already own evidence discovery; use the injected upstream facts, record a genuine evidence gap when those facts are insufficient, and start committing record_* facts immediately. For decision=new, pass sourceRequirementIds to record_component_choice; runtime derives the exact PRD citation from the frozen ledger.",
-                    "Output budget protocol (hard, max output <=16K per turn): never enumerate-reason the whole requirement list before your first record_* call — that reasoning burns the entire output budget and the attempt dies with zero committed facts. Process requirements in order: think about ONE requirement briefly, immediately emit its record calls (up to 5 per message), then move to the next. If your budget runs low, stop recording and call finalize_plan with what is committed — the retry ladder continues the remainder in a fresh session.",
+                    "Call finalize_plan; correct rejected facts until one successful terminal after the necessary typed facts. Return no Markdown narrative.",
+                    "Group members retain full source text and independent ACs. Use record_plan_group_coverage only for actually shared references; do not create components for exclusions. TOOL-ONLY PLAN: Do not read Contract/Scout stdout, task sources, or Scout-confirmed target files. Contract and Scout already own evidence discovery; use the injected upstream facts, record a genuine evidence gap when those facts are insufficient, and start committing record_* facts immediately. For decision=new, pass sourceRequirementIds to record_component_choice; runtime derives the exact PRD citation from the frozen ledger.",
+                    "Incremental output protocol: process the current complete scope, committing small records immediately. Runtime packs full input and estimated work without assuming a model capacity from its name. Use record_plan_group_coverage for shared references, record_mock_endpoint per endpoint, and finalize only when all coverage is complete. On exhaustion, durable progress survives and remaining work is reduced; never omit source conditions or repeatedly retry the same exhausted scope.",
                     fixedVerificationContext,
                     scopedOpenspecContext,
                     mockContextBlock,
@@ -3500,6 +3501,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_DESIGN_REVIEW_SKILLS,
                 outputContract: "Authoritative typed design terminal via approve_design / request_design_changes tools. No JSON verdict; the committed typed design fact is the only authority. No file writes.",
                 subtask_prompt: [
+                    "Submit findings individually with record_design_finding and stable IDs; terminal tools aggregate saved findings. Correct rejected calls, stop after a successful terminal. Check execution groups against every member source outcome, including permission, threshold and failure-path differences; shared verification is valid only when it proves each independent AC.",
                     "Audit the frontend plan before implementation. frontend-plan-pi is emitted to you as canonical full-contract JSON after the runtime applied and validated the planner's editable patch against its protected skeleton; there is no separate plan prose.",
                     "Your authoritative terminal verdict is exactly one committed typed tool call: approve_design or request_design_changes. Call exactly one of them; after calling one, do not call the other.",
                     "request_design_changes must carry a typed issueCategory, at least one evidenceRef, and non-empty findings.",
@@ -3665,6 +3667,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_REVIEW_SKILLS,
                 outputContract: 'Authoritative typed review terminal via approve_review / request_review_changes tools. No JSON verdict is required in the response text; the typed terminal fact is the only authority. No file writes.',
                 subtask_prompt: [
+                    "Submit findings individually with record_review_finding and stable IDs; terminal tools aggregate saved findings. Correct rejected calls, stop after a successful terminal. Check execution groups against every member source outcome, including permission, threshold and failure-path differences; shared verification is valid only when it proves each independent AC.",
                     "Review the frontend implementation and verification evidence.",
                     "Your authoritative terminal verdict is exactly one committed typed tool call: approve_review or request_review_changes. Call it once and do not call the other afterwards.",
                     "approve_review means the implementation passes; it must not carry Critical or Important findings. request_review_changes must carry a typed issueCategory, at least one evidenceRef, and non-empty findings.",
@@ -3751,6 +3754,9 @@ async function buildFrontendHybridDagFromTask(sources) {
     // runner can bound M6 auto-recovery without re-reading the task config.
     const frontendMaxContinuations = sources.taskConfig.frontendRecovery?.maxContinuations ?? 1;
     spec.frontendRecovery = { maxContinuations: frontendMaxContinuations };
+    // Configurable execution safety quota, independent of model context/output capacity.
+    spec.budget = { schemaVersion: 1, mode: "hard", limits: { maxProviderRequests: sources.taskConfig.frontendRecovery?.maxProviderRequests ?? 1024 } };
+    spec.frontendExecutionPolicy = frontendExecutionPolicySchema.parse(sources.taskConfig.frontendExecutionPolicy ?? {});
     applyDefaultReadOnlyRetryPolicy(spec);
     stampGeneratedArtifactBindings(spec);
     parseDagSpec(spec);