@tea-agent/loop-agent 0.44.0-next.10 → 0.44.0-next.12

package/dist/executors/shell-executor.js

@@ -1,7 +1,7 @@
 import { collectExistingFrontendVerificationPaths } from "../workflows/dag/frontend-implementation-contract.js";
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
-import { inspectFrontendTestCommand, compareFrontendTestObservation, parseFrontendTestExecutionReport } from "../workflows/dag/frontend-test-execution-evidence.js";
+import { FRONTEND_TEST_OBSERVATION_FAILURES, inspectFrontendTestCommand, compareFrontendTestObservation, parseFrontendTestExecutionReport } from "../workflows/dag/frontend-test-execution-evidence.js";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -135,6 +135,13 @@ function shouldReuseSuccessfulShellCommands(shell) {
     return shell.verifyEvidence?.phase === "intermediate" || shell.verifyEvidence?.phase === "final";
 }
 const DEFAULT_SHELL_TIMEOUT_MS = 300_000;
+/**
+ * Tolerance for filesystem mtime granularity when rejecting a test report as
+ * stale. Reports are written by the command we just ran, so the only legitimate
+ * skew is coarse mtime resolution (1s on some filesystems) — not a real clock
+ * difference.
+ */
+const REPORT_FRESHNESS_SKEW_MS = 2_000;
 const SUMMARY_STDOUT_MAX = 4_000;
 const SUMMARY_STDERR_MAX = 2_000;
 const TEST_TIMEOUT_CLASSIFY_MAX_CHARS = 8_000;
