npm - @tea-agent/loop-agent - Versions diffs - 0.33.4 → 0.33.5 - Mend

@tea-agent/loop-agent 0.33.4 → 0.33.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

package/CHANGELOG.md +28 -0
package/dist/executors/dag-pi-executor.js +34 -12
package/dist/executors/shell-executor.js +26 -66
package/dist/task/config-types.js +2 -2
package/dist/worker/console/chat/chat-event-store.js +57 -18
package/dist/worker/console/chat/routes.js +850 -170
package/dist/worker/console/static/assets/{index-PzYzcuFG.js → index-CteJFFL2.js} +17 -17
package/dist/worker/console/static/index.html +1 -1
package/dist/worker/console/static-src/operator-chat/chat-sse-events.js +33 -8
package/dist/worker/console/static-src/operator-chat/refs.js +3 -0
package/dist/worker/console/static-src/operator-chat/useChatSessions.js +3 -0
package/dist/worker/console/static-src/operator-chat/useChatStream.js +80 -2
package/dist/workflows/dag/backend-test-markdown-workflow.js +17 -0
package/dist/workflows/dag/backend-test-module-stem.js +21 -0
package/dist/workflows/dag/backend-test-pytest-collection.js +44 -0
package/dist/workflows/dag/backend-test-writer-completeness.js +130 -45
package/dist/workflows/dag/init-hybrid.js +29 -160
package/docs/templates/backend-test-dag.json +3 -3
package/docs/templates/frontend-test-dag.generate-cases.prompt.md +2 -2
package/docs/templates/frontend-test-dag.json +9 -9
package/docs/templates/frontend-test-dag.retrieve-context.prompt.md +7 -7
package/harness.json +1 -1
package/package.json +1 -1
package/skills/playwright-cli/SKILL.md +2 -3

package/dist/worker/console/static/index.html CHANGED Viewed

@@ -6,7 +6,7 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="stylesheet" href="/inspect/operator-chrome.css" />
     <title>Loop 操作台 · Operator Console</title>
-    <script type="module" crossorigin src="/assets/index-PzYzcuFG.js"></script>
+    <script type="module" crossorigin src="/assets/index-CteJFFL2.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CnUXAqxG.css">
   </head>
   <body>

package/dist/worker/console/static-src/operator-chat/chat-sse-events.js CHANGED Viewed

