@tea-agent/loop-agent 0.42.0-next.4 → 0.42.0-next.6

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

@@ -6,6 +6,94 @@ import { confirmationToken } from "./format.js";
 import { upsertCompactionMessage } from "./compaction-message.js";
 import { describeMutationGateFailure, isMutationGateFailureCode, isStaleTokenFailure, } from "./mutation-gate.js";
 import { SessionTitleWatcher } from "./session-title-watcher.js";
+/** Pure list mutations keep optimistic UI deterministic and easy to verify. */
+export function insertOptimisticSession(list, row) {
+    return [row, ...list.filter((item) => item.sessionId !== row.sessionId)];
+}
+export function replaceOptimisticSession(list, temporaryId, durable) {
+    return [
+        durable,
+        ...list.filter((item) => item.sessionId !== durable.sessionId &&
+            (!temporaryId || item.sessionId !== temporaryId)),
+    ];
+}
+export function removeSessionById(list, sessionId) {
+    const index = list.findIndex((item) => item.sessionId === sessionId);
+    if (index < 0)
+        return { next: list, index: -1 };
+    return {
+        next: list.filter((item) => item.sessionId !== sessionId),
+        removed: list[index],
+        index,
+    };
+}
+export function restoreSessionAt(list, row, index) {
+    if (list.some((item) => item.sessionId === row.sessionId))
+        return list;
+    const next = [...list];
+    next.splice(Math.max(0, Math.min(index, next.length)), 0, row);
+    return next;
+}
+function sameQueueSummary(a, b) {
+    const left = a.deferredTurns ?? (a.deferredTurn ? [a.deferredTurn] : []);
+    const right = b.deferredTurns ?? (b.deferredTurn ? [b.deferredTurn] : []);
+    if (left.length !== right.length)
+        return false;
+    return left.every((item, index) => {
+        const other = right[index];
+        return Boolean(other &&
+            item.clientRequestId === other.clientRequestId &&
+            item.revision === other.revision &&
+            item.state === other.state &&
+            item.updatedAt === other.updatedAt &&
+            item.textPreview === other.textPreview &&
+            item.imageCount === other.imageCount &&
+            item.acceptedTurnId === other.acceptedTurnId &&
+            item.lastError?.code === other.lastError?.code &&
+            item.lastError?.message === other.lastError?.message);
+    });
+}
+function sameSessionSummary(a, b) {
+    return (a.sessionId === b.sessionId &&
+        a.workspaceId === b.workspaceId &&
+        a.state === b.state &&
+        a.title === b.title &&
+        a.displayTitle === b.displayTitle &&
+        a.updatedAt === b.updatedAt &&
+        a.activeTurnId === b.activeTurnId &&
+        a.turnPhase === b.turnPhase &&
+        a.model?.provider === b.model?.provider &&
+        a.model?.modelId === b.model?.modelId &&
+        a.thinkingLevel === b.thinkingLevel &&
+        a.isBlank === b.isBlank &&
+        a.optimisticState === b.optimisticState &&
+        sameQueueSummary(a, b));
+}
+/** Reuse unchanged row and list references across catalog refreshes. */
+export function stabilizeSessionList(previous, next) {
+    const previousById = new Map(previous.map((item) => [item.sessionId, item]));
+    let changed = previous.length !== next.length;
+    const stabilized = next.map((item, index) => {
+        const existing = previousById.get(item.sessionId);
+        const value = existing && sameSessionSummary(existing, item) ? existing : item;
+        if (value !== previous[index])
+            changed = true;
+        return value;
+    });
+    return changed ? stabilized : previous;
+}
+/** Select a server-confirmed blank session owned by the requested workspace. */
+export function findReusableBlankSession(list, workspaceId) {
+    const scope = workspaceId.trim();
+    if (!scope)
+        return undefined;
+    return list.find((item) => item.workspaceId === scope &&
+        item.state === "active" &&
+        item.isBlank === true &&
+        item.turnPhase === "idle" &&
+        !item.activeTurnId &&
+        !item.optimisticState);
+}
 export async function createSessionAndPrimeTitleWatcher(input) {
     if (input.creatingRef?.current) {
         throw new Error("CREATE_SESSION_IN_FLIGHT");
@@ -23,7 +111,10 @@ export async function createSessionAndPrimeTitleWatcher(input) {
                 "x-loop-console-confirmation": confirmationToken(),
             },
             credentials: "include",
-            body: JSON.stringify(input.options ?? {}),
+            body: JSON.stringify((() => {
+                const { optimisticSessionId: _optimisticSessionId, ...body } = input.options ?? {};
+                return body;
+            })()),
         });
         if (!res.ok) {
             const body = (await res.json().catch(() => ({})));
@@ -35,7 +126,7 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         const body = (await res.json());
         if (!body.session)
             throw new Error("创建会话响应缺少 durable session");
-        const durable = body.session;
+        const durable = { ...body.session, isBlank: true };
         const created = {
             sessionId: durable.sessionId,
             ...(durable.workspaceId || input.options?.workspaceId
@@ -45,16 +136,12 @@ export async function createSessionAndPrimeTitleWatcher(input) {
                 : {}),
             ...runtimeSelectionFromRecord(durable),
         };
-        const nextList = [
-            durable,
-            ...input.sessionListRef.current.filter((item) => item.sessionId !== durable.sessionId),
-        ];
+        const nextList = replaceOptimisticSession(input.sessionListRef.current, input.options?.optimisticSessionId, durable);
         // Commit ref → state → eligibility → deferred refresh. The ref assignment
         // makes the durable record observable before React's state commit.
         input.sessionListRef.current = nextList;
         input.setSessionList(nextList);
         input.titleWatcher?.markEligible(durable.sessionId);
-        void input.refreshSessionList();
         return created;
     }
     finally {
@@ -90,6 +177,11 @@ export function useChatSessions(params) {
     }, [refs]);
     const [sessionList, setSessionList] = useState([]);
     const sessionListRef = useRef([]);
+    const pendingDeletedIdsRef = useRef(new Set());
+    const pendingCreatedRowsRef = useRef(new Map());
+    const sessionMutationVersionRef = useRef(0);
+    const deleteRequestVersionsRef = useRef(new Map());
+    const activateSessionRef = useRef(null);
     sessionListRef.current = sessionList;
     const titleWatcherRef = useRef(null);
     // Shared busy gate for sidebar + Landing create entries (one render feedback).
@@ -159,9 +251,13 @@ export function useChatSessions(params) {
                 return;
             }
             const sessions = body.sessions ?? [];
+            const durable = sessions.filter((item) => !pendingDeletedIdsRef.current.has(item.sessionId));
+            const optimistic = [...pendingCreatedRowsRef.current.values()].filter((item) => !durable.some((session) => session.sessionId === item.sessionId));
             // Preserve every workspace's summaries. ChatWorkspaceSidebar applies the
             // visible recent-item limit independently inside each workspace group.
-            setSessionList(sessions);
+            const next = stabilizeSessionList(sessionListRef.current, [...optimistic, ...durable]);
+            sessionListRef.current = next;
+            setSessionList(next);
             if (body.workspaceErrors?.length) {
                 setError(`部分工作区的会话加载失败（${body.workspaceErrors.length} 个）`);
             }
@@ -171,6 +267,60 @@ export function useChatSessions(params) {
         }
     }, [origin, blocked, setError]);
     const deleteSession = useCallback(async (sessionId) => {
+        if (pendingDeletedIdsRef.current.has(sessionId))
+            return false;
+        const requestId = ++sessionMutationVersionRef.current;
+        const currentList = sessionListRef.current;
+        const { next: removedList, removed, index: removedIndex } = removeSessionById(currentList, sessionId);
+        if (!removed || removedIndex < 0)
+            return false;
+        pendingDeletedIdsRef.current.add(sessionId);
+        deleteRequestVersionsRef.current.set(sessionId, requestId);
+        const activeSession = refs.sessionRef.current?.sessionId === sessionId
+            ? refs.sessionRef.current
+            : null;
+        const activeWorkspaceId = activeSession?.workspaceId ?? workspaceId;
+        const deletingRow = {
+            ...removed,
+            optimisticState: "deleting",
+        };
+        const deletingList = restoreSessionAt(removedList, deletingRow, removedIndex);
+        sessionListRef.current = deletingList;
+        setSessionList(deletingList);
+        window.setTimeout(() => {
+            if (!pendingDeletedIdsRef.current.has(sessionId) ||
+                deleteRequestVersionsRef.current.get(sessionId) !== requestId)
+                return;
+            const next = sessionListRef.current.filter((item) => item.sessionId !== sessionId);
+            sessionListRef.current = next;
+            setSessionList(next);
+        }, 150);
+        const restore = () => {
+            if (deleteRequestVersionsRef.current.get(sessionId) !== requestId)
+                return;
+            pendingDeletedIdsRef.current.delete(sessionId);
+            deleteRequestVersionsRef.current.delete(sessionId);
+            const restored = restoreSessionAt(sessionListRef.current, removed, removedIndex);
+            if (restored === sessionListRef.current)
+                return;
+            sessionListRef.current = restored;
+            setSessionList(restored);
+        };
+        let deletionSelectionVersion = null;
+        if (activeSession) {
+            deletionSelectionVersion = ++sessionSelectionVersionRef.current;
+            refs.sessionRef.current = null;
+            resetActiveProjection();
+            setSession(null);
+            forgetActiveChatSession(window.localStorage, activeWorkspaceId, sessionId);
+        }
+        const restoreActiveSession = async () => {
+            if (activeSession &&
+                deletionSelectionVersion === sessionSelectionVersionRef.current &&
+                !refs.sessionRef.current) {
+                await activateSessionRef.current?.(activeSession.sessionId, activeSession.workspaceId);
+            }
+        };
         try {
             // AC-002: delete follows the session's durable owner, not the
             // global active workspace.
@@ -184,22 +334,21 @@ export function useChatSessions(params) {
                 },
             });
             if (!res.ok) {
+                restore();
+                await restoreActiveSession();
                 setError("删除会话失败");
                 return false;
             }
             titleWatcherRef.current?.cancel(sessionId);
-            if (refs.sessionRef.current?.sessionId === sessionId) {
-                const activeWorkspaceId = refs.sessionRef.current.workspaceId ?? workspaceId;
-                sessionSelectionVersionRef.current += 1;
-                refs.sessionRef.current = null;
-                resetActiveProjection();
-                setSession(null);
-                forgetActiveChatSession(window.localStorage, activeWorkspaceId, sessionId);
-            }
-            await refreshSessionList();
+            void refreshSessionList().finally(() => {
+                pendingDeletedIdsRef.current.delete(sessionId);
+                deleteRequestVersionsRef.current.delete(sessionId);
+            });
             return true;
         }
         catch (error) {
+            restore();
+            await restoreActiveSession();
             setError(error instanceof Error ? error.message : String(error));
             return false;
         }
