@tea-agent/loop-agent 0.38.0 → 0.38.1

package/dist/worker/console/static-src/operator-chat/resource-diagnostics.js

@@ -0,0 +1,204 @@
+/**
+ * Resource-panel diagnostics presentation.
+ *
+ * Pi ResourceLoader emits machine English (`warning` / `collision` + full
+ * Windows paths). The Skills / Packages / Models panels must not dump that
+ * block above the inventory — it pushes the list off-screen. Classify here,
+ * then render a header chip + grouped popover with natural Chinese copy.
+ */
+const COLLISION_NAME = /name\s+"([^"]+)"\s+collision/i;
+const INVALID_CHARS = /invalid characters|must be lowercase/i;
+const INVALID_EDGE_HYPHEN = /must not start or end with a hyphen/i;
+const INVALID_DOUBLE_HYPHEN = /consecutive hyphens/i;
+const GROUP_COPY = {
+    "load-failed": {
+        heading: "需要处理",
+        hint: "有些清单没读完整，下面的列表可能不全。",
+    },
+    "invalid-name": {
+        heading: "名称不规范",
+        hint: "技能已经加载，还能用。名称请改成小写字母、数字和连字符，例如 sdd-requirement-analysis。",
+    },
+    collision: {
+        heading: "同名未生效",
+        hint: "同名技能只保留先扫到的那一份，后面的不会进当前会话。",
+    },
+    other: {
+        heading: "其他提示",
+        hint: "不影响你浏览当前列表。",
+    },
+};
+const GROUP_ORDER = [
+    "load-failed",
+    "invalid-name",
+    "collision",
+    "other",
+];
+export function shortResourcePath(path) {
+    if (!path)
+        return undefined;
+    const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+    if (parts.length === 0)
+        return path;
+    const file = parts.at(-1);
+    if (!file)
+        return path;
+    const parent = parts.at(-2);
+    return parent ? `${parent}/${file}` : file;
+}
+export function skillNameFromPath(path) {
+    if (!path)
+        return undefined;
+    const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+    if (parts.length === 0)
+        return undefined;
+    const last = parts.at(-1);
+    if (!last)
+        return undefined;
+    if (/^skill\.md$/i.test(last) && parts.length >= 2) {
+        return parts.at(-2);
+    }
+    return last.replace(/\.md$/i, "");
+}
+export function diagnosticMatchesSkill(item, skill) {
+    if (item.path) {
+        const left = item.path.replace(/\\/g, "/").toLowerCase();
+        const right = skill.path.replace(/\\/g, "/").toLowerCase();
+        if (left === right || left.endsWith(right) || right.endsWith(left)) {
+            return true;
+        }
+    }
+    return Boolean(item.skillName && item.skillName === skill.name);
+}
+function shortenMessage(message) {
+    const trimmed = message.trim();
+    if (trimmed.length <= 80)
+        return trimmed;
+    return `${trimmed.slice(0, 79)}…`;
+}
+function titleForLoadFailed(diag) {
+    const hay = `${diag.code ?? ""} ${diag.message}`.toLowerCase();
+    if (hay.includes("preference"))
+        return "自动使用偏好读不出来";
+    if (hay.includes("package"))
+        return "软件包清单没读完整";
+    if (hay.includes("skill"))
+        return "技能清单没读完整";
+    if (hay.includes("extension"))
+        return "扩展没读完整";
+    if (hay.includes("prompt"))
+        return "提示词没读完整";
+    if (hay.includes("theme"))
+        return "主题没读完整";
+    if (hay.includes("context"))
+        return "上下文文件没读完整";
+    return "有些内容没读完整";
+}
+function detailForInvalidName(message) {
+    if (INVALID_DOUBLE_HYPHEN.test(message)) {
+        return "名称里不要连用两个连字符。现在这样也能用。";
+    }
+    if (INVALID_EDGE_HYPHEN.test(message)) {
+        return "名称开头和结尾不要用连字符。现在这样也能用。";
+    }
+    return "名称请只用小写字母、数字和连字符。现在这样也能用。";
+}
+export function classifyResourceDiagnostic(diag) {
+    const type = (diag.type ?? "warning").toLowerCase();
+    const message = diag.message ?? "";
+    const collisionMatch = message.match(COLLISION_NAME) ??
+        (type === "collision" ? message.match(/"([^"]+)"/) : null);
+    if (type === "collision" || collisionMatch) {
+        const skillName = collisionMatch?.[1] ?? skillNameFromPath(diag.path);
+        return {
+            kind: "collision",
+            tone: "warning",
+            title: skillName ? `「${skillName}」有多份` : "有一份同名技能没生效",
+            detail: "同名只保留先扫到的那一份，这份被盖掉了。",
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            skillName,
+            retryable: false,
+        };
+    }
+    if (INVALID_CHARS.test(message) ||
+        INVALID_EDGE_HYPHEN.test(message) ||
+        INVALID_DOUBLE_HYPHEN.test(message)) {
+        const skillName = skillNameFromPath(diag.path);
+        return {
+            kind: "invalid-name",
+            tone: "warning",
+            title: skillName ?? "有个技能名称不合规范",
+            detail: detailForInvalidName(message),
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            skillName,
+            retryable: false,
+        };
+    }
+    const isLoadFailed = type === "error" ||
+        diag.retryable === true ||
+        diag.code === "RESOURCE_LOAD_FAILED" ||
+        diag.code === "PACKAGE_INVENTORY_FAILED" ||
+        diag.code === "PI_RESOURCE_PREFERENCES_MALFORMED";
+    if (isLoadFailed) {
+        return {
+            kind: "load-failed",
+            tone: "error",
+            title: titleForLoadFailed(diag),
+            detail: shortenMessage(message),
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            retryable: diag.retryable === true,
+        };
+    }
+    return {
+        kind: "other",
+        tone: type === "error" ? "error" : "warning",
+        title: shortenMessage(message) || "一条提示",
+        path: diag.path,
+        shortPath: shortResourcePath(diag.path),
+        retryable: false,
+    };
+}
+export function summarizeResourceDiagnostics(diagnostics) {
+    const items = diagnostics.map(classifyResourceDiagnostic);
+    const buckets = new Map();
+    for (const item of items) {
+        const list = buckets.get(item.kind) ?? [];
+        list.push(item);
+        buckets.set(item.kind, list);
+    }
+    const groups = GROUP_ORDER.flatMap((kind) => {
+        const groupItems = buckets.get(kind);
+        if (!groupItems?.length)
+            return [];
+        return [{ kind, ...GROUP_COPY[kind], items: groupItems }];
+    });
+    const errorCount = items.filter((item) => item.tone === "error").length;
+    const warningCount = items.length - errorCount;
+    return {
+        total: items.length,
+        errorCount,
+        warningCount,
+        chipLabel: chipLabel(errorCount, warningCount),
+        groups,
+    };
+}
+function chipLabel(errorCount, warningCount) {
+    if (errorCount > 0 && warningCount > 0) {
+        return `${errorCount} 个问题 · ${warningCount} 条提示`;
+    }
+    if (errorCount > 0) {
+        return errorCount === 1 ? "1 个问题" : `${errorCount} 个问题`;
+    }
+    if (warningCount === 1)
+        return "1 条提示";
+    return `${warningCount} 条提示`;
+}
+export function skillHasNameWarning(skill, items) {
+    return items.some((item) => item.kind === "invalid-name" && diagnosticMatchesSkill(item, skill));
+}
+export function noticesForSkill(skill, items) {
+    return items.filter((item) => item.kind !== "collision" && diagnosticMatchesSkill(item, skill));
+}

