@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.3

package/dist/worker/console/workspace-context.js

@@ -37,9 +37,6 @@ import { UserQuestionRegistry } from "./chat/user-questions.js";
 import { TodoListRegistry } from "./chat/todos.js";
 import { GoalRegistry } from "./chat/goals.js";
 import { GoalRoundDriver } from "./chat/goal-round-driver.js";
-import { TerminalSessionRegistry } from "./chat/terminal-sessions.js";
-import { ScmService } from "./chat/scm-service.js";
-import { BrowserAutomationService } from "./chat/browser-automation.js";
 import { driveGoalRound, recoverDeferredTurns } from "./chat/routes.js";
 import { createOperationEventStore, } from "./operation-sse.js";
 import { OperationStore } from "../../infrastructure/console/operation-store.js";
@@ -53,7 +50,6 @@ import { probePiReadiness, } from "./pi-readiness.js";
 import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 import { NightAuxTicker } from "./night-aux-ticker.js";
 import { createObserveRouteContext, } from "../observe/routes.js";
-import { WorkspaceInitializationService } from "./workspace-initialization.js";
 import { WorkspaceRegistry } from "./workspace-registry.js";
 import { resolveConsoleDefaultTimeoutMs } from "./server.js";
 /**
@@ -244,7 +240,6 @@ export async function createWorkspaceContext(record, deps) {
         readiness: readinessCache,
         getReadiness,
         refreshReadiness,
-        workspaceInitialization: new WorkspaceInitializationService({ workspaceId: record.workspaceId, name: record.name, repoRoot, client, operations, events, activeChatTurnCount: () => chatTurnExecutions.size() }),
         observeBaseUrl: deps.observeBaseUrl,
         fetchImpl: deps.fetchImpl,
         getConsoleOrigin: deps.getConsoleOrigin,
@@ -259,9 +254,7 @@ export async function createWorkspaceContext(record, deps) {
             }
         },
     });
-    const aimaxAuth = new AimaxAuthReader();
-    await aimaxAuth.getToken();
-    const sddDataAlignment = new SddDataAlignmentService(chatStore, aimaxAuth, deps.fetchImpl);
+    const sddDataAlignment = new SddDataAlignmentService(chatStore, new AimaxAuthReader(), deps.fetchImpl);
     const chatEventEpoch = randomBytes(12).toString("hex");
     const chatEvents = createChatEventStore({
         appData,
@@ -292,13 +285,6 @@ export async function createWorkspaceContext(record, deps) {
         operations,
         operationEvents: events,
     });
-    // Persistent PTY terminal sessions shared by the model tool (terminal) and
-    // the Console UI terminal panel (HTTP API), keyed per chat session owner.
-    const terminalRegistry = new TerminalSessionRegistry();
-    // Workspace-scoped git source control shared by the model tool (scm) and
-    // the Console UI SCM panel (HTTP API).
-    const scmService = new ScmService(repoRoot);
-    const browserAutomation = new BrowserAutomationService();
     const chatRuntime = new ConsolePiRuntime({
         cwd: repoRoot,
         sessionDir: appData.chatSessions,
@@ -308,9 +294,6 @@ export async function createWorkspaceContext(record, deps) {
         todoRegistry,
         goalRegistry,
         sddDataAlignment,
-        terminalRegistry,
-        scmService,
-        browserAutomation,
     });
     let chatRouteDeps;
     const goalRoundDriver = new GoalRoundDriver((sessionId) => driveGoalRound(chatRouteDeps, sessionId));
@@ -325,9 +308,6 @@ export async function createWorkspaceContext(record, deps) {
         sddDataAlignment,
         goalRoundDriver,
         operationLinker: chatOperationLinker,
-        terminals: terminalRegistry,
-        scm: scmService,
-        browserAutomation,
         appData,
         bootToken: deps.bootToken,
         getConsoleOrigin: deps.getConsoleOrigin,

package/dist/worker/observe/static/router.js

@@ -204,7 +204,7 @@ export function parseHashRouteWithFilters(hashValue) {
 	if (base.view === "dag") {
 		const params = new URLSearchParams(raw.includes("?") ? raw.slice(raw.indexOf("?") + 1) : "");
 		const nodeId = params.get("node");
-		if (nodeId) return { ...base, inspector: { nodeId, tab: params.get("tab") || null, executionKey: /^(attempt|pass)-[1-9]\d*$/.test(params.get("attempt") || "") ? params.get("attempt") : null } };
+		if (nodeId) return { ...base, inspector: { nodeId, tab: params.get("tab") || "output", executionKey: /^(attempt|pass)-[1-9]\d*$/.test(params.get("attempt") || "") ? params.get("attempt") : null } };
 	}
 	if (base.view === "dags") {
 		const history = parseDagHistoryQuery(raw);

package/dist/worker/observe/static/styles.css

@@ -1281,9 +1281,6 @@ body.is-resizing-dag-graph {
 	user-select: none;
 }
 .dag-inspector-header {
-	/* Keep the attempt menu above the content's sticky timeline toolbar. */
-	position: relative;
-	z-index: 6;
 	display: grid;
 	grid-template-columns: minmax(0, 1fr) auto;
 	gap: var(--space-3);