@@ -37,9 +37,7 @@ export function createChatSseEventApplier(deps) {
                 interviewSessionId: typeof payload.interviewSessionId === "string"
                     ? payload.interviewSessionId
                     : current?.interviewSessionId,
-                taskId: typeof payload.taskId === "string"
-                    ? payload.taskId
-                    : current?.taskId,
+                taskId: typeof payload.taskId === "string" ? payload.taskId : current?.taskId,
                 state: typeof payload.state === "string" ? payload.state : current?.state,
                 question: payload.question && typeof payload.question === "object"
                     ? payload.question
@@ -50,9 +48,7 @@ export function createChatSseEventApplier(deps) {
         if (eventName === "draft") {
             setInterview((current) => ({
                 ...(current ?? {}),
-                taskId: typeof payload.taskId === "string"
-                    ? payload.taskId
-                    : current?.taskId,
+                taskId: typeof payload.taskId === "string" ? payload.taskId : current?.taskId,
                 draft: payload.draft && typeof payload.draft === "object"
                     ? payload.draft
                     : current?.draft,
@@ -95,15 +91,44 @@ export function createChatSseEventApplier(deps) {
             return;
         }
         if (eventName === "agent_start") {
+            // P2: a replayed agent_start must not resurrect an already-finished
+            // turn (aborted turns have no agent_settled in the ring, so replay
+            // would otherwise leave the UI streaming forever). Only the server's
+            // active turn may flip streaming on during replay; every other
+            // agent_start (including all of them when the server reports no
+            // active turn) is stale and ignored.
+            if (replay &&
+                turnId !== undefined &&
+                turnId !== refs.activeTurnIdRef.current) {
+                return;
+            }
+            if (turnId)
+                refs.activeTurnIdRef.current = turnId;
             setStreaming(true);
             setStreamingAssistantId(resolvedAssistantId);
             return;
         }
-        if (eventName === "agent_settled") {
+        if (eventName === "agent_settled" || eventName === "agent_end") {
+            // Both are terminal: agent_end = SDK run finished, agent_settled =
+            // post-turn continuation idle. Clear streaming and drop an empty
+            // placeholder bubble so a settled turn never shows a stuck "…" row.
             setStreaming(false);
             setStreamingAssistantId(null);
-            if (!replay && document.hidden)
+            if (eventName === "agent_settled" &&
+                !replay &&
+                typeof document !== "undefined" &&
+                document.hidden) {
                 setUnread((current) => current + 1);
+            }
+            setMessages((m) => m.filter((msg) => !(msg.id === resolvedAssistantId &&
+                msg.role === "assistant" &&
+                !msg.text.trim())));
+            // Close out tool calls that never got a tool_result (abort/fail):
+            // without this the process rail keeps showing "运行中" forever even
+            // though the turn is over.
+            setToolCalls((prev) => prev.map((t) => t.status === "running" && t.assistantMessageId === resolvedAssistantId
+                ? { ...t, status: "error", finishedAt: Date.now() }
+                : t));
             return;
         }
         if (eventName === "operation-ref" || eventName === "operation-status") {

package/dist/worker/console/static-src/operator-chat/refs.js CHANGED Viewed

@@ -10,6 +10,7 @@ export function useChatRefs() {
     const seenEventIdsRef = useRef(new Set());
     const turnAssistantIdsRef = useRef(new Map());
     const reconnectAbortRef = useRef(null);
+    const activeTurnIdRef = useRef(null);
     const usageResponseKeysRef = useRef(new Set());
     const isComposingRef = useRef(false);
     const compositionEndedAtRef = useRef(0);
@@ -26,6 +27,7 @@ export function useChatRefs() {
         seenEventIdsRef,
         turnAssistantIdsRef,
         reconnectAbortRef,
+        activeTurnIdRef,
         usageResponseKeysRef,
         isComposingRef,
         compositionEndedAtRef,
@@ -40,6 +42,7 @@ export function useChatRefs() {
         seenEventIdsRef,
         turnAssistantIdsRef,
         reconnectAbortRef,
+        activeTurnIdRef,
         usageResponseKeysRef,
         isComposingRef,
         compositionEndedAtRef,

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

@@ -23,6 +23,7 @@ export function useChatSessions(params) {
         refs.lastEventIdRef.current = null;
         refs.seenEventIdsRef.current = new Set();
         refs.turnAssistantIdsRef.current = new Map();
+        refs.activeTurnIdRef.current = null;
         resetForNewSession();
         setInput("");
         setPendingImages([]);
@@ -125,6 +126,7 @@ export function useChatSessions(params) {
             };
             refs.sessionRef.current = next;
             refs.streamingRef.current = Boolean(body.session.activeTurnId);
+            refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
             refs.seenEventIdsRef.current = new Set();
             refs.turnAssistantIdsRef.current = new Map();
             refs.lastEventIdRef.current = null;
@@ -192,6 +194,7 @@ export function useChatSessions(params) {
                 // from the durable store, but tool/gate/operation projections live
                 // in the event ring and must replay once. applySseBlock dedups by
                 // eventId and marks replay so usage/unread/sound do not double-count.
+                refs.activeTurnIdRef.current = body.session.activeTurnId ?? null;
                 refs.seenEventIdsRef.current = new Set();
                 refs.turnAssistantIdsRef.current = new Map();
                 refs.lastEventIdRef.current = null;

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

@@ -123,7 +123,84 @@ export function useChatStream(params) {
         refs.streamingRef.current = false;
         setStreaming(false);
         setStreamingAssistantId(null);
-    }, [refs, setStreaming, setStreamingAssistantId]);
+        // User-initiated stop: immediately drop the still-empty placeholder
+        // bubble (no text yet) instead of leaving a forever "…" row (pi-web
+        // hides empty assistant rows on abort).
+        setMessages((m) => m.filter((msg) => !(msg.id === refs.assistantIdRef.current &&
+            msg.role === "assistant" &&
+            !msg.text.trim())));
+    }, [refs, setStreaming, setStreamingAssistantId, setMessages]);
+    // Reconcile client streaming state with the server (pi-web get_state loop).
+    // When SSE events are missed (network drop, backgrounded tab, half-open
+    // connection) agent_end/agent_settled never arrive and the UI stays
+    // streaming forever. If the server reports no active turn while we still
+    // think a turn is streaming, force the same finish a terminal event would
+    // have produced. Also refreshes activeTurnIdRef so replayed agent_start
+    // frames are judged against current server truth.
+    useEffect(() => {
+        if (!session || !streaming)
+            return;
+        const sid = session.sessionId;
+        let cancelled = false;
+        const sync = async () => {
+            if (cancelled)
+                return;
+            try {
+                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sid)}/state`, { credentials: "include" });
+                if (!res.ok)
+                    return;
+                const body = (await res.json());
+                const activeTurnId = body.state?.activeTurnId ?? null;
+                refs.activeTurnIdRef.current = activeTurnId;
+                if (activeTurnId !== null || !refs.streamingRef.current)
+                    return;
+                // Server idle while the client still thinks a turn is streaming.
+                // Skip when an inline prompt request is still in flight — the
+                // server may not have created its turn lease yet (POST prompt
+                // creates the turn server-side after the request lands), and
+                // force-finishing then would kill a just-sent prompt.
+                if (refs.inlineStreamSessionIdsRef.current.has(sid))
+                    return;
+                const pendingAssistantId = refs.assistantIdRef.current;
+                refs.streamingRef.current = false;
+                setStreaming(false);
+                setStreamingAssistantId(null);
+                refs.abortRef.current?.abort();
+                refs.abortRef.current = null;
+                refs.assistantIdRef.current = null;
+                setMessages((m) => m.filter((msg) => !(msg.id === pendingAssistantId &&
+                    msg.role === "assistant" &&
+                    !msg.text.trim())));
+            }
+            catch {
+                // Network still down — the next poll / visibility / online tick retries.
+            }
+        };
+        const onVisible = () => {
+            if (document.visibilityState === "visible")
+                void sync();
+        };
+        const onOnline = () => {
+            void sync();
+        };
+        const interval = setInterval(() => void sync(), 15_000);
+        document.addEventListener("visibilitychange", onVisible);
+        window.addEventListener("online", onOnline);
+        return () => {
+            cancelled = true;
+            clearInterval(interval);
+            document.removeEventListener("visibilitychange", onVisible);
+            window.removeEventListener("online", onOnline);
+        };
+    }, [
+        origin,
+        refs,
+        session,
+        streaming,
+        setStreaming,
+        setStreamingAssistantId,
+        setMessages,
+    ]);
     /** Open the reconnectable GET /events stream for a session and apply events
      *  until it closes, then reopen with the latest Last-Event-ID (M1-T04/T05).
      *
@@ -194,7 +271,8 @@ export function useChatStream(params) {
     // leak a dangling connection. It resumes after settle/stop to catch the tail.
     useEffect(() => {
         if (!session ||
-            (streaming && refs.inlineStreamSessionIdsRef.current.has(session.sessionId)))
+            (streaming &&
+                refs.inlineStreamSessionIdsRef.current.has(session.sessionId)))
             return;
         const ac = new AbortController();
         refs.reconnectAbortRef.current = ac;

package/dist/workflows/dag/backend-test-markdown-workflow.js CHANGED Viewed

@@ -5,6 +5,7 @@ import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { createWriteStream } from "node:fs";
 import path from "node:path";
 import { promisify } from "node:util";
+import { isPriorityOnlyBackendTestModuleStem } from "./backend-test-module-stem.js";
 import { parseJacocoXml, } from "./backend-test-coverage-contract.js";
 import { backendTestCaseManifestSchema, computeCaseManifestCoverageSummary, } from "./backend-test-case-manifest.js";
 const execFileAsync = promisify(execFile);
@@ -398,9 +399,13 @@ function markdownSecretFindings(relativeFile, markdown) {
 export function hasBlockingBackendMarkdownSafetyFindings(report) {
     return /^## Safety Status\s*\r?\n\s*BLOCKED\s*$/m.test(report);
 }
+export function hasBlockingBackendMarkdownModuleStemFindings(report) {
+    return /^## Module Stem Status\s*\r?\n\s*BLOCKED\s*$/m.test(report);
+}
 export async function validateBackendMarkdownCases(input) {
     const findings = [];
     const safetyFindings = [];
+    const moduleStemFindings = [];
     let files = [];
     try {
         files = await markdownFiles(input.workspaceRoot);
@@ -419,6 +424,9 @@ export async function validateBackendMarkdownCases(input) {
     let caseCount = 0;
     for (const file of moduleFiles) {
         const relativeFile = path.relative(input.workspaceRoot, file).replaceAll(path.sep, "/");
+        if (isPriorityOnlyBackendTestModuleStem(path.basename(file, path.extname(file)))) {
+            moduleStemFindings.push(`priority-only-module-stem: ${relativeFile}; regenerate the README Module Index with a stable business resource/domain stem`);
+        }
         const markdown = await readFile(file, "utf8");
         safetyFindings.push(...markdownSecretFindings(relativeFile, markdown));
         if (!markdown.trim()) {
@@ -479,6 +487,7 @@ export async function validateBackendMarkdownCases(input) {
     if (missing.length > 0) {
         findings.push(`required AC IDs are not covered by final Markdown cases: ${missing.join(", ")}`);
     }
+    findings.push(...moduleStemFindings);
     const status = findings.length === 0 ? "PASS" : "FAIL";
     const report = [
         "# Backend Markdown Case Validation",
@@ -497,6 +506,14 @@ export async function validateBackendMarkdownCases(input) {
         "- Source-reference validity check: not applied",
         "- Markdown quality sensitive-information finding: not advisory; see Safety Status",
         "",
+        "## Module Stem Status",
+        "",
+        moduleStemFindings.length > 0 ? "BLOCKED" : "PASS",
+        "",
+        ...(moduleStemFindings.length > 0
+            ? moduleStemFindings.map((finding) => `- ${finding}`)
+            : ["- All Markdown modules use non-priority business stems."]),
+        "",
         "## Safety Status",
         "",
         safetyFindings.length > 0 ? "BLOCKED" : "PASS",

package/dist/workflows/dag/backend-test-module-stem.js ADDED Viewed

@@ -0,0 +1,21 @@
+import path from "node:path";
+const PRIORITY_ONLY_MODULE_STEMS = new Set(["p0", "p1", "p2"]);
+export function normalizeBackendTestModuleStemCandidate(raw) {
+    return path.basename(raw)
+        .replace(/\.(?:md|py)$/i, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .replace(/_+/g, "_");
+}
+export function isPriorityOnlyBackendTestModuleStem(raw) {
+    return PRIORITY_ONLY_MODULE_STEMS.has(normalizeBackendTestModuleStemCandidate(raw));
+}
+export function isPriorityOnlyBackendPytestScript(script) {
+    const basename = path.posix.basename(script.replaceAll("\\", "/"));
+    const match = /^test_(.+)\.py$/i.exec(basename);
+    return match ? isPriorityOnlyBackendTestModuleStem(match[1]) : false;
+}
+export function priorityOnlyBackendPytestScripts(paths) {
+    return [...new Set(paths.map((item) => item.replaceAll("\\", "/")).filter(isPriorityOnlyBackendPytestScript))].sort();
+}

package/dist/workflows/dag/backend-test-pytest-collection.js CHANGED Viewed

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { readdir, readFile, writeFile, mkdir } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
+import { priorityOnlyBackendPytestScripts } from "./backend-test-module-stem.js";
 const SHA256 = /^[a-f0-9]{64}$/;
 const MAX_DIAGNOSTIC_CHARS = 12_000;
 export const backendPytestCollectionFindingSchema = z.object({
@@ -273,6 +274,41 @@ export function assessBackendPytestCollection(input) {
         fixtureStderrExcerpt: "",
     });
 }
+export function assessPriorityOnlyBackendPytestModules(input) {
+    const invalidScripts = priorityOnlyBackendPytestScripts(input.inventory.assetFiles);
+    if (invalidScripts.length === 0)
+        return undefined;
+    return backendPytestCollectionFactsSchema.parse({
+        schemaId: "backend-test-pytest-collection-v3",
+        phase: input.phase,
+        status: "BLOCKED",
+        repairEligible: false,
+        repairAttempt: input.phase === "final" ? 1 : 0,
+        collectionAttempted: false,
+        fixtureResolutionAttempted: false,
+        fixtureResolutionStatus: "NOT_RUN",
+        fixtureResolutionExitCode: null,
+        repairPaths: [],
+        mappedScripts: [...input.mappedScripts],
+        existingMappedScripts: input.inventory.mappedScripts,
+        missingMappedScripts: [],
+        assetFiles: input.inventory.assetFiles,
+        inputHashes: input.inventory.inputHashes,
+        pytestExitCode: null,
+        collectedItemCount: 0,
+        collectedItemIds: [],
+        findings: invalidScripts.map((script) => ({
+            kind: "priority-only-pytest-module",
+            classification: "test-asset-defect",
+            repairability: "blocked",
+            detail: `priority-only pytest module is forbidden and cannot be auto-renamed: ${script}`,
+        })),
+        stdoutExcerpt: "",
+        stderrExcerpt: "",
+        fixtureStdoutExcerpt: "",
+        fixtureStderrExcerpt: "",
+    });
+}
 export function assessMissingBackendPytestScripts(input) {
     return backendPytestCollectionFactsSchema.parse({
         schemaId: "backend-test-pytest-collection-v3",
@@ -408,6 +444,10 @@ export async function materializeBackendTestExecutionReadiness(input) {
         throw new Error("backend-test execution readiness requires effective collection and fixture-resolution PASS");
     }
     const current = await buildBackendPytestAssetInventory(input.workspaceRoot, input.effective.mappedScripts);
+    const priorityOnly = priorityOnlyBackendPytestScripts(current.assetFiles);
+    if (priorityOnly.length > 0) {
+        throw new Error(`priority-only-pytest-module: ${priorityOnly.join(", ")}`);
+    }
     assertSameInventory(input.effective, current);
     const status = input.scenarioParamStatus === "FAIL"
         ? "BLOCKED"
@@ -442,6 +482,10 @@ export async function assertBackendTestExecutionReadinessFresh(workspaceRoot, re
         throw new Error(`backend pytest execution readiness is ${readiness.status}`);
     }
     const current = await buildBackendPytestAssetInventory(workspaceRoot, readiness.mappedScripts);
+    const priorityOnly = priorityOnlyBackendPytestScripts(current.assetFiles);
+    if (priorityOnly.length > 0) {
+        throw new Error(`priority-only-pytest-module: ${priorityOnly.join(", ")}`);
+    }
     assertSameInventory({ mappedScripts: readiness.mappedScripts, assetFiles: Object.keys(readiness.assetHashes), inputHashes: readiness.assetHashes }, current);
 }
 export async function assertBackendPytestCollectionFresh(workspaceRoot, effective) {

package/dist/workflows/dag/backend-test-writer-completeness.js CHANGED Viewed

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
+import { isPriorityOnlyBackendTestModuleStem } from "./backend-test-module-stem.js";
 /**
  * Maps a backend-test generation writer task id to its writer-progress role.
  * Returns undefined for nodes that are not completeness-gated generators.
@@ -96,31 +97,26 @@ function hasMarkdownTable(section, headerNeedle) {
  * phantom missing modules when the model discusses forbidden filenames
  * ("do not create 1.md / 9.md") inside the README body.
  */
-function looksLikeValidModuleStem(raw) {
+function moduleStemInvalidReason(raw) {
     if (!raw)
-        return false;
+        return "invalid-syntax";
     const stem = normalizeBackendTestModuleStem(raw);
+    if (isPriorityOnlyBackendTestModuleStem(stem))
+        return "priority-only-module-stem";
     if (stem.toLowerCase() === "readme")
-        return false;
+        return "reserved-module-stem";
     if (!/^[a-z][a-z0-9_]*$/.test(stem))
-        return false;
+        return "invalid-syntax";
     if (/^(?:be|tp|ac|req|br)[_-]/i.test(stem))
-        return false;
-    return true;
+        return "case-like-module-stem";
+    return undefined;
 }
-/**
- * Exported for reuse by the manifest-shell node that materializes the
- * module list JSON consumed by the map_agent expansion. Kept deterministic
- * (same extractor as the completeness gate) so the shard set always matches
- * the README index the gate trusts.
- */
-export function extractModuleStemsFromReadme(readme) {
-    const stems = [];
-    // Only trust testcase/md/<stem>.md mentions that appear inside markdown
-    // table rows (`| ... testcase/md/x.md ... |`) or as canonical relative
-    // links (`[label](./x.md)`). Free-form prose mentions such as a recovery
-    // note listing `testcase/md/1.md` must NOT be treated as authoritative
-    // module references, otherwise the gate invents phantom missing modules.
+function looksLikeValidModuleStem(raw) {
+    return moduleStemInvalidReason(raw) === undefined;
+}
+/** Inspect only authoritative README module-index candidates. */
+export function inspectModuleStemsFromReadme(readme) {
+    const candidates = [];
     const tableRowLines = readme
         .replaceAll("\r\n", "\n")
         .replaceAll("\r", "\n")
@@ -128,19 +124,42 @@ export function extractModuleStemsFromReadme(readme) {
         .filter((line) => line.includes("|"));
     for (const line of tableRowLines) {
         for (const match of line.matchAll(/`?testcase\/md\/([A-Za-z0-9_.-]+)\.md`?/g)) {
-            if (looksLikeValidModuleStem(match[1]))
-                stems.push(match[1]);
+            candidates.push(match[1]);
         }
         for (const match of line.matchAll(/\|\s*`?([A-Za-z0-9_.-]+)`?\s*\|\s*`?testcase\/test_/g)) {
-            if (looksLikeValidModuleStem(match[1]))
-                stems.push(match[1]);
+            // This compatibility shape can also capture a numeric count column.
+            // Keep valid stems and the priority-only defect we diagnose, while
+            // ignoring non-stem incidental cells such as `1`.
+            if (looksLikeValidModuleStem(match[1]) || isPriorityOnlyBackendTestModuleStem(match[1])) {
+                candidates.push(match[1]);
+            }
         }
     }
     for (const match of readme.matchAll(/\[[^\]]+\]\(\.\/([A-Za-z0-9_.-]+)\.md\)/g)) {
-        if (looksLikeValidModuleStem(match[1]))
-            stems.push(match[1]);
+        candidates.push(match[1]);
     }
-    return orderedUnique(stems.map((stem) => normalizeBackendTestModuleStem(stem)));
+    const uniqueCandidates = orderedUnique(candidates);
+    const invalid = uniqueCandidates.flatMap((raw) => {
+        const reasonCode = moduleStemInvalidReason(raw);
+        return reasonCode
+            ? [{ raw, normalized: normalizeBackendTestModuleStem(raw), reasonCode }]
+            : [];
+    });
+    return {
+        candidates: uniqueCandidates,
+        validStems: orderedUnique(uniqueCandidates
+            .filter(looksLikeValidModuleStem)
+            .map((stem) => normalizeBackendTestModuleStem(stem))),
+        invalid,
+    };
+}
+/**
+ * Exported for reuse by callers that only need the trusted shard set.
+ * Completeness gates must use inspectModuleStemsFromReadme so invalid
+ * authoritative candidates cannot be silently dropped.
+ */
+export function extractModuleStemsFromReadme(readme) {
+    return inspectModuleStemsFromReadme(readme).validStems;
 }
 async function listMarkdownModules(workspaceRoot) {
     const root = path.join(workspaceRoot, "testcase", "md");
@@ -242,12 +261,80 @@ function moduleStructuralDetail(result) {
         return "module file is structurally complete";
     return `module file is empty or has structural issues: ${result.reasons.join("; ")}`;
 }
+function pythonStructureOutsideStrings(source) {
+    const input = source.replace(/\r\n/g, "\n");
+    let output = "";
+    let index = 0;
+    let quote;
+    let triple = false;
+    let comment = false;
+    while (index < input.length) {
+        const char = input[index];
+        if (comment) {
+            if (char === "\n") {
+                comment = false;
+                output += "\n";
+            }
+            else
+                output += " ";
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === "\\") {
+                output += " ";
+                if (index + 1 < input.length)
+                    output += input[index + 1] === "\n" ? "\n" : " ";
+                index += 2;
+                continue;
+            }
+            if (triple && input.slice(index, index + 3) === quote.repeat(3)) {
+                output += "   ";
+                index += 3;
+                quote = undefined;
+                triple = false;
+                continue;
+            }
+            if (!triple && char === quote) {
+                output += " ";
+                index += 1;
+                quote = undefined;
+                continue;
+            }
+            if (!triple && char === "\n")
+                return { text: output, stringsClosed: false };
+            output += char === "\n" ? "\n" : " ";
+            index += 1;
+            continue;
+        }
+        if (char === "#") {
+            comment = true;
+            output += " ";
+            index += 1;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            triple = input.slice(index, index + 3) === char.repeat(3);
+            output += triple ? "   " : " ";
+            index += triple ? 3 : 1;
+            continue;
+        }
+        output += char;
+        index += 1;
+    }
+    return { text: output, stringsClosed: quote === undefined };
+}
 function pythonParseable(source) {
-    const text = source.replace(/\r\n/g, "\n");
-    if (!text.trim())
+    const normalized = source.replace(/\r\n/g, "\n");
+    if (!normalized.trim())
         return false;
-    if (/^\s*(?:def|class|import|from)\b/m.test(text) === false)
+    if (/^\s*(?:def|class|import|from)\b/m.test(normalized) === false)
+        return false;
+    const structural = pythonStructureOutsideStrings(normalized);
+    if (!structural.stringsClosed)
         return false;
+    const text = structural.text;
     const openParens = (text.match(/\(/g) ?? []).length;
     const closeParens = (text.match(/\)/g) ?? []).length;
     const openBrackets = (text.match(/\[/g) ?? []).length;
@@ -260,15 +347,6 @@ function pythonParseable(source) {
         return false;
     if (openBraces !== closeBraces)
         return false;
-    if (/("""|''')[\s\S]*$/.test(text)) {
-        const triples = text.match(/("""|''')/g) ?? [];
-        if (triples.length % 2 !== 0)
-            return false;
-    }
-    // The balanced-bracket counts above already catch a genuinely truncated
-    // file (an unclosed def/call leaves unbalanced parens). The previous
-    // per-line "def ... ( ... $" heuristic was a false-positive source for
-    // legal multi-line definitions such as `def f(\n    x,\n):` — removed.
     return true;
 }
 /**
@@ -318,12 +396,7 @@ function looksLikeValidPythonModule(source) {
         return false;
     if (/^\s*(?:def|class|import|from)\b/m.test(text) === false)
         return false;
-    if (/("""|''')[\s\S]*$/.test(text)) {
-        const triples = text.match(/("""|''')/g) ?? [];
-        if (triples.length % 2 !== 0)
-            return false;
-    }
-    return true;
+    return pythonStructureOutsideStrings(text).stringsClosed;
 }
 export function buildOutputLimitRecoveryPrompt(input) {
     return buildOutputLimitRecoverySection(input);
@@ -842,7 +915,19 @@ export async function assessBackendTestMdPlanCompleteness(workspaceRoot) {
         // The README must advertise a non-empty module index so the downstream
         // manifest shell has stems to shard; the indexed module files themselves
         // are produced by map_agent children and are NOT required here.
-        const indexedStems = extractModuleStemsFromReadme(readme);
+        const stemInspection = inspectModuleStemsFromReadme(readme);
+        const indexedStems = stemInspection.validStems;
+        for (const invalid of stemInspection.invalid) {
+            if (!brokenPaths.includes("testcase/md/README.md")) {
+                brokenPaths.push("testcase/md/README.md");
+            }
+            issues.push({
+                code: "T5",
+                path: "testcase/md/README.md",
+                detail: `${invalid.reasonCode}: ${invalid.normalized}; use a stable lowercase business resource/domain stem`,
+                recoverable: true,
+            });
+        }
         if (indexedStems.length === 0) {
             if (!brokenPaths.includes("testcase/md/README.md")) {
                 brokenPaths.push("testcase/md/README.md");