@@ -312,7 +319,10 @@ export async function executeShellCommand(input) {
             : undefined;
         const child = spawn(resolveBashExecutable(), ["-c", input.command], {
             cwd: input.cwd,
-            env: buildShellProcessEnv(input.envAllowlist, injectedEnv),
+            env: buildShellProcessEnv(input.envAllowlist, {
+                ...injectedEnv,
+                ...input.extraEnv,
+            }),
             ...processTreeSpawnOptions(),
             stdio: ["ignore", "pipe", "pipe"],
         });
@@ -2140,16 +2150,20 @@ async function executeFrontendVerificationBundle(input, meta) {
             let result = cached ? reuseCommandResult(cached, command) : undefined;
             if (!result) {
                 const commandNumber = results.length + 1;
-                const reportPath = path.join(meta.runDir, input.task.id, "commands", `${commandNumber}-${randomUUID()}.vitest.json`);
                 const observedTest = testPreflight.inspected.get(command);
-                const observedCommand = observedTest?.withReporter?.(reportPath);
-                if (observedCommand)
+                // Name the report after the resolved protocol so an operator can
+                // tell at a glance which runner produced it.
+                const reportScheme = observedTest?.observation.scheme ?? "vitest-json-v1";
+                const reportPath = path.join(meta.runDir, input.task.id, "commands", `${commandNumber}-${randomUUID()}.${reportScheme}.json`);
+                const observedInvocation = observedTest?.withReporter?.(reportPath);
+                if (observedInvocation)
                     await mkdir(path.dirname(reportPath), { recursive: true });
                 result = await executeShellCommand({
-                    command: observedCommand ?? command,
+                    command: observedInvocation?.command ?? command,
                     cwd,
                     timeoutMs: shell.timeoutMs ?? DEFAULT_SHELL_TIMEOUT_MS,
                     envAllowlist: shell.envAllowlist,
+                    extraEnv: observedInvocation?.env,
                     dagRunMeta: { runDir: meta.runDir, runId: meta.runId },
                     reportActivity: input.reportActivity,
                     outputArtifacts: {
@@ -2158,21 +2172,35 @@ async function executeFrontendVerificationBundle(input, meta) {
                     },
                 });
                 let reportError;
-                if (observedCommand && result.ok) {
+                if (observedInvocation && result.ok) {
                     try {
-                        // Vitest reports physical paths (e.g. /private/var on macOS).
+                        // Runners report physical paths (e.g. /private/var on macOS).
                         // Match those in workspace coordinates even when shell.cwd is
                         // a subdirectory or the caller used a directory alias.
+                        const reportStat = await stat(reportPath);
+                        // A stale report from an earlier run would otherwise let a
+                        // command that wrote nothing at all look verified.
+                        if (reportStat.mtimeMs < started - REPORT_FRESHNESS_SKEW_MS) {
+                            throw new Error(`stale test execution report (${FRONTEND_TEST_OBSERVATION_FAILURES.reportProtocol}): report predates this command`);
+                        }
                         const rawReport = await readFile(reportPath, "utf8");
                         const reportSha256 = createHash("sha256").update(rawReport).digest("hex");
-                        commandExecutionEvidence.set(key, parseFrontendTestExecutionReport(JSON.parse(rawReport), await realpath(observedTest?.effectiveCwd ?? cwd), await realpath(input.cwd)));
+                        const parsedExecutions = parseFrontendTestExecutionReport(JSON.parse(rawReport), await realpath(observedTest?.effectiveCwd ?? cwd), await realpath(input.cwd), observedTest.observation.scheme);
+                        // Zero tests is not evidence: the runner may have matched no
+                        // file at all. The trace gate also rejects a target file with
+                        // no matching record, but failing here keeps the report itself
+                        // from being recorded as a successful observation.
+                        if (parsedExecutions.length === 0) {
+                            throw new Error(`test execution report contains no test cases (${FRONTEND_TEST_OBSERVATION_FAILURES.reportProtocol})`);
+                        }
+                        commandExecutionEvidence.set(key, parsedExecutions);
                         const actual = commandExecutionEvidence.get(key);
                         for (let offset = 0; offset < actual.length; offset += 24) {
                             const relative = `${input.task.id}/commands/${commandNumber}-execution-${offset / 24}.json`;
-                            const excerpt = { schemaVersion: 1, commandSha256: observedTest.observation.commandSha256, cwd: observedTest.observation.cwd, reportSha256, offset, total: actual.length, behaviorCoverage: "unconfirmed", tests: actual.slice(offset, offset + 24).map(test => ({ file: test.file, status: test.status, title: test.title.slice(0, 500), ...(test.title.length > 500 ? { titleTruncated: true } : {}) })) };
+                            const excerpt = { schemaVersion: 1, scheme: observedTest.observation.scheme, commandSha256: observedTest.observation.commandSha256, cwd: observedTest.observation.cwd, reportSha256, offset, total: actual.length, behaviorCoverage: "unconfirmed", tests: actual.slice(offset, offset + 24).map(test => ({ file: test.file, status: test.status, title: test.title.slice(0, 500), ...(test.title.length > 500 ? { titleTruncated: true } : {}) })) };
                             await writeDagRunJsonArtifact(meta.runDir, relative, excerpt);
                             const bytes = await readFile(path.join(meta.runDir, relative));
-                            testExecutionEvidence.push({ path: relative, sha256: createHash("sha256").update(bytes).digest("hex"), reportPath: path.relative(meta.runDir, reportPath).replace(/\\/g, "/"), reportSha256 });
+                            testExecutionEvidence.push({ path: relative, sha256: createHash("sha256").update(bytes).digest("hex"), reportPath: path.relative(meta.runDir, reportPath).replace(/\\/g, "/"), reportSha256, scheme: observedTest.observation.scheme });
                         }
                     }
                     catch (error) {

package/dist/worker/console/routes.js

@@ -38,6 +38,11 @@ function contentTypeFor(pathname) {
         return "text/css; charset=utf-8";
     if (lower.endsWith(".json"))
         return "application/json; charset=utf-8";
+    // A web app manifest must carry this exact type: browsers ignore the
+    // document (and therefore offer no install entry) when it arrives as
+    // application/octet-stream.
+    if (lower.endsWith(".webmanifest"))
+        return "application/manifest+json";
     if (lower.endsWith(".svg"))
         return "image/svg+xml";
     if (lower.endsWith(".png"))

package/dist/worker/console/static/app-icon.svg

@@ -0,0 +1,39 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">
+  <title>Loop Agent App Icon</title>
+  <style>
+    .loop-ink { stroke: #26251e; }
+    @media (prefers-color-scheme: dark) {
+      .loop-ink { stroke: #f7f7f4; }
+    }
+  </style>
+  <defs>
+    <mask id="square-handoff" maskUnits="userSpaceOnUse" x="0" y="6" width="64" height="52">
+      <rect x="0" y="6" width="64" height="52" fill="#ffffff" />
+      <path
+        d="m31.15 32.28 2.83 3.11"
+        fill="none"
+        stroke="#000000"
+        stroke-linecap="round"
+        stroke-width="6.23"
+      />
+    </mask>
+  </defs>
+  <g transform="translate(4.8485 13.899) scale(0.56566)">
+    <path
+      class="loop-ink"
+      d="M12 32c0-16 16-20 28-6l17 18c11 11 27 5 27-12S68 9 57 20L39 39C28 51 12 48 12 32Z"
+      fill="none"
+      stroke-linecap="round"
+      stroke-linejoin="round"
+      stroke-width="11"
+      mask="url(#square-handoff)"
+    />
+  </g>
+  <path
+    d="m31.15 32.28 2.83 3.11"
+    fill="none"
+    stroke="#f54e00"
+    stroke-linecap="round"
+    stroke-width="5.37"
+  />
+</svg>

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

@@ -3,7 +3,10 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="theme-color" content="#f4f2ee" />
+    <link rel="manifest" href="/manifest.webmanifest" />
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <link rel="apple-touch-icon" href="/app-icon.svg" />
     <link rel="preconnect" href="https://cdn.jsdelivr.net" />
     <link
       rel="stylesheet"

package/dist/worker/console/static/manifest.webmanifest

@@ -0,0 +1,19 @@
+{
+  "id": "/",
+  "name": "Loop Operator Console",
+  "short_name": "Loop Console",
+  "description": "Loop Agent 操作台：任务、Agent DAG 运行与交付证据的只读观察与受控操作界面",
+  "start_url": "/",
+  "scope": "/",
+  "display": "standalone",
+  "background_color": "#f4f2ee",
+  "theme_color": "#f4f2ee",
+  "icons": [
+    {
+      "src": "/app-icon.svg",
+      "sizes": "any",
+      "type": "image/svg+xml",
+      "purpose": "any"
+    }
+  ]
+}

package/dist/worker/observe/static/console-theme.js

@@ -7,10 +7,46 @@ export const CONSOLE_THEMES = Object.freeze([
 
 const STORAGE_KEY = "loop-console.theme.v1";
 
+/**
+ * Titlebar colour per theme, matching each palette's --canvas. An installed PWA
+ * paints the OS window frame with the theme-color meta value, so it must track
+ * the active theme: a fixed brand colour leaves an orange titlebar above the
+ * dark midnight palette. Values mirror console-theme.css --canvas.
+ */
+const TITLEBAR_COLOR = Object.freeze({
+	default: "#f4f2ee",
+	midnight: "#1c222a",
+	daylight: "#eef0f2",
+});
+
 function normalizeTheme(value) {
 	return CONSOLE_THEMES.some((theme) => theme.id === value) ? value : "default";
 }
 
+/**
+ * Project the theme onto the document's theme-color meta tag. Browsers read
+ * this tag live (the manifest theme_color only applies at install time), and
+ * an installed window repaints its frame when it changes.
+ *
+ * Strictly best-effort: the titlebar is cosmetic, so a missing or partial DOM
+ * (SSR, a test stub, an exotic embedder) must never break theme switching.
+ */
+function syncTitlebarColor(theme) {
+	try {
+		const head = document?.head;
+		if (!head || typeof document.createElement !== "function") return;
+		let meta = document.querySelector?.('meta[name="theme-color"]');
+		if (!meta) {
+			meta = document.createElement("meta");
+			meta.setAttribute("name", "theme-color");
+			head.appendChild(meta);
+		}
+		meta.setAttribute("content", TITLEBAR_COLOR[theme] ?? TITLEBAR_COLOR.default);
+	} catch {
+		// The palette switch above already succeeded; the titlebar is optional.
+	}
+}
+
 export function applyStoredConsoleTheme() {
 	let value;
 	try {
@@ -20,6 +56,7 @@ export function applyStoredConsoleTheme() {
 	}
 	const theme = normalizeTheme(value);
 	document.documentElement.dataset.consoleTheme = theme;
+	syncTitlebarColor(theme);
 	return theme;
 }
 
@@ -27,6 +64,7 @@ export function setConsoleTheme(value) {
 	const theme = normalizeTheme(value);
 	// Apply before persistence: a storage failure must not disable the picker.
 	document.documentElement.dataset.consoleTheme = theme;
+	syncTitlebarColor(theme);
 	try {
 		window.localStorage.setItem(STORAGE_KEY, theme);
 	} catch {