@tea-agent/loop-agent 0.44.0-next.7 → 0.44.0-next.9

package/dist/workflows/dag/frontend-test-execution-evidence.js

@@ -1,59 +1,217 @@
 import path from "node:path";
-import { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { readFile, realpath } from "node:fs/promises";
 import { z } from "zod";
-/** Decide whether a bare vitest/npm-test command is observable and, if so,
- * return the command with the separator (" --") a reporter would need. */
-async function adaptPlainTestCommand(command, cwd) {
-    const direct = /^(?:(?:npx|pnpm exec|yarn exec)\s+)?vitest\s+run(?:\s|$)/.test(command.trim());
-    const npm = /^npm\s+(?:run\s+([\w:-]+)|(test))(?=\s|$)(.*)$/.exec(command.trim());
-    let separator = "";
-    if (!direct) {
-        if (!npm)
-            return undefined;
-        let manifest;
-        try {
-            manifest = JSON.parse(await readFile(path.join(cwd, "package.json"), "utf8"));
+export const frontendTestObservationSchema = z.object({
+    scheme: z.literal("vitest-json-v1"),
+    commandId: z.string().optional(),
+    status: z.enum(["supported", "deferred", "unsupported"]),
+    commandSha256: z.string().regex(/^[a-f0-9]{64}$/),
+    cwd: z.string(),
+    packageScript: z.object({ file: z.string(), name: z.string(), sha256: z.string().nullable() }).optional(),
+    reason: z.string().optional(),
+}).strict();
+const hash = (text) => createHash("sha256").update(text).digest("hex");
+const quote = (text) => `'${text.replace(/'/g, `'"'"'`)}'`;
+/** Literal shell words only. Keep spans to replace a wrapper payload as ONE
+ * shell argument; never splice nested quotes into an already quoted payload. */
+function words(command) {
+    const result = [];
+    let i = 0;
+    while (i < command.length) {
+        if (/[\r\n]/.test(command[i]))
+            throw Error("multiple shell lines are unsupported");
+        if (/\s/.test(command[i])) {
+            i++;
+            continue;
         }
-        catch {
-            return undefined;
+        const start = i;
+        if (command.slice(i, i + 2) === "&&") {
+            result.push({ value: "&&", start, end: i += 2, operator: true });
+            continue;
         }
-        const script = manifest.scripts?.[npm[1] ?? "test"] ?? "";
-        if (!/^vitest\s+run(?:\s|$)/.test(script) || /[;&|<>`\n\r$]|--(?:reporter|outputFile)/.test(script))
-            return undefined;
-        if (npm[3]?.trim() && !/^--(?:\s|$)/.test(npm[3].trim()))
-            return undefined;
-        separator = npm[3]?.trim() ? "" : " --";
+        let value = "";
+        let quoted;
+        while (i < command.length) {
+            const c = command[i];
+            if (quoted === "'") {
+                if (c === "'")
+                    quoted = undefined;
+                else
+                    value += c;
+                i++;
+                continue;
+            }
+            if (c === "\\") {
+                const next = command[++i];
+                if (!next || /[\r\n]/.test(next))
+                    throw Error("invalid shell escape");
+                if (quoted === '"' && !['$', '`', '"', '\\'].includes(next))
+                    value += "\\";
+                value += next;
+                i++;
+                continue;
+            }
+            if (quoted === '"') {
+                if (c === '"')
+                    quoted = undefined;
+                else if (c === "$" || c === "`")
+                    throw Error("shell expansion is unsupported");
+                else
+                    value += c;
+                i++;
+                continue;
+            }
+            if (/\s/.test(c) || command.slice(i, i + 2) === "&&")
+                break;
+            if (c === "'" || c === '"') {
+                quoted = c;
+                i++;
+                continue;
+            }
+            if (/[;&|<>`$(){}*?\[\]#~]/.test(c))
+                throw Error("shell operators or expansion are unsupported");
+            value += c;
+            i++;
+        }
+        if (quoted)
+            throw Error("unterminated shell quote");
+        if (i === start)
+            throw Error("unsupported shell syntax");
+        result.push({ value, start, end: i });
+    }
+    return result;
+}
+function literalCommand(command, cwd, depth = 0) {
+    const tokens = words(command);
+    let offset = 0;
+    if (tokens[0]?.value === "cd") {
+        if (tokens[1]?.operator || tokens[2]?.value !== "&&" || !tokens[2].operator)
+            throw Error("only a leading literal cd is supported");
+        cwd = path.resolve(cwd, tokens[1].value);
+        offset = 3;
+    }
+    if (tokens.slice(offset).some(t => t.operator))
+        throw Error("compound commands are unsupported");
+    while (tokens[offset] && /^[A-Za-z_][A-Za-z0-9_]*=/.test(command.slice(tokens[offset].start, tokens[offset].end)))
+        offset++;
+    const argv = tokens.slice(offset).map(t => t.value);
+    if (argv[0] === "bash") {
+        // `bash -lc <payload>` is a wrapper: unwrap it and keep resolving the
+        // payload. Repeated layers are unwrapped too, matching the
+        // normalization the DAG generator already applies
+        // (normalizeVerifyCommandArgs in init-hybrid). Depth stays bounded so a
+        // pathological self-nesting payload terminates.
+        if (argv.length === 3 && argv[1] === "-lc") {
+            if (depth >= 8)
+                throw Error("unsupported bash wrapper");
+            const payload = tokens[offset + 2];
+            const inner = literalCommand(argv[2], cwd, depth + 1);
+            return { ...inner, append: suffix => command.slice(0, payload.start) + quote(inner.append(suffix)) + command.slice(payload.end) };
+        }
+        // A plain `bash <script> [args…]` invocation is NOT a wrapper: it is an
+        // ordinary command that simply is not a vitest/npm-test adapter. The
+        // frozen command for a declared repo script is
+        // `… 'bash' '-lc' 'bash scripts/check-repo.sh'`, so the payload lands
+        // here; throwing made the caller record
+        // FRONTEND_TEST_OBSERVATION_INVALID and blocked writer admission before
+        // implement could run. Returning the argv lets the normal capability
+        // check classify it as unsupported (non-fatal) instead.
+        if (argv.length >= 2)
+            return { argv, cwd, append: suffix => command.trimEnd() + suffix };
+        throw Error("unsupported bash wrapper");
+    }
+    return { argv, cwd, append: suffix => command.trimEnd() + suffix };
+}
+function directVitest(argv) {
+    const args = [...argv];
+    if (["npx"].includes(args[0] ?? ""))
+        args.shift();
+    else if (["pnpm", "yarn"].includes(args[0] ?? "") && args[1] === "exec")
+        args.splice(0, 2);
+    return args[0] === "vitest" && args[1] === "run";
+}
+function hasReporter(argv) { return argv.some(arg => /^--(?:reporter|outputFile)(?:[.=]|$)/.test(arg)); }
+/** Shared read-only capability resolver, used at generation, admission and
+ * immediately before execution. It never executes or rewrites an npm script. */
+export async function inspectFrontendTestCommand(input) {
+    const root = path.resolve(input.workspaceRoot ?? input.cwd);
+    let cwd = path.resolve(input.cwd);
+    const base = { scheme: "vitest-json-v1", status: "unsupported", commandSha256: hash(input.command), cwd: path.relative(root, cwd).replace(/\\/g, "/") || "." };
+    try {
+        const parsed = literalCommand(input.command, cwd);
+        cwd = parsed.cwd;
+        base.cwd = path.relative(root, cwd).replace(/\\/g, "/") || ".";
+        if (base.cwd === ".." || base.cwd.startsWith("../") || path.isAbsolute(base.cwd))
+            throw Error("test cwd is outside the workspace");
+        // Reject symlink escapes too, while a future directory remains governed
+        // by the existing cwd/future-delivery preflight.
+        const physicalRoot = await realpath(root).catch(() => root);
+        const physicalCwd = await realpath(cwd).catch(() => cwd);
+        const physicalRelative = path.relative(physicalRoot, physicalCwd);
+        if (physicalRelative === ".." || physicalRelative.startsWith(`..${path.sep}`) || path.isAbsolute(physicalRelative))
+            throw Error("test cwd resolves outside the workspace");
+        if (hasReporter(parsed.argv))
+            throw Error("frozen command already owns reporter/outputFile flags");
+        let separator = "";
+        if (!directVitest(parsed.argv)) {
+            const argv = parsed.argv;
+            const name = argv[0] === "npm" ? argv[1] === "test" ? "test" : argv[1] === "run" ? argv[2] : undefined : undefined;
+            if (!name || !/^[\w:-]+$/.test(name))
+                throw Error("no supported test reporter adapter for this command");
+            const rest = argv.slice(argv[1] === "test" ? 2 : 3);
+            if (rest.length && rest[0] !== "--")
+                throw Error("npm script arguments require --");
+            const file = path.relative(root, path.join(cwd, "package.json")).replace(/\\/g, "/");
+            let manifest = {};
+            try {
+                manifest = JSON.parse(await readFile(path.join(cwd, "package.json"), "utf8"));
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw Error("package.json is unreadable or invalid");
+            }
+            const script = manifest?.scripts?.[name];
+            base.packageScript = { file, name, sha256: typeof script === "string" ? hash(JSON.stringify({ script, pre: manifest.scripts?.[`pre${name}`] ?? null, post: manifest.scripts?.[`post${name}`] ?? null })) : null };
+            if (script === undefined) {
+                const authorized = input.allowedPaths?.some(pattern => pathMatchesPattern(file, pattern)) && !input.forbiddenPaths?.some(pattern => pathMatchesPattern(file, pattern));
+                if (!authorized)
+                    throw Error(`missing npm script ${name}; ${file} is not an authorized delivery`);
+                return { observation: { ...base, status: "deferred", reason: `Awaiting authorized ${file} script ${name} with vitest-json-v1 capability` }, effectiveCwd: cwd };
+            }
+            if (typeof script !== "string")
+                throw Error("npm script must be a string");
+            const scriptWords = words(script);
+            if (scriptWords.some(word => word.operator) || !directVitest(scriptWords.map(w => w.value)) || hasReporter(scriptWords.map(w => w.value)))
+                throw Error("npm script has no supported Vitest JSON reporter capability");
+            separator = rest.length ? "" : " --";
+        }
+        return { observation: { ...base, status: "supported" }, effectiveCwd: cwd,
+            withReporter: reportPath => parsed.append(`${separator} --reporter=json --outputFile=${quote(reportPath)}`) };
     }
-    return `${command}${separator}`;
+    catch (error) {
+        return { observation: { ...base, status: "unsupported", reason: error instanceof Error ? error.message : String(error) }, effectiveCwd: cwd };
+    }
+}
+export function compareFrontendTestObservation(frozen, observed, phase, writeSet = []) {
+    if (frozen.status === "unsupported")
+        return frozen.reason ?? "unsupported test observation scheme";
+    if (observed.status === "unsupported")
+        return observed.reason ?? "unsupported test observation scheme";
+    if (frozen.scheme !== observed.scheme || frozen.commandSha256 !== observed.commandSha256 || frozen.cwd !== observed.cwd || frozen.packageScript?.file !== observed.packageScript?.file || frozen.packageScript?.name !== observed.packageScript?.name)
+        return "frozen test command/cwd/script binding changed";
+    if (frozen.status === "supported" && (observed.status !== "supported" || frozen.packageScript?.sha256 !== observed.packageScript?.sha256))
+        return "frozen npm test script changed";
+    if (frozen.status === "deferred" && phase === "admission" && (!frozen.packageScript || !writeSet.includes(frozen.packageScript.file)))
+        return "future test script is outside the admitted concrete writeSet";
+    if (phase === "execution" && observed.status !== "supported")
+        return "future test reporter capability is still unavailable";
+    return undefined;
 }
 /** Observe supported frozen Vitest commands without changing their selection. */
 export async function withFrontendTestReporter(input) {
-    // Compound commands/wrappers need their own adapter: never append flags to
-    // a different shell command, change selection, or override a user reporter.
-    if (/[;&|<>`\n\r$]/.test(input.command) || /--(?:reporter|outputFile)/.test(input.command))
-        return undefined;
-    // Frozen verify commands are env-prefixed bash wrappers —
-    // `HARNESS_ALLOW_ACTIVE_DAG_RUNS=1 'bash' '-lc' 'npm test'` — so the JSON
-    // reporter must be injected INSIDE the quoted payload; appending it to the
-    // wrapper would target bash's own CLI and produce no test report at all
-    // (smoke r54: every behavior verification target then failed the trace
-    // gate with "test execution report unavailable").
-    const bashWrapped = /^((?:[A-Za-z_][A-Za-z0-9_]*=(?:'[^']*'|[^\s'"]+)\s+)*)'bash'\s+'-lc'\s+'([^']*)'\s*$/.exec(input.command);
-    if (bashWrapped) {
-        const inner = bashWrapped[2];
-        if (/[;&|<>`\n\r$]/.test(inner) || /--(?:reporter|outputFile)/.test(inner))
-            return undefined;
-        const adaptedInner = await adaptPlainTestCommand(inner, input.cwd);
-        if (!adaptedInner)
-            return undefined;
-        const quote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
-        return input.command.replace(`'${inner}'`, `'${adaptedInner} --reporter=json --outputFile=${quote(input.reportPath)}'`);
-    }
-    const adapted = await adaptPlainTestCommand(input.command, input.cwd);
-    if (!adapted)
-        return undefined;
-    const quote = (value) => `'${value.replace(/'/g, `'"'"'`)}'`;
-    return `${adapted} --reporter=json --outputFile=${quote(input.reportPath)}`;
+    return (await inspectFrontendTestCommand(input)).withReporter?.(input.reportPath);
 }
 const resultSchema = z.object({
     testResults: z.array(z.object({

package/dist/workflows/dag/frontend-typed-event-store.js

@@ -1,3 +1,4 @@
+import { sanitizeRepairAssertions } from "./frontend-repair-assertions.js";
 import { readFile } from "node:fs/promises";
 import { z } from "zod";
 import { sha256OfCanonicalJson } from "../../task/contract/hash.js";
@@ -196,13 +197,17 @@ export const reviewFindingSchema = z
     line: z.number().int().positive().optional(),
     issue: z.string().min(1),
     requiredChange: z.string().min(1).optional(),
-    repairAssertions: z.array(z.object({
-        check: z.enum(["file-absent", "state-present", "vt-changed"]),
-        token: z.string().min(1), source: z.string(),
-        expectedRequirementIds: z.array(z.string().min(1)).optional(),
-    }).strict()).optional(),
+    repairAssertions: z.unknown().optional(),
+    repairAssertionDiagnostics: z.array(z.string()).optional(),
 })
-    .strict();
+    .strict().transform(finding => {
+    const { repairAssertions, ...base } = finding;
+    if (repairAssertions === undefined)
+        return base;
+    const sanitized = sanitizeRepairAssertions(repairAssertions);
+    const diagnostics = [...(finding.repairAssertionDiagnostics ?? []), ...sanitized.diagnostics];
+    return { ...finding, repairAssertions: sanitized.assertions, ...(diagnostics.length ? { repairAssertionDiagnostics: [...new Set(diagnostics)] } : {}) };
+});
 /** `approve_review` terminal fact payload. Approval may carry informational
  * findings (Minor/Info) but never Critical/Important. */
 export const approveReviewFactSchema = z

package/dist/workflows/dag/frontend-verification-trace.js

@@ -261,6 +261,8 @@ export async function evaluateFrontendWriterTracePreflight(input) {
             ...(target.symbol ? { symbol: target.symbol } : {}),
             status: fileTrace.issues.length ? "failed" : "ok",
             evidence: fileTrace.issues.length ? "unavailable" : "file-exists",
+            plannedEvidenceLevel: target.evidenceLevel ?? "unknown",
+            ...(target.boundary ? { boundary: target.boundary } : {}),
             behaviorCoverage: "unconfirmed",
             matchedNodeIds: [],
             issues: fileTrace.issues,
@@ -322,6 +324,8 @@ export async function evaluateVerificationTargets(input) {
             evidence: issues.length
                 ? "unavailable"
                 : target.mode === "static" ? "command-execution" : "test-file-execution",
+            plannedEvidenceLevel: target.evidenceLevel ?? "unknown",
+            ...(target.boundary ? { boundary: target.boundary } : {}),
             behaviorCoverage: "unconfirmed",
             matchedNodeIds: owners ?? [],
             issues,
@@ -494,6 +498,7 @@ export async function runFrontendVerificationTraceGate(input) {
         contractSchemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
         browserStatus: "not-run",
         visualStatus: "not-run",
+        testExecutionEvidence: input.evidence?.behavior.testExecutionEvidence ?? [],
         targets,
         mockStrategy: contract.mockApi.strategy,
         mockCommandLabels,
@@ -515,6 +520,7 @@ export async function runFrontendVerificationTraceGate(input) {
             mockCommandNodeId: result.mockCommandNodeId,
             mockCommandTexts: result.mockCommandTexts,
             targets: result.targets,
+            testExecutionEvidence: result.testExecutionEvidence,
         }, null, 2)}\n`, "utf8");
         result.artifactPath = artifactPath;
     }

package/dist/workflows/dag/frontend-writer-admission.js

@@ -163,7 +163,7 @@ export function deriveWriteSet(contract, options) {
     const candidates = [
         ...contract.targets.files,
         ...contract.verificationTargets
-            .filter((target) => target.mode !== "static")
+            .filter((target) => target.mode !== "static" && !options?.existingVerificationPaths?.includes(target.file))
             .map((target) => target.file),
     ];
     // Expand glob entries (e.g. `src/**` inherited from the skeleton) against
@@ -249,6 +249,7 @@ export function deriveFrontendWriterAdmissionShell(input) {
     }
     const derived = deriveWriteSet(input.contract, {
         workspaceFiles: input.workspaceFiles,
+        existingVerificationPaths: input.existingVerificationPaths,
     });
     findings.push(...derived.findings);
     const baseline = freezeBaseline(input.baseline);