@@ -5404,10 +5401,10 @@ button.copy-command:focus-visible {
 .risk-dag-items { display: grid; gap: 6px; padding-top: 8px; }
 /* The hosted Console also has .panel styles; keep the reader shell flush. */
 #dag-inspector { padding: 0; gap: 0; }
-.dag-inspector-header .dag-inspector-attempt-bar { flex-wrap: wrap; gap: 8px; background: transparent; }
-.dag-inspector-header .dag-inspector-attempt-select { min-width: 112px; flex: 0 0 126px; }
-.dag-inspector-header .dag-inspector-attempt-preview { flex: 1 1 100px; flex-wrap: wrap; padding: 0; }
-.dag-inspector-header .dag-inspector-attempt-category { display: inline; white-space: normal; overflow-wrap: anywhere; }
+.dag-inspector-header .dag-inspector-attempt-bar { flex-wrap: nowrap; background: transparent; }
+.dag-inspector-header .dag-inspector-attempt-select { min-width: 0; flex: 0 1 126px; }
+.dag-inspector-header .dag-inspector-attempt-preview { flex: 1 1 auto; flex-wrap: nowrap; padding: 0; }
+.dag-inspector-header .dag-inspector-attempt-category,
 .dag-inspector-header .dag-inspector-attempt-duration { display: none; }
 @container (max-width: 560px) {
  .process-timeline-toolbar { display: grid; grid-template-columns: minmax(80px, 1fr) 32px 32px 32px; gap: 4px; }

package/dist/worker/observe/static/views/dag-inspector.js

@@ -518,9 +518,6 @@ function renderDagInspectorForCurrent() {
 
 function resetInspectorNodeSelection(dagRunId, nodeId) {
 	uiState.selectedDagNodeId = nodeId;
-	// Resolve the default after loading this node, rather than inheriting
-	// another node's tab. Explicit links and later tab clicks still win.
-	uiState.dagInspectorTab = null;
 	uiState.dagInspectorOpen = true;
 	// Each node opens in live-follow mode by default. The explicit floating
 	// control can pause it without losing the reader's current position.
@@ -3340,7 +3337,6 @@ function inspectorTabDefinitions(node = inspectorSelection.node) {
 	const options = node ? attemptSelectorOptions(node) : [];
 	const hasPassOnlyHistory = options[0]?.key.startsWith("pass-");
 	const tabDefs = DAG_INSPECTOR_READ_ONLY_TABS.filter(([tab]) => {
-		if (tab === "lineage") return Boolean(inspectorSelection.run?.continuation?.parentRunId);
 		if (tab === "context") return !["shell", "static"].includes(node?.executor) && !hasPassOnlyHistory;
 		if (tab === "timeline") return node?.executor !== "static";
 		return true;
@@ -3357,9 +3353,6 @@ function activeInspectorTab() {
 	const available = inspectorTabDefinitions().map(([tab]) => tab);
 	const requested = uiState.dagInspectorTab;
 	if (available.includes(requested)) return requested;
-	if (requested == null && ["running", "started"].includes(String(inspectorSelection.node?.status ?? "").toLowerCase())) {
-		return available.includes("timeline") ? "timeline" : "overview";
-	}
 	if (requested === "compare" && available.includes("timeline")) return "timeline";
 	return ["compare", "context", "timeline"].includes(requested) ? "overview" : "output";
 }
@@ -3590,13 +3583,21 @@ function buildAttemptBar(dagRunId, node) {
 
 	const bar = el("div", "dag-inspector-attempt-bar");
 	bar.appendChild(el("label", "dag-inspector-attempt-label", "执行分次"));
-	const choose = (nextKey) => {
+	const choose = (nextKey, source = "select") => {
 		uiState.dagInspectorAttempt = { dagRunId, nodeId: node.nodeId, key: String(nextKey) };
 		inspectorNodeSelections.set(`${dagRunId}:${node.nodeId}`, uiState.dagInspectorAttempt);
 		renderDagInspectorForCurrent();
 		const nextBar = document.querySelector(".dag-inspector-header .dag-inspector-attempt-bar");
-		nextBar?.querySelector(".custom-select-trigger")?.focus({ preventScroll: true });
+		const control = nextBar?.querySelector(`[data-attempt-action="${source}"]`);
+		(control && !control.disabled ? control : nextBar?.querySelector(".custom-select-trigger"))?.focus({ preventScroll: true });
 	};
+	const selectedIndex = options.findIndex((option) => option.key === selectedKey);
+	const previous = iconButton("上一次尝试", "ri-arrow-left-s-line");
+	previous.type = "button";
+	previous.dataset.attemptAction = "previous";
+	previous.disabled = selectedIndex <= 0;
+	previous.addEventListener("click", () => choose(options[selectedIndex - 1].key, "previous"));
+	bar.appendChild(previous);
 	const select = createCustomSelect({
 		ariaLabel: "选择执行分次",
 		className: "dag-inspector-attempt-select",
@@ -3611,6 +3612,12 @@ function buildAttemptBar(dagRunId, node) {
 	// `.value` after assign + change (StubNode handler contract).
 	select.value = selectedKey;
 	bar.appendChild(select);
+	const next = iconButton("下一次尝试", "ri-arrow-right-s-line");
+	next.type = "button";
+	next.dataset.attemptAction = "next";
+	next.disabled = selectedIndex >= options.length - 1;
+	next.addEventListener("click", () => choose(options[selectedIndex + 1].key, "next"));
+	bar.appendChild(next);
 
 	const selected =
 		options.find((option) => option.key === selectedKey) ??
@@ -3622,16 +3629,16 @@ function buildAttemptBar(dagRunId, node) {
 	if (status) {
 		preview.appendChild(el("span", `badge badge-${status.cls}`, status.label));
 	}
-	if (status?.cls === "failed") {
+	if (status?.cls === "failed" && data.failureCategory) {
 		// 仅失败尝试显示原因；部分 runtime 会在成功尝试保留
 		// failureCategory="success"，不能将其误映射为「其他失败原因」。
 		// 未知失败分类仍 fail-closed，raw token 仅保留在 title 诊断中。
 		const reason = el(
 			"span",
 			"dag-inspector-attempt-category",
-			data.failureCategory ? `原因 ${attemptFailureLabel(data.failureCategory)}` : "未记录失败原因",
+			`原因 ${attemptFailureLabel(data.failureCategory)}`,
 		);
-		if (data.failureCategory) reason.setAttribute("title", `failureCategory ${data.failureCategory}`);
+		reason.setAttribute("title", `failureCategory ${data.failureCategory}`);
 		preview.appendChild(reason);
 	}
 	if (data.durationMs !== undefined) {

package/dist/worker/observe/static/views/dag.js

@@ -263,7 +263,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		uiState.sessionEvents = [];
 		uiState.sessionEventIdentity = null;
 		uiState.dagInspectorOpen = false;
-		uiState.dagInspectorTab = null;
+		uiState.dagInspectorTab = "output";
 		uiState.dagInspectorAttempt = null;
 		uiState.dagGraphViewportState = null;
 		uiState.dagTimelineViewportState = null;
@@ -343,7 +343,7 @@ export async function renderDagDetail(dagRunId, initial = true) {
 		if (routeState?.nodeId && routeState.open !== false && nodes.some((node) => node.nodeId === routeState.nodeId)) {
 			uiState.selectedDagNodeId = routeState.nodeId;
 			uiState.dagInspectorOpen = true;
-			uiState.dagInspectorTab = ["overview", "input", "context", "timeline", "compare", "output", "lineage", "spec-evidence", "prompt-restart"].includes(routeState.tab) ? routeState.tab : null;
+			uiState.dagInspectorTab = ["overview", "input", "context", "timeline", "compare", "output", "lineage", "spec-evidence", "prompt-restart"].includes(routeState.tab) ? routeState.tab : "output";
 			uiState.dagInspectorAttempt = { dagRunId, nodeId: routeState.nodeId, key: routeState.executionKey };
 			uiState.sessionEventIdentity = makeSessionEventIdentity(dagRunId, routeState.nodeId);
 		}

package/dist/worker/scheduler/index.js

@@ -0,0 +1,25 @@
+export * from "./types.js";
+export * from "./paths.js";
+export * from "./lock.js";
+export * from "./trigger.js";
+export * from "./store.js";
+export * from "./lifecycle.js";
+export * from "./doctor.js";
+export * from "./traceability.js";
+export * from "./reservation.js";
+export * from "./workspace-adapter.js";
+export * from "./admission.js";
+export * from "./lease.js";
+export * from "./evidence.js";
+export * from "./night-git-finalizer.js";
+export * from "./dispatcher.js";
+export * from "./scheduler-loop.js";
+export * from "./night-harvest.js";
+export * from "./morning-window.js";
+export * from "./recovery.js";
+export * from "./retry.js";
+export * from "./prepared-attempt-recovery.js";
+export * from "./auto-followup.js";
+export * from "./clock.js";
+export * from "./clock-install.js";
+export { registerSchedulerCommands } from "./cli.js";

package/dist/workflows/dag/facts.js

@@ -0,0 +1,4 @@
+export * from "./decision-evidence.js";
+export * from "./failure-category.js";
+export * from "./recovery-recommendation.js";
+export * from "../../executors/shell-write-guard.js";

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

@@ -114,7 +114,7 @@ export function buildFrontendTestHandoff(input) {
  * required verification evidence. Anything else downgrades to pending.
  */
 export function deriveFrontendIntegrationFacts(input) {
-    const requiredEvidenceSatisfied = input.verificationTargets.some((target) => target.mode === "behavior") &&
+    const requiredEvidenceSatisfied = input.verificationTargets.length > 0 &&
         input.verificationTargets.every((target) => target.status === "ok");
     if (input.realApiEvidence.present &&
         input.realApiEvidence.passed &&

package/dist/workflows/dag/frontend-design-policy.js

@@ -1,12 +1,11 @@
 import { deterministicSha256, } from "./frontend-implementation-contract.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
-import { FRONTEND_MAX_IMPLEMENTATION_FILES } from "./frontend-capacity.js";
 const SHA256_HEX = /^[a-f0-9]{64}$/;
 const NPM_PACKAGE_NAME = /^(?:@[a-zA-Z0-9_.-]+\/)?[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
 /** Max concrete implementation files a single writeSet may carry before the
  * plan is asked to split. Kept at 15: beyond this, a single implement node's
  * read/edit loop inflates provider context toward overflow. */
-const MAX_WRITE_SET_FILES = FRONTEND_MAX_IMPLEMENTATION_FILES;
+const MAX_WRITE_SET_FILES = 15;
 function normalizeRelativePath(value) {
     return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }

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

@@ -345,11 +345,11 @@ export async function deriveFrontendVerifyCommandDirectoryFromRun(runDir) {
 }
 /**
  * A behavior verification target must bind a test file: the trace gate
- * binds results by frozen command and executed test file, without requiring
- * generated target ids in test titles. Enforced at the plan boundary and
+ * proves behavior targets by finding the target id in a real
+ * describe/it/test title inside `file`. Enforced at the plan boundary and
  * at materialization (path shape only — the writer may create the file).
  *
- * Only code files count: fixtures and
+ * Only code files count (the gate reads titles from source): fixtures and
  * data files such as `test/fixtures/data.json` are rejected even under a
  * test directory, as are helper/support/setup files (`cypress/fixtures/*`,
  * `tests/support/*`, `setup.*`) that never carry describe/it/test titles.
@@ -2377,7 +2377,7 @@ export async function analyzeFrontendImplementationContract(input) {
                 record.commandLabel = entry.label;
                 const file = asString(record.file);
                 if (entry.mode === "behavior" && file && !isFrontendTestFilePath(file)) {
-                    fail("retryable-invalid", `invalid-output: verification-target-phase-mismatch: verification target "${vtId}" binds behavior command "${entry.label}" (${entry.commandId}) to non-test file "${file}"; behavior targets must bind a test file (__tests__/, tests?/, e2e/, cypress/, *.test.*, *.spec.*, *.cy.*) so verification can bind runner evidence to the declared test file`, candidateJsonSha256);
+                    fail("retryable-invalid", `invalid-output: verification-target-phase-mismatch: verification target "${vtId}" binds behavior command "${entry.label}" (${entry.commandId}) to non-test file "${file}"; behavior targets must bind a test file (__tests__/, tests?/, e2e/, cypress/, *.test.*, *.spec.*, *.cy.*) so the trace gate can match the target id in a real describe/it/test title`, candidateJsonSha256);
                 }
             }
             pushAction("resolve-verification-command-ids");
@@ -2509,10 +2509,6 @@ function splitFrontendContractReviewGroup(canonical, fields) {
         if (!Object.hasOwn(canonical, field))
             continue;
         const fieldValue = canonical[field];
-        // JSON omits undefined object properties; the index must describe the
-        // persisted contract, not phantom keys retained by normalization.
-        if (fieldValue === undefined)
-            continue;
         if (!Array.isArray(fieldValue)) {
             const candidate = { ...data, [field]: fieldValue };
             if (Object.keys(data).length > 0 &&

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

@@ -702,10 +702,10 @@ export async function runFrontendPrewriteGate(input) {
             failureCode: "mock-strategy-outside-allowed",
         });
     }
-    // Behavior verification needs bound Mock evidence. Build-only implementation
-    // does not claim tested Mock behavior and may defer those commands.
+    // Mock command binding (main): a non-not-needed strategy can only be proven
+    // by the DAG's frozen Mock verification commands. Block before any write is
+    // authorized when none were materialized at generation time.
     if (mockStrategy !== "not-needed" &&
-        analysis.canonical.verificationTargets.some((target) => target.mode === "behavior") &&
         (input.config.mockCommandLabels?.length ?? 0) === 0) {
         return finalizePrewrite(input, {
             ...basePending,

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

@@ -24,50 +24,6 @@ export const frontendCommandCategorySchema = z.enum([
     "unit-test",
     "trace",
 ]);
-/**
- * Ordered string-blob rules. Order is the contract: the first matching rule wins,
- * so rules that share keywords keep their original precedence. `nodeIdIncludes`
- * and `blobIncludes` are alternatives within one rule (logical OR).
- */
-const BLOB_RULES = [
-    {
-        result: "contract",
-        nodeIdIncludes: ["contract"],
-        blobIncludes: ["contract mismatch", "source binding"],
-    },
-    { result: "trace", nodeIdIncludes: ["trace"], blobIncludes: ["trace:"] },
-    { result: "review", nodeIdIncludes: ["review"] },
-    {
-        result: "unit-test",
-        nodeIdIncludes: ["behavior"],
-        blobIncludes: ["vitest", "jest", "npm test"],
-    },
-    {
-        result: "typecheck",
-        blobIncludes: ["typecheck", "tsc"],
-        blobPatterns: [/error ts\d+/i],
-    },
-    { result: "lint", blobIncludes: ["eslint", "lint"] },
-    // "vite build"/"next build" are subsumed by "build".
-    { result: "build", blobIncludes: ["build"] },
-    {
-        result: "component-test",
-        blobIncludes: ["testing-library", "component", "render("],
-    },
-    {
-        result: "dependency",
-        blobIncludes: ["package.json", "unapproved dependency", "npm install"],
-    },
-    {
-        result: "credential",
-        blobIncludes: ["credential", "api key", "secret"],
-    },
-    { result: "deploy", blobIncludes: ["deploy", "production release"] },
-    {
-        result: "spec-unclear",
-        blobIncludes: ["spec unclear", "requirement ambiguous", "needs human"],
-    },
-];
 export function classifyFrontendFailure(input) {
     // AC-2: structured evidence takes priority over string-blob heuristics.
     if (input.failureCategory === "write-guard") {
@@ -83,21 +39,86 @@ export function classifyFrontendFailure(input) {
         return "trace";
     }
     if (input.commandCategory) {
-        // "trace" already returned above, so the remaining categories map 1:1.
-        return input.commandCategory;
+        switch (input.commandCategory) {
+            case "typecheck":
+                return "typecheck";
+            case "build":
+                return "build";
+            case "lint":
+                return "lint";
+            case "component-test":
+                return "component-test";
+            case "unit-test":
+                return "unit-test";
+        }
     }
-    // Fallback: ordered string-blob heuristics. Only the shell executor's
-    // structured category proves a write-boundary failure, so blob text never
-    // overrides the structured checks above.
+    // Fallback: string-blob heuristic, preserved in its original branch order so
+    // legacy assertions (error TS2304 → typecheck, write-guard → path, etc.) stay green.
     const blob = `${input.nodeId}\n${input.failureCategory ?? ""}\n${input.stdout ?? ""}\n${input.stderr ?? ""}`.toLowerCase();
-    for (const rule of BLOB_RULES) {
-        if (rule.nodeIdIncludes?.some((keyword) => input.nodeId.includes(keyword)) ||
-            rule.blobIncludes?.some((keyword) => blob.includes(keyword)) ||
-            rule.blobPatterns?.some((pattern) => pattern.test(blob))) {
-            return rule.result;
-        }
+    if (input.nodeId.includes("contract") ||
+        blob.includes("contract mismatch") ||
+        blob.includes("source binding")) {
+        return "contract";
+    }
+    // Shell verification may contain test-runner logs from unrelated tests. Only
+    // the shell executor's structured category proves a write-boundary failure.
+    if (input.failureCategory === "write-guard") {
+        return "path";
+    }
+    if (input.nodeId.includes("trace") || blob.includes("trace:")) {
+        return "trace";
+    }
+    if (input.nodeId.includes("review")) {
+        return "review";
+    }
+    // Classify the failed verification command before inspecting its output.
+    // Full test output includes unrelated passing-test titles such as
+    // "secret-shaped" and "write-guard failure".
+    if (blob.includes("vitest") ||
+        blob.includes("jest") ||
+        blob.includes("npm test") ||
+        input.nodeId.includes("behavior")) {
+        return "unit-test";
+    }
+    if (blob.includes("typecheck") ||
+        blob.includes("tsc") ||
+        /error ts\d+/i.test(blob)) {
+        return "typecheck";
+    }
+    if (blob.includes("eslint") || blob.includes("lint")) {
+        return "lint";
+    }
+    if (blob.includes("build") ||
+        blob.includes("vite build") ||
+        blob.includes("next build")) {
+        return "build";
+    }
+    if (blob.includes("testing-library") ||
+        blob.includes("component") ||
+        blob.includes("render(")) {
+        return "component-test";
+    }
+    if (blob.includes("package.json") ||
+        blob.includes("unapproved dependency") ||
+        blob.includes("npm install")) {
+        return "dependency";
+    }
+    if (blob.includes("credential") ||
+        blob.includes("api key") ||
+        blob.includes("secret")) {
+        return "credential";
+    }
+    if (blob.includes("deploy") || blob.includes("production release")) {
+        return "deploy";
+    }
+    if (blob.includes("spec unclear") ||
+        blob.includes("requirement ambiguous") ||
+        blob.includes("needs human")) {
+        return "spec-unclear";
     }
     if (input.failureCategory === "invalid-output")
         return "contract";
+    if (input.failureCategory === "write-guard")
+        return "path";
     return "unknown";
 }

package/dist/workflows/dag/frontend-review-context.js

@@ -246,8 +246,7 @@ function assertReviewEvidence(input) {
     const trace = input.verificationTrace;
     const expectedTargets = new Map(contract.data.verificationTargets.map((target) => [target.id, target]));
     const actualTargets = Array.isArray(trace?.targets) ? trace.targets : [];
-    const mockEvidenceBound = contract.data.verificationTargets.every((target) => target.mode === "static") ||
-        contract.data.mockApi.strategy === "not-needed" ||
+    const mockEvidenceBound = contract.data.mockApi.strategy === "not-needed" ||
         (typeof trace?.mockCommandNodeId === "string" && trace.mockCommandNodeId.length > 0 &&
             Array.isArray(trace?.mockCommandLabels) && trace.mockCommandLabels.length > 0 &&
             Array.isArray(trace?.mockCommandTexts) && trace.mockCommandTexts.length === trace.mockCommandLabels.length &&

package/dist/workflows/dag/frontend-review-scopes.js

@@ -4,11 +4,6 @@ import path from "node:path";
 import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
 import { readCommittedEvents } from "./frontend-typed-event-store.js";
 import { stageTypedEventFact, adoptTypedEventFact } from "./frontend-typed-event-transaction.js";
-const invalidScope = (message) => Object.assign(new Error(`FRONTEND_REVIEW_SCOPE_INVALID: ${message}`), { code: "FRONTEND_REVIEW_SCOPE_INVALID" });
-const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-const isArtifactReference = (value) => isRecord(value)
-    && typeof value.path === "string" && value.path.length > 0
-    && typeof value.sha256 === "string" && /^[a-f0-9]{64}$/.test(value.sha256);
 const hash = (text) => createHash("sha256").update(text).digest("hex");
 /** The section index is navigation; reconstruct coverage against the canonical source before using it. */
 export async function loadFrontendReviewScopes(runDir, phase, targetBytes) {
@@ -17,7 +12,7 @@ export async function loadFrontendReviewScopes(runDir, phase, targetBytes) {
     async function read(relative, expected) {
         const absolute = path.resolve(root, relative);
         if (!absolute.startsWith(root + path.sep) || (await lstat(absolute)).isSymbolicLink() || !(await realpath(absolute)).startsWith(root + path.sep))
-            throw invalidScope("artifact escaped run");
+            throw Error("FRONTEND_REVIEW_SCOPE_INVALID: artifact escaped run");
         const text = await readFile(absolute, "utf8");
         const sha256 = hash(text);
         if (expected && sha256 !== expected)
@@ -35,62 +30,45 @@ export async function loadFrontendReviewScopes(runDir, phase, targetBytes) {
         throw error;
     }
     const index = JSON.parse(indexArtifact.text);
-    if (!isRecord(index) || !isArtifactReference(index.contract) || !Array.isArray(index.sections))
-        throw invalidScope("malformed contract index");
     const canonicalArtifact = await read(index.contract.path, index.contract.sha256);
     const canonical = JSON.parse(canonicalArtifact.text);
-    if (!isRecord(canonical))
-        throw invalidScope("canonical contract must be an object");
     const covered = new Map();
     const sections = [];
     const ids = new Set();
     for (const entry of index.sections) {
-        if (!isRecord(entry) || !isArtifactReference(entry) || !Array.isArray(entry.slices))
-            throw invalidScope("malformed section index entry");
         if (ids.has(entry.path))
-            throw invalidScope("duplicate section identity");
+            throw Error("FRONTEND_REVIEW_SCOPE_INVALID: duplicate section identity");
         ids.add(entry.path);
         const section = await read(entry.path, entry.sha256);
         const payload = JSON.parse(section.text);
-        if (!isRecord(payload) || !Array.isArray(payload.slices) || !isRecord(payload.data))
-            throw invalidScope(`malformed section: ${entry.path}`);
         if (payload.contractSha256 !== canonicalArtifact.sha256 || sha256OfCanonicalJson(payload.slices) !== sha256OfCanonicalJson(entry.slices))
-            throw invalidScope("unbound section");
+            throw Error("FRONTEND_REVIEW_SCOPE_INVALID: unbound section");
         for (const slice of payload.slices) {
-            if (!isRecord(slice) || typeof slice.field !== "string" || !Object.hasOwn(canonical, slice.field) || !Object.hasOwn(payload.data, slice.field))
-                throw invalidScope(`missing or invalid field reference in ${entry.path}: ${String(slice?.field)}`);
             const value = canonical[slice.field];
+            const range = Array.isArray(value) ? value.slice(slice.start, slice.end) : value;
+            if (sha256OfCanonicalJson(range) !== sha256OfCanonicalJson(payload.data[slice.field]))
+                throw Error("FRONTEND_REVIEW_SCOPE_INVALID: section differs from canonical obligation");
             const positions = covered.get(slice.field) ?? new Set();
             if (Array.isArray(value)) {
                 if (!Number.isInteger(slice.start) || !Number.isInteger(slice.end) || slice.start < 0 || slice.end < slice.start || slice.end > value.length || slice.total !== value.length)
-                    throw invalidScope("invalid array coverage");
-                if ((value.length === 0 && covered.has(slice.field)) || (value.length > 0 && slice.start === slice.end))
-                    throw invalidScope(`empty or duplicate array coverage: ${slice.field}`);
+                    throw Error("FRONTEND_REVIEW_SCOPE_INVALID: invalid array coverage");
                 for (let i = slice.start; i < slice.end; i++) {
                     if (positions.has(i))
-                        throw invalidScope("overlapping coverage");
+                        throw Error("FRONTEND_REVIEW_SCOPE_INVALID: overlapping coverage");
                     positions.add(i);
                 }
             }
             else {
-                if (["start", "end", "total"].some(key => Object.hasOwn(slice, key)))
-                    throw invalidScope(`scalar field has array range: ${slice.field}`);
                 if (positions.size)
-                    throw invalidScope("duplicate field");
+                    throw Error("FRONTEND_REVIEW_SCOPE_INVALID: duplicate field");
                 positions.add(0);
             }
-            const range = Array.isArray(value) ? value.slice(slice.start, slice.end) : value;
-            if (sha256OfCanonicalJson(range) !== sha256OfCanonicalJson(payload.data[slice.field]))
-                throw invalidScope(`section differs from canonical obligation: ${slice.field}`);
             covered.set(slice.field, positions);
         }
-        const sectionFields = new Set(payload.slices.map(slice => slice.field));
-        if (Object.keys(payload.data).some(field => !sectionFields.has(field)))
-            throw invalidScope(`unindexed section data: ${entry.path}`);
         sections.push(section);
     }
     if (Object.keys(canonical).some(field => !covered.has(field) || covered.get(field).size !== (Array.isArray(canonical[field]) ? canonical[field].length : 1)))
-        throw invalidScope("canonical field coverage incomplete");
+        throw Error("FRONTEND_REVIEW_SCOPE_INVALID: canonical field coverage incomplete");
     const scopes = Buffer.byteLength(canonicalArtifact.text) <= targetBytes ? [canonicalArtifact] : sections;
     if (phase === "review") {
         const context = await read("contracts/frontend-review-context.json");
@@ -121,11 +99,11 @@ export function createFrontendReviewScopeProtocol(input) {
         committedFacts: () => readCommittedEvents(input.getStore(), input.attemptId),
         assertComplete() { const missing = input.inventory?.scopes.filter(s => !completedScopeIds().has(s.id)) ?? []; if (missing.length)
             throw Object.assign(Error(`FRONTEND_REVIEW_SCOPE_INCOMPLETE: ${missing.map(s => s.id).join(", ")}`), { code: "FRONTEND_REVIEW_SCOPE_INCOMPLETE" }); },
-        customTools: !input.inventory ? [] : [{ name: "complete_review_scope", label: "complete_review_scope", description: "After reviewing the supplied complete scope and saving its findings, checkpoint its exact runtime id. This does not approve the implementation or design.", parameters: { type: "object", properties: { id: { type: "string", minLength: 1, enum: input.inventory.scopes.map(scope => scope.id) } }, required: ["id"], additionalProperties: false },
+        customTools: !input.inventory ? [] : [{ name: "complete_review_scope", label: "complete_review_scope", description: "After reviewing the supplied complete scope and saving its findings, checkpoint its exact runtime id. This does not approve the implementation or design.", parameters: { type: "object", properties: { id: { type: "string", minLength: 1 } }, required: ["id"], additionalProperties: false },
                 async execute(callId, params) {
                     const scope = input.inventory.scopes.find(s => s.id === params.id);
                     if (!scope || !active.has(params.id))
-                        return receipt({ ok: false, code: "FRONTEND_INPUT_SCOPE_VIOLATION", error: "Only the supplied active review scope may be completed; use an exact activeScopeIds entry, not the node name", activeScopeIds: [...active], completedScopeIds: [...completedScopeIds()] });
+                        return receipt({ ok: false, code: "FRONTEND_INPUT_SCOPE_VIOLATION", error: "Only the supplied active review scope may be completed" });
                     await input.inventory.validate();
                     const store = input.getStore();
                     const requestId = `${input.attemptId}:${callId}:${randomUUID()}`;

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

@@ -1,5 +1,4 @@
 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";
@@ -223,13 +222,7 @@ function extractRuntimeShapeEvidence(input) {
         !sourceText.includes(path) &&
         /(?:\.[A-Za-z0-9]+|\*\*)$/.test(path));
     const routes = canonicalStrings(text.match(/\/(?:[A-Za-z0-9_:[\]-]+\/?)+/g) ?? []);
-    // 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);
+    const splitRequired = /["']splitRequired["']\s*:\s*true|\bsplit-required\s+shape\b/i.test(text);
     return {
         sourceNodeId: input.sourceNodeId,
         sourceNodeDigest: computeFrontendShapeNodeDigest(node),
@@ -239,10 +232,7 @@ function extractRuntimeShapeEvidence(input) {
         targetPaths,
         routes,
         splitRequired,
-        evidenceRefs: [
-            ...(capacitySplit ? ["dag:frontend-plan-pi:structuredContractOutput.skeleton.targets.files"] : []),
-            `node:${input.sourceNodeId}:stdout`,
-        ],
+        evidenceRefs: [`node:${input.sourceNodeId}:stdout`],
     };
 }
 /** Commit a typed, structured runtime fact immediately after a canonical source