package/dist/worker/console/static-src/operator-chat/useChatSessions.js

@@ -5,6 +5,7 @@ import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
 import { CHAT_SESSION_LIST_LIMIT } from "../chat-view-types.js";
 import { confirmationToken } from "./format.js";
+import { describeMutationGateFailure, isMutationGateFailureCode, isStaleTokenFailure, } from "./mutation-gate.js";
 import { SessionTitleWatcher } from "./session-title-watcher.js";
 export async function createSessionAndPrimeTitleWatcher(input) {
     if (input.creatingRef?.current) {
@@ -69,6 +70,8 @@ export function useChatSessions(params) {
     // Shared busy gate for sidebar + Landing create entries (one render feedback).
     const [creatingSession, setCreatingSession] = useState(false);
     const creatingSessionRef = useRef(false);
+    /** One-shot guard so a stale-token failure schedules a single page reload. */
+    const compactReloadScheduledRef = useRef(false);
     // Only the latest activate/create/restore intent may commit active-session
     // state. This prevents slow responses from an older selection overwriting a
     // newer user choice.
@@ -396,6 +399,18 @@ export function useChatSessions(params) {
             });
             const body = (await response.json().catch(() => ({})));
             if (!response.ok) {
+                const gateCode = body.error?.code;
+                if (isMutationGateFailureCode(gateCode)) {
+                    // Stale boot tokens: the page predates the current server boot.
+                    // Auto-reload once so the fresh boot page re-injects tokens; keep
+                    // an error line up while reloading in case reload is blocked.
+                    setError(describeMutationGateFailure(gateCode));
+                    if (isStaleTokenFailure(gateCode) && !compactReloadScheduledRef.current) {
+                        compactReloadScheduledRef.current = true;
+                        window.setTimeout(() => window.location.reload(), 1200);
+                    }
+                    return;
+                }
                 setError(body.error?.message ?? "上下文压缩失败");
                 return;
             }

package/dist/worker/console/static-src/operator-chat/useChatStream.js

@@ -242,9 +242,14 @@ export function useChatStream(params) {
     /** Issue real POST /abort for a known turnId (Stop never disposes Session). */
     const postAbortForTurn = useCallback(async (sessionId, generation, turnId) => {
         refs.stoppingTurnIdRef.current = turnId;
-        // Keep streaming/busy while abort is in flight (UIS-stopping).
-        refs.streamingRef.current = true;
-        setStreaming(true);
+        // Optimistic stop (pi-web parity): the abort signal kills the SDK
+        // process tree promptly, so flip the UI idle NOW instead of holding
+        // the busy spinner through the whole POST /abort round-trip. If the
+        // server later reports the turn still running (TURN_ABORT_PENDING
+        // or owner-lost reconcile), applyAbortDecision restores busy state.
+        refs.streamingRef.current = false;
+        setStreaming(false);
+        setStreamingAssistantId(null);
         try {
             const res = await fetch(operatorChatAbortUrl(origin, sessionId, turnId), {
                 method: "POST",
@@ -285,6 +290,10 @@ export function useChatStream(params) {
                 markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
             });
             applyOwnershipBagToRefs(refs, bag);
+            // Sync the post-decision busy state back to React: optimistic stop
+            // flipped it idle up front; pending/keep-busy outcomes restore it.
+            if (bag.streaming)
+                setStreaming(true);
         }
         catch {
             // Abort network failure: keep busy (UIS-abort-network-fail).
@@ -297,6 +306,10 @@ export function useChatStream(params) {
                 networkError: true,
             }), noticeSink());
             applyOwnershipBagToRefs(refs, bag);
+            // Network failure: the optimistic idle was premature — restore busy
+            // so the turn is not silently dropped; /state reconcile converges.
+            refs.streamingRef.current = true;
+            setStreaming(true);
         }
     }, [
         origin,
@@ -371,7 +384,7 @@ export function useChatStream(params) {
             refs.streamingRef.current ||
             refs.submitInFlightRef.current ||
             // AC-R5-002: ownership lease blocks send until terminal release.
-            Boolean(refs.pendingSubmissionRef.current))
+            refs.pendingSubmissionRef.current)
             return;
         // AC-001: acquire synchronous submit ownership before the first await.
         refs.submitInFlightRef.current = true;

package/dist/worker/console/static-src/operator-chat/useChatThread.js

@@ -1,6 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
-import { parseAssistantContent } from "../../chat/assistant-content.js";
-import { buildTurnProcessGroups } from "../../chat/turn-process.js";
+import { buildTurnProcessGroups, hydrateSessionThread, selectRecentTurnGroups, } from "../../chat/turn-process.js";
 import { createChatSseEventApplier, } from "./chat-sse-events.js";
 import { taskContextUnchanged } from "./format.js";
 const EMPTY_USAGE = {
@@ -121,9 +120,7 @@ export function useChatThread(params) {
         }, 350);
         return () => window.clearTimeout(timer);
     }, [sessionId, operationCards, humanGateCards, interview, loadTaskContext]);
-    const visibleMessages = useMemo(() => messages
-        .filter((m) => m.role !== "system" || showSystemInMessages)
-        .slice(-historyLimit), [messages, showSystemInMessages, historyLimit]);
+    const timelineMessages = useMemo(() => messages.filter((m) => m.role !== "system" || showSystemInMessages), [messages, showSystemInMessages]);
     useEffect(() => {
         const onVisibility = () => {
             if (!document.hidden)
@@ -158,12 +155,30 @@ export function useChatThread(params) {
             statusKind,
         };
     }, [toolCalls]);
-    const turnGroups = useMemo(() => buildTurnProcessGroups({
-        messages: visibleMessages,
+    const turnGroups = useMemo(() => {
+        const all = buildTurnProcessGroups({
+            messages: timelineMessages,
+            toolCalls,
+            streaming,
+            activeAssistantId: streamingAssistantId,
+        });
+        return selectRecentTurnGroups(all, historyLimit);
+    }, [
+        timelineMessages,
         toolCalls,
         streaming,
-        activeAssistantId: streamingAssistantId,
-    }), [visibleMessages, toolCalls, streaming, streamingAssistantId]);
+        streamingAssistantId,
+        historyLimit,
+    ]);
+    const visibleMessages = useMemo(() => {
+        const next = [];
+        for (const group of turnGroups) {
+            if (group.user)
+                next.push(group.user);
+            next.push(...group.assistants);
+        }
+        return next;
+    }, [turnGroups]);
     /** Reset all session-scoped projections before adopting a fresh session. */
     const resetForNewSession = useCallback(() => {
         setMessages([]);
@@ -220,18 +235,9 @@ export function useChatThread(params) {
             refs.seenEventIdsRef.current = new Set();
             refs.turnAssistantIdsRef.current = new Map();
             refs.sealedAssistantIdsRef.current = new Set();
-            setMessages((body.session.messages ?? [])
-                .filter((message) => message.role === "user" || message.role === "assistant")
-                .map((message) => {
-                const content = parseAssistantContent(message.content);
-                return {
-                    id: message.id,
-                    role: message.role,
-                    text: message.text,
-                    createdAt: Date.parse(message.at) || Date.now(),
-                    ...(content && content.length > 0 ? { content } : {}),
-                };
-            }));
+            const hydrated = hydrateSessionThread(body.session.messages ?? []);
+            setMessages(hydrated.messages);
+            setToolCalls(hydrated.toolCalls);
             setStreamingAssistantId(null);
             return true;
         }
@@ -240,7 +246,7 @@ export function useChatThread(params) {
             // trigger another reconcile and retry (best-effort recovery).
             return false;
         }
-    }, [origin, refs, setMessages, setStreamingAssistantId]);
+    }, [origin, refs, setMessages, setToolCalls, setStreamingAssistantId]);
     return {
         messages,
         setMessages,

package/dist/worker/console/static-src/operator-chat/useRepoBrowser.js

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
 /** Left-rail repo tree + file preview tabs state. */
 export function useRepoBrowser(params) {
@@ -9,6 +9,8 @@ export function useRepoBrowser(params) {
     const [previews, setPreviews] = useState([]);
     const [activePreviewPath, setActivePreviewPath] = useState(null);
     const [previewLoading, setPreviewLoading] = useState(false);
+    const expandedDirsRef = useRef(new Set());
+    expandedDirsRef.current = expandedDirs;
     const loadTree = useCallback(async (directory = "") => {
         try {
             setTreeError(null);
@@ -28,6 +30,28 @@ export function useRepoBrowser(params) {
     useEffect(() => {
         void loadTree();
     }, [loadTree]);
+    /** pi-web parity: re-fetch the root + every expanded directory. Bump
+     *  `refreshTick` to trigger; cached entries are NOT reused, so newly
+     *  created/deleted files appear without a manual refresh. */
+    const [refreshTick, setRefreshTick] = useState(0);
+    const refreshTree = useCallback(() => {
+        setRefreshTick((tick) => tick + 1);
+    }, []);
+    useEffect(() => {
+        const dirs = ["", ...expandedDirsRef.current];
+        for (const dir of dirs)
+            void loadTree(dir);
+    }, [loadTree, refreshTick]);
+    // Also refresh when the tab regains focus: external tools (editor, git,
+    // CLI) may have changed the tree while the console was hidden.
+    useEffect(() => {
+        const onVisibility = () => {
+            if (!document.hidden)
+                refreshTree();
+        };
+        document.addEventListener("visibilitychange", onVisibility);
+        return () => document.removeEventListener("visibilitychange", onVisibility);
+    }, [refreshTree]);
     const openPreview = useCallback(async (file) => {
         setPreviewLoading(true);
         try {
@@ -116,6 +140,7 @@ export function useRepoBrowser(params) {
         previewLoading,
         setPreviews,
         loadTree,
+        refreshTree,
         openPreview,
         closePreview,
         toggleDir,

package/dist/workflows/dag/contract-validator-registrations.js

@@ -3,6 +3,7 @@
  * its schemaId in the contract output registry. Imported once by the node
  * executor; keeps per-contract imports out of the executor.
  */
-import { validateFrontendContractNodeOutput } from "./frontend-implementation-contract.js";
+import { validateFrontendContractNodeOutput, validateFrontendRevisionPatchNodeOutput, } from "./frontend-implementation-contract.js";
 import { registerStructuredContractValidator } from "./contract-output-registry.js";
 registerStructuredContractValidator("frontend-implementation-contract-v1", validateFrontendContractNodeOutput);
+registerStructuredContractValidator("frontend-implementation-contract-revision-patch-v1", validateFrontendRevisionPatchNodeOutput);

package/dist/workflows/dag/failure-routing.js

@@ -44,7 +44,9 @@ function routeToProductLine(input) {
         case "decision-envelope":
             return "NeedsHuman";
         case "skipped":
-            return "DependencyFailure";
+            return input.skippedReason === "frontend-prewrite-not-authorized"
+                ? "ContractMismatch"
+                : "DependencyFailure";
         case "shell-command":
             if (/\b(ENOENT|PATH|command not found|No such file|not found in PATH|bash: .*: No such file)\b/i.test(raw)) {
                 return "EnvFailure";
@@ -90,9 +92,12 @@ export function routeDagFailure(input) {
     if (!productLineFailureCategory)
         return {};
     const recommendedFollowUp = productLineFailureCategory === "ContractMismatch" &&
-        isFrontendDesignGateNode(input.nodeId ?? "")
-        ? "frontend-plan-revision-and-rerun"
-        : FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory];
+        input.skippedReason === "frontend-prewrite-not-authorized"
+        ? "fix-frontend-task-contract-and-regenerate-dag"
+        : productLineFailureCategory === "ContractMismatch" &&
+            isFrontendDesignGateNode(input.nodeId ?? "")
+            ? "frontend-plan-revision-and-rerun"
+            : FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory];
     return {
         productLineFailureCategory,
         recommendedFollowUp,

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

@@ -191,6 +191,42 @@ const gap = z
     blocking: z.boolean(),
 })
     .strict();
+/**
+ * Structured component/token selection contract (ADR 0016). Every user-visible
+ * UI purpose the plan touches must be declared here so the prewrite gate can
+ * deterministically cross-check that the selection comes from the frontend
+ * specification (openspec/ai_workspace component + theme specs) instead of
+ * relying on design-review's soft model judgment.
+ *
+ * - `specified`: the frontend spec mandates this component for the purpose →
+ *   `specReference` is required (path/section/line hit).
+ * - `reuse-existing`: reuse an existing repo component/convention not named by
+ *   the spec → `specReference` may be null, rationale explains the basis.
+ * - `new`: neither spec nor existing code fits → `specReference` must be null,
+ *   rationale must declare the deviation (design-review approves it).
+ *
+ * `specReference` is nullable + optional because `stripNullValuesDeep` strips
+ * null object values before validation, so a `new` choice's `specReference:
+ * null` becomes an absent field; the superRefine below treats absent and null
+ * identically.
+ */
+const uiComponentSpecReferenceSchema = z
+    .object({
+    path: safePath,
+    section: z.string(),
+    line: z.number().int().nullable().optional(),
+})
+    .strict();
+const uiComponentChoiceSchema = z
+    .object({
+    purpose: z.string().min(1),
+    component: z.string().min(1),
+    decision: z.enum(["specified", "reuse-existing", "new"]),
+    specReference: uiComponentSpecReferenceSchema.nullable().optional(),
+    rationale: z.string().min(1),
+})
+    .strict();
+const uiComponentChoicesSchema = z.array(uiComponentChoiceSchema);
 /**
  * Normalize unstable model emissions before the strict schema sees them:
  * recursively drop null values (object entries and array elements). A null for
@@ -316,6 +352,12 @@ export const frontendImplementationContractSchema = z
     })
         .strict()).min(1),
     evidenceGaps: z.array(gap),
+    implementationSteps: z.array(z.string().min(1)).optional(),
+    stylingStrategy: z.string().min(1).optional(),
+    uiComponentChoices: uiComponentChoicesSchema.optional(),
+    dependencyPolicy: z.string().min(1).optional(),
+    residualRisks: z.array(z.string().min(1)).optional(),
+    realIntegrationGap: z.string().min(1).optional(),
 })
     .strict()
     .superRefine((value, ctx) => {
@@ -391,6 +433,26 @@ export const frontendImplementationContractSchema = z
                 path: ["uiStates"],
             });
     }
+    for (const [index, choice] of (value.uiComponentChoices ?? []).entries()) {
+        if (choice.decision === "specified") {
+            if (!choice.specReference || !choice.specReference.path) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "specified component choice requires a non-empty specReference.path",
+                    path: ["uiComponentChoices", index, "specReference"],
+                });
+            }
+        }
+        else if (choice.decision === "new") {
+            if (choice.specReference) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "new component choice must not carry a specReference",
+                    path: ["uiComponentChoices", index, "specReference"],
+                });
+            }
+        }
+    }
     if (value.mockApi.strategy !== "not-needed") {
         if (value.mockApi.endpoints.length === 0) {
             ctx.addIssue({
@@ -426,6 +488,44 @@ export const frontendImplementationContractSchema = z
         });
     }
 }));
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/**
+ * Apply an RFC 7386 merge-patch on a target contract without mutating it.
+ * `null` removes the key; plain objects merge recursively when the target value
+ * is also a plain object; arrays and scalars replace the whole value. The
+ * result is re-validated by analyzeFrontendImplementationContract before it is
+ * ever materialized, so a patch that removes a required field still fails
+ * closed at the gate.
+ */
+export function applyFrontendImplementationContractPatch(target, patch) {
+    if (!isPlainObject(patch)) {
+        throw new Error("frontend revision patch must be a JSON object");
+    }
+    const merge = (base, delta) => {
+        if (delta === null)
+            return undefined;
+        if (!isPlainObject(delta))
+            return delta;
+        const result = isPlainObject(base)
+            ? { ...base }
+            : {};
+        for (const [key, value] of Object.entries(delta)) {
+            if (value === null) {
+                delete result[key];
+            }
+            else if (isPlainObject(value) && isPlainObject(result[key])) {
+                result[key] = merge(result[key], value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    };
+    return merge(target, patch);
+}
 export async function assertFrontendSourceBindingFresh(input) {
     for (const source of input.binding.sources) {
         const absolute = resolveDagTaskSourcePath({
@@ -648,6 +748,18 @@ function asStringArray(value) {
         .map((item) => asString(item))
         .filter((item) => item.length > 0);
 }
+/**
+ * Pass structured component choices through the free-form compatibility
+ * branch. The strict-shape branch already spreads unknown fields, so only this
+ * explicit constructor needs to re-emit `uiComponentChoices`; a missing/empty
+ * array normalizes to undefined (absent) so the optional schema field stays
+ * compatible with legacy free-form contracts.
+ */
+function normalizeUiComponentChoices(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return undefined;
+    return value;
+}
 function normalizeFrontendRoute(value) {
     const route = asString(value).replaceAll("\\", "/").replace(/^\/+/, "");
     if (!route || route === "." || route.split("/").includes(".."))
@@ -1331,6 +1443,12 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
         },
         verificationTargets,
         evidenceGaps,
+        implementationSteps: asStringArray(record.implementationSteps),
+        stylingStrategy: asString(record.stylingStrategy) || undefined,
+        dependencyPolicy: asString(record.dependencyPolicy) || undefined,
+        residualRisks: asStringArray(record.residualRisks),
+        realIntegrationGap: asString(record.realIntegrationGap) || undefined,
+        uiComponentChoices: normalizeUiComponentChoices(record.uiComponentChoices),
     };
 }
 /**
@@ -1514,6 +1632,46 @@ export async function validateFrontendContractNodeOutput(input) {
         };
     }
 }
+/**
+ * Node-output self-check for the plan revision node, which emits an RFC 7386
+ * merge-patch delta against the original contract instead of a full contract.
+ * Deliberately loose and format-level: the output must contain at least one
+ * ```openspec-citations fenced block and must extract (after the citations
+ * blocks are stripped) to exactly one JSON object. The delta carries no
+ * schemaVersion/targets, so no full-contract schema/semantic checks run here;
+ * content parsing, patch application, and merged-contract validation stay with
+ * the prewrite gate, which remains the only authority.
+ */
+export async function validateFrontendRevisionPatchNodeOutput(input) {
+    // Mirror the prewrite gate's block-presence semantics (a fenced
+    // ```openspec-citations block with a newline-terminated body).
+    if (!/```openspec-citations[ \t]*\r?\n[\s\S]*?\r?\n```/.test(input.text)) {
+        return {
+            ok: false,
+            reason: "revision patch output must include at least one ```openspec-citations fenced block",
+        };
+    }
+    // Strip the citation blocks before extraction: their per-row JSON objects
+    // would otherwise count as competing balanced objects in the extractor.
+    const textWithoutCitations = input.text.replace(/```openspec-citations[ \t]*\r?\n[\s\S]*?\r?\n```/g, "");
+    let patch;
+    try {
+        patch = extractFrontendImplementationJson(textWithoutCitations);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: `revision patch output must contain exactly one valid JSON object: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+        return {
+            ok: false,
+            reason: "revision patch output must extract to exactly one JSON object (RFC 7386 merge-patch delta)",
+        };
+    }
+    return { ok: true, contract: patch };
+}
 export async function materializeFrontendImplementationContract(input) {
     const analysis = await analyzeFrontendImplementationContract(input);
     return writeFrontendImplementationContractArtifact({