@tea-agent/loop-agent 0.42.0-next.3 → 0.42.0-next.5

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-writer-completeness.js

@@ -904,6 +904,16 @@ export async function writeBackendTestWriterProgressArtifacts(input) {
     await writeFile(reportPath, body, "utf8");
     return { factsPath, reportPath };
 }
+export function isBackendTestPytestCollectionRepairOutcomeRecoveryCandidate(task) {
+    return (task.id === "repair-backend-pytest-collection-pi" &&
+        task.executor === "pi" &&
+        task.role === "implementer" &&
+        task.toolProfile === "write" &&
+        task.writePolicy === "exclusive" &&
+        (task.writeSet?.length ?? 0) > 0 &&
+        task.writerOutcomePolicy?.type === "implementation-outcome-v1" &&
+        task.writerOutcomePolicy.requireChangedFiles === true);
+}
 export function isBackendTestCompletenessRetryCandidate(task) {
     if (task.executor !== "pi" || task.role !== "implementer")
         return false;

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

@@ -4256,21 +4256,26 @@ const headerIndex=lines.findIndex(line=>{const row=cells(line);return expectedHe
 if(headerIndex<0){process.stderr.write('invalid-module-index-header: require exact business ownership and path columns\\n');process.exit(2);}
 const dataRows=lines.slice(headerIndex+2).map(cells).filter(row=>row.length>=8&&row[0]&&row[0]!=='Module Stem');
 const allowedSplit=new Set(['explicit-user-layout','primary-business-resource','independent-business-resource','output-budget']);
-const strictExpectedStems=new Set((strictLayout&&strictLayout.modules||[]).map(item=>item.stem));
-const operationOwners=new Map();const declaredModules=[];let planRepairApplied=false;
+const operationOwners=new Map();const canonicalSeen=new Set();const declaredModules=[];let planRepairApplied=false;
 for(const row of dataRows){
-  const stem=norm(row[0]),resource=String(row[1]||'').trim(),operations=String(row[2]||'').split(';').map(value=>value.trim()).filter(Boolean),split=String(row[5]||'').trim();
-  if(strictLayout&&!strictExpectedStems.has(stem)){planRepairApplied=true;continue;}
+  const rawStem=String(row[0]||'').trim(),resource=String(row[1]||'').trim(),operations=String(row[2]||'').split(';').map(value=>value.trim()).filter(Boolean),split=String(row[5]||'').trim();
+  const mdMatches=[...String(row[6]||'').matchAll(rxMdPath)];
+  if(mdMatches.length!==1){process.stderr.write('module-markdown-path-mismatch: '+(rawStem||'unknown')+'; require exactly one canonical Markdown Path\\n');process.exit(2);}
+  let stem=norm(mdMatches[0][1]),markdownPath=mdMatches[0][0];
+  if(strictLayout&&!strictLayout.modules.some(item=>item.markdownPath===markdownPath)){planRepairApplied=true;continue;}
   if(!resource){process.stderr.write('missing-business-resource: '+stem+'\\n');process.exit(2);}
   if(/^(?:response|resp|regression|positive|negative|boundary|error|combo|filter)(?:[_ -]|$)/i.test(resource)){process.stderr.write('test-purpose-business-resource: '+stem+' -> '+resource+'\\n');process.exit(2);}
   if(!allowedSplit.has(split)){process.stderr.write('invalid-module-split-reason: '+stem+' -> '+split+'\\n');process.exit(2);}
   if(operations.length===0){process.stderr.write('missing-owned-operation: '+stem+'\\n');process.exit(2);}
-  const mdMatches=[...String(row[6]||'').matchAll(rxMdPath)];let markdownPath=mdMatches[0]&&mdMatches[0][0];
   let pytestPath=String(row[7]||'').replace(/^\\.\\//,'').replace(/\\\\/g,'/');
-  if(mdMatches.length!==1||norm(mdMatches[0][1])!==stem){process.stderr.write('module-markdown-path-mismatch: '+stem+'\\n');process.exit(2);}
   if(!/^[A-Za-z0-9_./-]+\\.py$/.test(pytestPath)||pytestPath.includes('..')){process.stderr.write('invalid-module-pytest-path: '+stem+' -> '+pytestPath+'\\n');process.exit(2);}
-  const required=strictLayout&&strictLayout.modules.find(item=>item.stem===stem);
+  const requiredCandidates=strictLayout?strictLayout.modules.filter(item=>item.markdownPath===markdownPath):[];
+  if(strictLayout&&requiredCandidates.length!==1){process.stderr.write('MODULE_LAYOUT_CONFLICT: no unique required module for Markdown Path '+markdownPath+'\\n');process.exit(2);}
+  const required=requiredCandidates[0];
+  if(!required&&norm(rawStem)!==stem)planRepairApplied=true;
   if(required){
+    stem=required.stem;
+    if(norm(rawStem)!==stem)planRepairApplied=true;
     if(!required.markdownPath.startsWith(mdDir+'/')||!required.pytestPath.startsWith(scriptDir+'/')||required.markdownPath.includes('..')||required.pytestPath.includes('..')){process.stderr.write('MODULE_LAYOUT_CONFLICT: strict paths outside frozen roots for '+stem+'\\n');process.exit(2);}
     if(markdownPath!==required.markdownPath||pytestPath!==required.pytestPath||resource!==required.businessResource||JSON.stringify(operations)!==JSON.stringify(required.ownedOperations)||split!==required.splitReason){planRepairApplied=true;}
     markdownPath=required.markdownPath;pytestPath=required.pytestPath;
@@ -4280,17 +4285,19 @@ for(const row of dataRows){
     }
   }
   const item={stem,markdownPath,pytestPath,businessResource:required?required.businessResource:resource,ownedOperations:required?required.ownedOperations:operations,ownedRuleKeys:String(row[3]||'').split(';').map(value=>value.trim()).filter(Boolean),caseIds:String(row[4]||'').split(';').map(value=>value.trim()).filter(Boolean),splitReason:required?required.splitReason:split,...(required&&required.budgetProof?{budgetProof:required.budgetProof}:{})};
+  if(canonicalSeen.has(item.stem)){process.stderr.write('duplicate-canonical-module-stem: '+item.stem+'; module identity must be unique\\n');process.exit(2);}
+  canonicalSeen.add(item.stem);
   declaredModules.push(item);
   for(const operation of item.ownedOperations){const owners=operationOwners.get(operation)||[];owners.push({stem,split:item.splitReason});operationOwners.set(operation,owners);}
 }
 if(strictLayout){
   const missing=strictLayout.modules.filter(item=>!declaredModules.some(actual=>actual.stem===item.stem));
   if(missing.length){process.stderr.write('MODULE_LAYOUT_CONFLICT: plan missing required modules '+missing.map(item=>item.stem).join(',')+'; deterministic Plan-only repair cannot invent Rule/Case ownership\\n');process.exit(2);}
-  if(planRepairApplied){
-    const table=['| '+expectedHeader.join(' | ')+' |','|'+expectedHeader.map(()=>'---').join('|')+'|',...declaredModules.map(item=>'| '+[item.stem,item.businessResource,item.ownedOperations.join('; '),item.ownedRuleKeys.join('; '),item.caseIds.join('; '),item.splitReason,'['+item.stem+'](./'+item.stem+'.md) '+item.markdownPath,item.pytestPath].join(' | ')+' |')].join('\\n');
-    readme=[...allLines.slice(0,headings[0]+1),table,...allLines.slice(end)].join('\\n');
-    fs.writeFileSync(planPath,readme,'utf8');
-  }
+}
+if(planRepairApplied){
+  const table=['| '+expectedHeader.join(' | ')+' |','|'+expectedHeader.map(()=>'---').join('|')+'|',...declaredModules.map(item=>'| '+[item.stem,item.businessResource,item.ownedOperations.join('; '),item.ownedRuleKeys.join('; '),item.caseIds.join('; '),item.splitReason,'['+item.stem+'](./'+item.stem+'.md) '+item.markdownPath,item.pytestPath].join(' | ')+' |')].join('\\n');
+  readme=[...allLines.slice(0,headings[0]+1),table,...allLines.slice(end)].join('\\n');
+  fs.writeFileSync(planPath,readme,'utf8');
 }
 for(const [operation,owners] of operationOwners){if(owners.length>1&&!owners.every(owner=>owner.split==='explicit-user-layout'||owner.split==='output-budget')){process.stderr.write('overlapping-operation-modules: '+operation+' -> '+owners.map(owner=>owner.stem).join(',')+'; merge by business resource or use an authoritative explicit-user-layout\\n');process.exit(2);}}
 if(!strictLayout){
@@ -4302,8 +4309,8 @@ if(!strictLayout){
 }
 const invalid=[];for(const r of raw){const reason=invalidReason(r);if(reason)invalid.push({stem:norm(r),reason});}
 if(invalid.length){for(const item of invalid)process.stderr.write(item.reason+': '+item.stem+'; use a stable business resource/domain stem\\n');process.exit(2);}
-const seen=new Set();const modules=[];
-for(const item of declaredModules){if(valid(item.stem)&&!seen.has(item.stem)){seen.add(item.stem);modules.push(item);}}
+const modules=[];
+for(const item of declaredModules){if(valid(item.stem))modules.push(item);}
 if(modules.length===0){process.stderr.write('empty-module-index: require at least one stable business module\\n');process.exit(2);}
 if(modules.length>8){process.stderr.write('excessive-module-count: '+modules.length+' > 8; merge by the smallest stable business resource/domain set\\n');process.exit(2);}
 const planReadPath=path.relative(process.cwd(),planPath).split(path.sep).join('/');
@@ -4899,7 +4906,7 @@ async function buildBackendTestHybridDag(sources) {
             "Each Rule Key must appear in exactly one Matrix row. Preserve each AC/REQ/BR Rule Key as one row; if one product rule spans multiple dimensions, use a concise composite Dimension in that single row instead of duplicating the key. Derive OpenAPI Rule Keys exactly as the deterministic analyzer does: operation token is `<HTTP-METHOD>-<PATH>` with braces removed and every non-alphanumeric run replaced by a hyphen, uppercase (for example POST `/api/resource-notes` → `POST-API-RESOURCE-NOTES`); response statuses use `API-<OPERATION>-RESPONSE-STATUS`; body/parameter fields use `API-<OPERATION>-<FIELD>-REQUIRED|ENUM|MIN-LENGTH|MAX-LENGTH|MINIMUM|MAXIMUM|PATTERN|FORMAT`. Do not invent aliases such as API-CREATE-FIELDS when a deterministic key applies.",
             "Coverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.",
             "For uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.",
-            "Mandatory module layout contract: first inspect the PRIMARY requirement for an explicit list of required Markdown/Python output path pairs. When explicit paths are present, they are authoritative `explicit-user-layout`: reproduce their exact filenames, count and one-to-one pairs in Module Index; do not rename, merge, split, omit or add a module from reference/example scripts. Only when the primary requirement has no explicit file layout may you derive the smallest `business-resource-layout`. Existing examples, historical regression functions and shared setup may add evidence/assertions to an existing required module, but never create an extra physical module by themselves. A reference-only `resp_regression`, positive/negative/boundary/error/response module is forbidden.",
+            "Mandatory module layout contract: first inspect the PRIMARY requirement for an explicit list of required Markdown/Python output path pairs. When explicit paths are present, they are authoritative `explicit-user-layout`: reproduce their exact filenames, count and one-to-one pairs in Module Index; do not rename, merge, split, omit or add a module from reference/example scripts. Only when the primary requirement has no explicit file layout may you derive the smallest `business-resource-layout`. Existing examples, historical regression functions and shared setup may add evidence/assertions to an existing required module, but never create an extra physical module by themselves. A reference-only `resp_regression`, positive/negative/boundary/error/response module is forbidden. The Module Stem cell must contain only the plain filename stem; never put Markdown link syntax or a path in that cell.",
             ...(taskConfig.backendTest?.moduleLayout
                 ? [
                     "A strict task-contract `backendTest.moduleLayout` is bound and is authoritative over model-derived layout. Reproduce every stem, businessResource, ownedOperations, splitReason, markdownPath and pytestPath exactly; do not add, omit, rename or reorder physical modules. The downstream preflight compares exact path sets and may perform at most one deterministic Plan-only pruning/path normalization; it cannot invent missing Rule/Case ownership.",