@@ -225,7 +374,7 @@ export function useChatSessions(params) {
             if (!res.ok || !body.session)
                 throw new Error(body.error?.message ?? "会话不可用");
             if (selectionVersion !== sessionSelectionVersionRef.current)
-                return;
+                return false;
             const next = {
                 sessionId: body.session.sessionId,
                 ...(body.session.workspaceId ? { workspaceId: body.session.workspaceId } : {}),
@@ -276,11 +425,13 @@ export function useChatSessions(params) {
             });
             rememberActiveChatSession(window.localStorage, body.session.workspaceId ?? ownerWorkspaceId ?? workspaceId, sessionId);
             setActivePreviewPath(null);
+            return true;
         }
         catch (error) {
             if (selectionVersion !== sessionSelectionVersionRef.current)
-                return;
+                return false;
             setError(error instanceof Error ? error.message : String(error));
+            return false;
         }
     }, [
         origin,
@@ -296,6 +447,7 @@ export function useChatSessions(params) {
         sessionOwnerQuery,
         workspaceId,
     ]);
+    activateSessionRef.current = activateSession;
     useEffect(() => {
         void refreshSessionList();
     }, [refreshSessionList]);
@@ -437,15 +589,38 @@ export function useChatSessions(params) {
             setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
             return Promise.reject(new Error("WORKSPACE_REQUIRED"));
         }
