npm - @tea-agent/loop-agent - Versions diffs - 0.33.4 → 0.33.6-beta.0 - Mend

@tea-agent/loop-agent 0.33.4 → 0.33.6-beta.0

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 (27) hide show

package/CHANGELOG.md +36 -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-case-coverage-analysis.js +27 -2
package/dist/workflows/dag/backend-test-markdown-workflow.js +17 -0
package/dist/workflows/dag/backend-test-module-stem.js +26 -0
package/dist/workflows/dag/backend-test-pytest-collection.js +44 -0
package/dist/workflows/dag/backend-test-writer-completeness.js +165 -49
package/dist/workflows/dag/dynamic-runtime/map.js +24 -8
package/dist/workflows/dag/init-hybrid.js +44 -167
package/dist/workflows/dag/types.js +7 -0
package/docs/templates/backend-test-dag.json +10 -10
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-case-coverage-analysis.js CHANGED Viewed

@@ -909,6 +909,10 @@ function symbolCaseId(symbol) {
     const match = symbol.match(/^test_(BE(?:_[A-Z0-9]+)+?_\d{2,3})(?:_|$)/i);
     return match ? canonicalCaseId(match[1].replaceAll("_", "-")) : undefined;
 }
+function metadataCaseIds(region) {
+    return orderedUnique([...region.matchAll(/^\s*Case-ID\s*:\s*(BE-[A-Z0-9]+(?:-[A-Z0-9]+)*)\s*$/gmi)]
+        .map((match) => canonicalCaseId(match[1])));
+}
 function metadataTestPoints(region, label) {
     const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const match = new RegExp(`^\\s*${escaped}\\s*:\\s*(.*)$`, "mi").exec(region);
@@ -928,6 +932,27 @@ function pytestFunctionRegionStart(source, functionIndex) {
     }
     return regionStart;
 }
+function pytestFunctionBodyEnd(source, signatureEnd, functionIndent) {
+    let cursor = source.indexOf("\n", signatureEnd);
+    if (cursor < 0)
+        return source.length;
+    cursor += 1;
+    const baseIndent = functionIndent.replaceAll("\t", "    ").length;
+    while (cursor < source.length) {
+        const nextLine = source.indexOf("\n", cursor);
+        const lineEnd = nextLine < 0 ? source.length : nextLine;
+        const line = source.slice(cursor, lineEnd).replace(/\r$/, "");
+        if (line.trim()) {
+            const indentation = line.match(/^[ \t]*/)?.[0]?.replaceAll("\t", "    ").length ?? 0;
+            if (indentation <= baseIndent)
+                return cursor;
+        }
+        if (nextLine < 0)
+            return source.length;
+        cursor = nextLine + 1;
+    }
+    return source.length;
+}
 function pytestParameterCollections(source) {
     const collections = new Map();
     for (const match of source.matchAll(/^([A-Z][A-Z0-9_]*)\s*=\s*\[([\s\S]*?)^\]/gm)) {
@@ -941,10 +966,10 @@ function pytestSymbols(script, source) {
     const parameterCollections = pytestParameterCollections(source);
     return matches.map((match, index) => {
         const regionStart = regionStarts[index];
-        const regionEnd = regionStarts[index + 1] ?? source.length;
+        const regionEnd = pytestFunctionBodyEnd(source, match.index + match[0].length, match[1]);
         const region = source.slice(match.index, regionEnd);
         const decorators = source.slice(regionStart, match.index);
-        const ids = caseIds(region);
+        const ids = metadataCaseIds(region);
         const fromSymbol = symbolCaseId(match[2]);
         if (fromSymbol)
             ids.unshift(fromSymbol);

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,26 @@
+import path from "node:path";
+const PRIORITY_ONLY_MODULE_STEMS = new Set(["p0", "p1", "p2"]);
+const OPAQUE_HASH_MODULE_STEM = /^[a-f][a-f0-9]{6,63}$/;
+export const BACKEND_TEST_MAX_MODULE_COUNT = 8;
+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 isOpaqueHashBackendTestModuleStem(raw) {
+    return OPAQUE_HASH_MODULE_STEM.test(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) {