+        const optimisticSessionId = `optimistic-chat-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const now = new Date().toISOString();
+        const optimisticRow = {
+            sessionId: optimisticSessionId,
+            workspaceId: scope,
+            state: "active",
+            updatedAt: now,
+            turnPhase: "idle",
+            optimisticState: "creating",
+        };
+        pendingCreatedRowsRef.current.set(optimisticSessionId, optimisticRow);
+        const optimisticList = insertOptimisticSession(sessionListRef.current, optimisticRow);
+        sessionListRef.current = optimisticList;
+        setSessionList(optimisticList);
         return createSessionAndPrimeTitleWatcher({
             origin,
             sessionListRef,
             setSessionList,
             titleWatcher: titleWatcherRef.current,
             refreshSessionList,
-            options: { ...options, workspaceId: scope },
+            options: { ...options, workspaceId: scope, optimisticSessionId },
             setCreatingSession,
             creatingRef: creatingSessionRef,
+        }).then((created) => {
+            pendingCreatedRowsRef.current.delete(optimisticSessionId);
+            return created;
+        }).catch((error) => {
+            pendingCreatedRowsRef.current.delete(optimisticSessionId);
+            const cleaned = sessionListRef.current.filter((item) => item.sessionId !== optimisticSessionId);
+            sessionListRef.current = cleaned;
+            setSessionList(cleaned);
+            throw error;
         });
     }, [origin, refreshSessionList, workspaceId, setError]);
     const createSession = useCallback(async (options) => {
@@ -456,11 +631,36 @@ export function useChatSessions(params) {
             return null; // AC-R5-002: unknown workspace — no POST
         const selectionVersion = ++sessionSelectionVersionRef.current;
         setError(null);
+        const previousSession = refs.sessionRef.current;
+        const scope = options?.workspaceId?.trim() ?? workspaceId?.trim();
+        if (!scope) {
+            setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
+            return null;
+        }
+        // A caller-provided snapshot is an explicit new-session boundary; reusing
+        // an existing shell would silently drop that context suffix.
+        const reusable = options?.snapshot
+            ? undefined
+            : findReusableBlankSession(sessionListRef.current, scope);
+        if (reusable) {
+            if (previousSession?.sessionId === reusable.sessionId)
+                return previousSession;
+            const activated = await activateSession(reusable.sessionId, reusable.workspaceId);
+            if (!activated)
+                return null;
+            return {
+                sessionId: reusable.sessionId,
+                ...(reusable.workspaceId ? { workspaceId: reusable.workspaceId } : {}),
+                ...runtimeSelectionFromRecord(reusable),
+            };
+        }
         try {
+            resetActiveProjection({ keepStreams: true });
+            refs.sessionRef.current = null;
+            setSession(null);
             const created = await createSessionAndPrimeTitleWatcherForHook(options);
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
-            resetActiveProjection({ keepStreams: true });
             // Set ref synchronously BEFORE setState so a chained
             // createSession().then(sendPrompt) reads the new session even
             // though sendPrompt's closure captured the stale (null) value.
@@ -472,6 +672,9 @@ export function useChatSessions(params) {
         catch (e) {
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
+            if (previousSession) {
+                await activateSession(previousSession.sessionId, previousSession.workspaceId);
+            }
             const message = e instanceof Error ? e.message : String(e);
             if (message !== "CREATE_SESSION_IN_FLIGHT") {
                 setError(message);
@@ -484,6 +687,7 @@ export function useChatSessions(params) {
         setError,
         resetActiveProjection,
         createSessionAndPrimeTitleWatcherForHook,
+        activateSession,
         blocked,
         workspaceId,
     ]);

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

@@ -28,6 +28,7 @@ export function useComposer(params) {
     }, []);
     const [shortcutIndex, setShortcutIndex] = useState(0);
     const [dynamicCommands, setDynamicCommands] = useState([]);
+    const [commandCapabilities, setCommandCapabilities] = useState({ sddBingo: false });
     const [dynamicCommandsLoading, setDynamicCommandsLoading] = useState(false);
     const [dynamicCommandsError, setDynamicCommandsError] = useState(null);
     const [commandsEpoch, setCommandsEpoch] = useState(0);
@@ -74,6 +75,7 @@ export function useComposer(params) {
         commandsSessionRef.current = sessionId;
         commandsGenerationRef.current += 1;
         setDynamicCommands([]);
+        setCommandCapabilities({ sddBingo: false });
         setDynamicCommandsError(null);
         setDynamicCommandsLoading(false);
     }, [sessionId]);
@@ -122,6 +124,7 @@ export function useComposer(params) {
             if (!isCurrent())
                 return;
             setDynamicCommands(items);
+            setCommandCapabilities({ sddBingo: body?.capabilities?.sddBingo === true });
             // Compact server fail-soft / partial-source warning; local Operator/Web still merge.
             const warning = typeof body?.warning === "string" ? body.warning.trim() : "";
             setDynamicCommandsError(warning ? warning.slice(0, 160) : null);
@@ -131,6 +134,7 @@ export function useComposer(params) {
                 return;
             setDynamicCommandsError("动态命令加载失败");
             setDynamicCommands([]);
+            setCommandCapabilities({ sddBingo: false });
         }
         finally {
             if (isCurrent()) {
@@ -227,7 +231,7 @@ export function useComposer(params) {
         }, 400);
         return () => window.clearTimeout(timer);
     }, [origin, sessionId, input]);
-    const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands), [dynamicCommands]);
+    const mergedCommands = useMemo(() => mergeSlashCommands(dynamicCommands, commandCapabilities), [dynamicCommands, commandCapabilities]);
     const filteredShortcuts = useMemo(() => input.startsWith("/")
         ? filterSlashCommands(mergedCommands, input)
         : [], [input, mergedCommands]);

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

@@ -32,6 +32,7 @@ import { ChatSessionStore } from "./chat/session-store.js";
 import { createChatEventStore, createChatOperationLinker, } from "./chat/chat-event-store.js";
 import { createChatTurnExecutionRegistry } from "./chat/turn-execution-registry.js";
 import { ConsolePiRuntime } from "./chat/pi-runtime.js";
+import { AimaxAuthReader, SddDataAlignmentService } from "./chat/sdd-data-alignment.js";
 import { UserQuestionRegistry } from "./chat/user-questions.js";
 import { TodoListRegistry } from "./chat/todos.js";
 import { GoalRegistry } from "./chat/goals.js";
@@ -253,6 +254,7 @@ export async function createWorkspaceContext(record, deps) {
             }
         },
     });
+    const sddDataAlignment = new SddDataAlignmentService(chatStore, new AimaxAuthReader(), deps.fetchImpl);
     const chatEventEpoch = randomBytes(12).toString("hex");
     const chatEvents = createChatEventStore({
         appData,
@@ -291,6 +293,7 @@ export async function createWorkspaceContext(record, deps) {
         questionRegistry,
         todoRegistry,
         goalRegistry,
+        sddDataAlignment,
     });
     let chatRouteDeps;
     const goalRoundDriver = new GoalRoundDriver((sessionId) => driveGoalRound(chatRouteDeps, sessionId));
@@ -302,6 +305,7 @@ export async function createWorkspaceContext(record, deps) {
         questionRegistry,
         todoRegistry,
         goalRegistry,
+        sddDataAlignment,
         goalRoundDriver,
         operationLinker: chatOperationLinker,
         appData,

package/dist/workflows/dag/backend-test-case-coverage-analysis.js

@@ -1463,7 +1463,7 @@ for top in ast.walk(tree):
                     returned_names.add(node.value.id)
             if isinstance(node,ast.Call):
                 for keyword in node.keywords:
-                    if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
+                    if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'} and isinstance(keyword.value,ast.Name) and keyword.value.id in positional:
                         transport.append((keyword.value.id,positional.index(keyword.value.id)-call_offset))
                 if isinstance(node.func,ast.Attribute) and node.func.attr.lower() in {'post','put','patch'} and len(node.args) >= 2:
                     candidate=node.args[1]
@@ -1484,7 +1484,7 @@ for top in ast.walk(tree):
         for node in ast.walk(top):
             if not isinstance(node,ast.Call): continue
             for keyword in node.keywords:
-                if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body'} and isinstance(keyword.value,ast.Name) and keyword.value.id in assigned:
+                if keyword.arg in {'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'} and isinstance(keyword.value,ast.Name) and keyword.value.id in assigned:
                     transport_shapes.append(assigned[keyword.value.id])
         if candidates: FUNCTION_PAYLOADS[top.name]=candidates
         if transport_shapes: FUNCTION_TRANSPORT_SHAPES[top.name]=transport_shapes
@@ -1540,8 +1540,9 @@ def literal(node):
         return repr(node.value)
     return None
 
-def collect_dict(node, prefix, paths, values):
+def collect_dict(node, prefix, paths, values, parameters=None):
     if not isinstance(node, ast.Dict): return
+    parameters = parameters or {}
     for key,value in zip(node.keys,node.values):
         if not isinstance(key, ast.Constant) or not isinstance(key.value,str): continue
         # Ignore writer helper/meta keys that are not DTO request fields.
@@ -1551,12 +1552,16 @@ def collect_dict(node, prefix, paths, values):
         paths.add(current)
         lv=literal(value)
         if lv is not None: values.setdefault(current,set()).add(lv)
-        if isinstance(value, ast.Dict): collect_dict(value,current,paths,values)
+        elif isinstance(value, ast.Name) and value.id in parameters:
+            for bound in parameters[value.id]:
+                bound_lv=literal(bound)
+                if bound_lv is not None: values.setdefault(current,set()).add(bound_lv)
+        if isinstance(value, ast.Dict): collect_dict(value,current,paths,values,parameters)
         elif isinstance(value,(ast.List,ast.Tuple)):
             for item in value.elts:
-                if isinstance(item,ast.Dict): collect_dict(item,current,paths,values)
+                if isinstance(item,ast.Dict): collect_dict(item,current,paths,values,parameters)
 
-PAYLOAD_NAMES={'payload','body','request_body','request_json','dto','json','data','json_body'}
+PAYLOAD_NAMES={'payload','body','request_body','request_json','dto','json','data','json_body','params','query','query_params'}
 
 def shape_only(node):
     if isinstance(node,ast.Dict):
@@ -1637,6 +1642,7 @@ def decorator_payload_nodes(parameters,assigned):
 
 def decorator_payload_nodes_by_tp(fn,assigned):
     result={}
+    function_payload_nodes=payload_nodes(fn)
     for dec in fn.decorator_list:
         if not isinstance(dec,ast.Call) or not isinstance(dec.func,ast.Attribute) or dec.func.attr != 'parametrize' or len(dec.args) < 2: continue
         if not isinstance(dec.args[0],ast.Constant) or not isinstance(dec.args[0].value,str): continue
@@ -1653,9 +1659,11 @@ def decorator_payload_nodes_by_tp(fn,assigned):
             parameters={}
             for index,name in enumerate(names):
                 if index < len(node.args): parameters.setdefault(name,[]).append(node.args[index])
-            payload_nodes=decorator_payload_nodes(parameters,assigned)
+            payload_nodes_for_tp=decorator_payload_nodes(parameters,assigned)
+            if not payload_nodes_for_tp:
+                payload_nodes_for_tp=function_payload_nodes
             paths=set(); values={}
-            for payload_node in payload_nodes: collect_dict(payload_node,'',paths,values)
+            for payload_node in payload_nodes_for_tp: collect_dict(payload_node,'',paths,values,parameters)
             result[tp]={key:sorted(items) for key,items in sorted(values.items())}
     return result
 
@@ -1729,8 +1737,8 @@ for fn in ast.walk(tree):
     if isinstance(fn,(ast.FunctionDef,ast.AsyncFunctionDef)) and fn.name.startswith('test_'):
         paths=set(); values={}
         fallback_paths=set(); fallback_values={}
-        for node in payload_nodes(fn): collect_dict(node,'',paths,values)
-        for node in fallback_payload_nodes(fn): collect_dict(node,'',fallback_paths,fallback_values)
+        for node in payload_nodes(fn): collect_dict(node,'',paths,values,{})
+        for node in fallback_payload_nodes(fn): collect_dict(node,'',fallback_paths,fallback_values,{})
         out[fn.name]={
             'paths':sorted(paths),
             'values':{key:sorted(items) for key,items in sorted(values.items())},
@@ -1782,14 +1790,39 @@ function metadataTestPoints(region, label) {
     const match = new RegExp(`^\\s*${escaped}\\s*:\\s*(.*)$`, "mi").exec(region);
     return orderedUnique(match?.[1]?.match(/\bTP-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/g) ?? []);
 }
+function isPytestDecoratorOrContinuationLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    if (trimmed.startsWith("#"))
+        return true;
+    if (trimmed.startsWith("@"))
+        return true;
+    // Multi-line decorator argument lists: @pytest.mark.parametrize(\n    "x", [\n      pytest.param(..., id="TP-...")\n    ]\n)
+    return /^[\]\),]/.test(trimmed) || /[\(\[{,]$/.test(trimmed) || /\bpytest\.param\s*\(/.test(trimmed);
+}
 function pytestFunctionRegionStart(source, functionIndex) {
     let regionStart = source.lastIndexOf("\n", functionIndex - 1) + 1;
     let cursor = regionStart;
+    let blankRun = 0;
     while (cursor > 0) {
         const previousEnd = cursor - 1;
         const previousStart = source.lastIndexOf("\n", previousEnd - 1) + 1;
         const previous = source.slice(previousStart, previousEnd).replace(/\r$/, "");
-        if (!previous.trim())
+        const trimmed = previous.trim();
+        if (!trimmed) {
+            blankRun += 1;
+            // Keep walking across a small blank gap so a decorator is still bound to
+            // the following test when writers insert one empty line before `def`.
+            if (blankRun > 2)
+                break;
+            cursor = previousStart;
+            continue;
+        }
+        blankRun = 0;
+        if (/^(?:async\s+)?def\s+/.test(trimmed) || /^(?:async\s+)?class\s+/.test(trimmed))
+            break;
+        if (!isPytestDecoratorOrContinuationLine(previous))
             break;
         regionStart = previousStart;
         cursor = previousStart;
@@ -1819,12 +1852,14 @@ function pytestFunctionBodyEnd(source, signatureEnd, functionIndent) {
 }
 function pytestParameterCollections(source) {
     const collections = new Map();
-    for (const match of source.matchAll(/^(_?[A-Z][A-Z0-9_]*)\s*=\s*\[(?![^\r\n]*\])([\s\S]*?)^\]/gm)) {
+    for (const match of source.matchAll(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\[(?![^\r\n]*\])([\s\S]*?)^\]/gm)) {
         const explicitIds = [...match[2].matchAll(/\bid\s*=\s*["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1]);
         const factoryIds = explicitIds.length === 0
             ? [...match[2].matchAll(/["'](TP-[A-Z0-9-]+)["']/g)].map((item) => item[1])
             : [];
-        collections.set(match[1], orderedUnique([...explicitIds, ...factoryIds]));
+        const ids = orderedUnique([...explicitIds, ...factoryIds]);
+        if (ids.length > 0)
+            collections.set(match[1], ids);
     }
     return collections;
 }
@@ -1886,6 +1921,12 @@ function normalizePythonLiteralValue(value) {
     if ((trimmed.startsWith("'") && trimmed.endsWith("'")) || (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
         return trimmed.slice(1, -1);
     }
+    if (trimmed === "True")
+        return "true";
+    if (trimmed === "False")
+        return "false";
+    if (trimmed === "None")
+        return "null";
     return trimmed;
 }
 function intentionalInvalidEnumVariant(input) {
@@ -1930,13 +1971,15 @@ function assessPayloadContract(testCase, refs) {
             : [];
     const enumMismatches = [];
     for (const [field, allowed] of Object.entries(testCase.payloadContract.enumValues)) {
-        const observed = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []));
+        const aggregated = orderedUnique(refs.flatMap((item) => (useFallback ? item.fallbackPayloadValues[field] : item.payloadValues[field]) ?? []));
+        const byTestPoint = orderedUnique(refs.flatMap((item) => Object.values(item.payloadValuesByTestPoint).flatMap((values) => values[field] ?? [])));
+        const observed = orderedUnique([...aggregated, ...byTestPoint]);
         for (const rawValue of observed) {
             const value = normalizePythonLiteralValue(rawValue);
             if (allowed.includes(value))
                 continue;
             const associatedTestPoints = orderedUnique(refs.flatMap((item) => Object.entries(item.payloadValuesByTestPoint)
-                .filter(([, values]) => (values[field] ?? []).includes(rawValue))
+                .filter(([, values]) => (values[field] ?? []).some((itemValue) => itemValue === rawValue || normalizePythonLiteralValue(itemValue) === value))
                 .map(([testPoint]) => testPoint)));
             const intentionallyInvalid = associatedTestPoints.length > 0 && associatedTestPoints.every((testPoint) => intentionalInvalidEnumVariant({ testCase, testPoint, field, observedValue: rawValue, allowed }));
             if (!intentionallyInvalid)