@tea-agent/loop-agent 0.41.1-beta.0 → 0.42.0-next.2

package/dist/workflows/dag/frontend-worktree-diff.js

@@ -5,152 +5,25 @@ import { runResilientGitCommand } from "../../shared/resilient-git.js";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 export const FRONTEND_WORKTREE_DIFF_SCHEMA_ID = "frontend-worktree-diff-v1";
-export const FRONTEND_REVIEW_DIFF_INDEX_SCHEMA_ID = "frontend-review-diff-index-v1";
-const MAX_REVIEW_DIFF_SUMMARY_ENTRIES = 48;
-/** Maximum diff payload per review artifact; metadata adds a small fixed header. */
-const MAX_REVIEW_DIFF_FRAGMENT_BYTES = 20 * 1024;
 export const FRONTEND_WORKTREE_BASELINE_SCHEMA_ID = "frontend-worktree-baseline-v1";
 async function runGit(cwd, args) {
     const result = await runResilientGitCommand({ cwd, args, readOnly: true });
     return { code: result.code, stdout: result.stdout, stderr: result.stderr };
 }
-/**
- * Ephemeral interpreter/tool caches that writers may create while drafting
- * tests (kept in sync with `isEphemeralToolCachePath` in
- * src/executors/shell-write-guard.ts). They are not product evidence: tool
- * cache writes must neither fail the write guard nor appear in the review
- * diff as pre-existing changes.
- */
-export function isEphemeralToolCachePath(filePath) {
-    const normalized = filePath.replace(/\\/g, "/");
-    if (!normalized)
-        return false;
-    if (normalized === ".pytest_cache" ||
-        normalized.startsWith(".pytest_cache/")) {
-        return true;
-    }
-    if (normalized === ".mypy_cache" || normalized.startsWith(".mypy_cache/")) {
-        return true;
-    }
-    if (normalized === ".ruff_cache" || normalized.startsWith(".ruff_cache/")) {
-        return true;
-    }
-    if (normalized === ".playwright-cli" ||
-        normalized.startsWith(".playwright-cli/")) {
-        return true;
-    }
-    if (normalized === ".coverage" || normalized.startsWith(".coverage.")) {
-        return true;
-    }
-    // vite/vitest runtime caches live under node_modules/.vite (e.g.
-    // node_modules/.vite/vitest/results.json). node_modules is the gitignored
-    // dependency tree — tool cache writes there are never a product change.
-    if (normalized.startsWith("node_modules/.vite/")) {
-        return true;
-    }
-    if (/(?:^|\/)__pycache__(?:\/|$)/.test(normalized))
-        return true;
-    if (/\.(?:pyc|pyo)$/.test(normalized))
-        return true;
-    return false;
-}
 function splitLines(text) {
     return text
         .split(/\r?\n/)
         .map((line) => line.trim())
         .filter(Boolean);
 }
-function buildReviewDiffSummary(input) {
-    const files = [...input.hunks.reduce((grouped, hunk) => {
-            const existing = grouped.get(hunk.path);
-            if (existing) {
-                existing.bytes += hunk.bytes;
-                existing.lastPatchPath = hunk.patchPath;
-                return grouped;
-            }
-            grouped.set(hunk.path, {
-                path: hunk.path,
-                bytes: hunk.bytes,
-                parts: hunk.parts,
-                firstPatchPath: hunk.patchPath,
-                lastPatchPath: hunk.patchPath,
-            });
-            return grouped;
-        }, new Map()).values()];
-    const listedFiles = files.slice(0, MAX_REVIEW_DIFF_SUMMARY_ENTRIES);
-    const remainingFiles = files.length - listedFiles.length;
-    const listedUntracked = input.untrackedFiles.slice(0, MAX_REVIEW_DIFF_SUMMARY_ENTRIES);
-    const remainingUntracked = input.untrackedFiles.length - listedUntracked.length;
-    return [
-        "# Frontend review diff summary",
-        "",
-        "Read this bounded summary first. Do not read artifacts/diff_patch.patch in full; it is retained only as the canonical audit artifact.",
-        "For a semantic finding, read only the matching per-file diff fragment below and then the current source file when necessary. Read fragments in part order when a file has more than one.",
-        "",
-        `Canonical patch SHA-256: ${input.patchSha256}`,
-        `Canonical patch bytes: ${input.patchBytes}`,
-        `Tracked changed files: ${files.length}`,
-        `Review diff fragments: ${input.hunks.length}`,
-        `Untracked files (inventory only): ${input.untrackedFiles.length}`,
-        "",
-        "## Tracked file diff fragment references",
-        ...(listedFiles.length > 0
-            ? listedFiles.map((file) => file.parts === 1
-                ? `- ${file.path} — ${file.bytes} bytes — read ${file.firstPatchPath} only if this file needs review`
-                : `- ${file.path} — ${file.bytes} bytes across ${file.parts} ordered fragments — read ${file.firstPatchPath} through ${file.lastPatchPath} only if this file needs review`)
-            : ["- (none)"]),
-        ...(remainingFiles > 0
-            ? [`- … ${remainingFiles} additional tracked files are recorded in contracts/frontend-review-diff-index.json; do not bulk-read them.`]
-            : []),
-        "",
-        "## Untracked inventory",
-        ...(listedUntracked.length > 0
-            ? listedUntracked.map((file) => `- ${file}`)
-            : ["- (none)"]),
-        ...(remainingUntracked > 0
-            ? [`- … ${remainingUntracked} additional untracked files are recorded in contracts/frontend-review-diff-index.json.`]
-            : []),
-        "",
-    ].join("\n");
-}
-function splitReviewDiffFragments(text) {
-    const fragments = [];
-    let current = "";
-    for (const line of text.match(/[^\n]*\n|[^\n]+/g) ?? []) {
-        const lineBytes = Buffer.byteLength(line);
-        if (current.length > 0 &&
-            Buffer.byteLength(current) + lineBytes >
-                MAX_REVIEW_DIFF_FRAGMENT_BYTES) {
-            fragments.push(current);
-            current = "";
-        }
-        if (lineBytes <= MAX_REVIEW_DIFF_FRAGMENT_BYTES) {
-            current += line;
-            continue;
-        }
-        // Generated/minified files can produce a single diff line larger than the
-        // review budget. Split by Unicode code point so no fragment exceeds the
-        // byte limit while preserving the original patch bytes when concatenated.
-        let oversizedLineFragment = "";
-        let oversizedLineFragmentBytes = 0;
-        for (const codePoint of line) {
-            const codePointBytes = Buffer.byteLength(codePoint);
-            if (oversizedLineFragmentBytes > 0 &&
-                oversizedLineFragmentBytes + codePointBytes >
-                    MAX_REVIEW_DIFF_FRAGMENT_BYTES) {
-                fragments.push(oversizedLineFragment);
-                oversizedLineFragment = "";
-                oversizedLineFragmentBytes = 0;
-            }
-            oversizedLineFragment += codePoint;
-            oversizedLineFragmentBytes += codePointBytes;
-        }
-        if (oversizedLineFragment)
-            fragments.push(oversizedLineFragment);
-    }
-    if (current.length > 0)
-        fragments.push(current);
-    return fragments.length > 0 ? fragments : [""];
+function statusPaths(status) {
+    return status
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length >= 4)
+        .map((line) => line.slice(3).split(" -> ").at(-1) ?? "")
+        .filter(Boolean)
+        .sort();
 }
 async function sha256File(filePath) {
     try {
@@ -164,26 +37,15 @@ async function sha256File(filePath) {
 export async function captureFrontendWorktreeBaseline(input) {
     const run = input.dependencies?.runGit ?? runGit;
     const root = path.resolve(input.workspaceRoot);
-    // Baseline = the full concrete workspace inventory the writer may touch
-    // (tracked + untracked, gitignored excluded), NOT just currently-changed
-    // files. Using `git status` here made a clean repository baseline-empty
-    // (status has no entries when nothing changed), which wrongly blocked
-    // writer admission with baseline-empty.
-    const ls = await run(root, [
-        "ls-files",
-        "-co",
-        "--exclude-standard",
-        "-z",
+    const status = await run(root, [
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
     ]);
-    if (ls.code !== 0) {
-        throw new Error(`frontend worktree baseline failed: ${ls.stderr.trim() || ls.stdout.trim()}`);
+    if (status.code !== 0) {
+        throw new Error(`frontend worktree baseline failed: ${status.stderr.trim() || status.stdout.trim()}`);
     }
-    const files = ls.stdout
-        .split("\0")
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .filter((file) => !isEphemeralToolCachePath(file))
-        .sort();
+    const files = statusPaths(status.stdout);
     const hashes = {};
     for (const file of files)
         hashes[file] = await sha256File(path.join(root, file));
@@ -250,12 +112,8 @@ export async function runFrontendWorktreeDiffGate(input) {
     if (untracked.code !== 0) {
         throw new Error(`frontend worktree diff gate ls-files failed: ${untracked.stderr.trim() || untracked.stdout.trim()}`);
     }
-    const changedFilesAll = splitLines(nameOnly.stdout)
-        .filter((file) => !isEphemeralToolCachePath(file))
-        .sort();
-    const untrackedFilesAll = splitLines(untracked.stdout)
-        .filter((file) => !isEphemeralToolCachePath(file))
-        .sort();
+    const changedFilesAll = splitLines(nameOnly.stdout).sort();
+    const untrackedFilesAll = splitLines(untracked.stdout).sort();
     const authorizedChangedPaths = input.authorizedChangedPaths ?? [];
     if (baseline) {
         for (const file of baseline.files) {
@@ -302,65 +160,11 @@ export async function runFrontendWorktreeDiffGate(input) {
     const absolutePatch = path.join(input.runDir, ...relativePatch.split("/"));
     await mkdir(path.dirname(absolutePatch), { recursive: true });
     await writeFile(absolutePatch, patchText, "utf8");
-    // Keep the complete patch as immutable audit evidence, but create a bounded
-    // reviewer entrypoint plus one file-scoped artifact per tracked change. This
-    // prevents final review from loading a multi-thousand-line patch into a
-    // single Pi session merely to inspect one or two relevant files.
-    const reviewHunks = [];
-    const reviewHunksDir = path.join(input.runDir, "artifacts", "diff-hunks");
-    await mkdir(reviewHunksDir, { recursive: true });
-    for (const [index, file] of changedFiles.entries()) {
-        const filePatch = await run(root, ["diff", "--binary", "HEAD", "--", file]);
-        if (filePatch.code !== 0) {
-            throw new Error(`frontend worktree diff hunk failed for ${file}: ${filePatch.stderr.trim() || filePatch.stdout.trim()}`);
-        }
-        const text = filePatch.stdout.endsWith("\n") || filePatch.stdout.length === 0
-            ? filePatch.stdout
-            : `${filePatch.stdout}\n`;
-        const fragments = splitReviewDiffFragments(text);
-        for (const [partIndex, fragment] of fragments.entries()) {
-            const part = partIndex + 1;
-            const patchPath = `artifacts/diff-hunks/${String(index + 1).padStart(3, "0")}-${String(part).padStart(3, "0")}.patch`;
-            const artifact = [
-                "# Frontend review diff fragment",
-                `# path: ${file}`,
-                `# part: ${part}/${fragments.length}`,
-                "",
-                fragment,
-            ].join("\n");
-            await writeFile(path.join(input.runDir, ...patchPath.split("/")), artifact, "utf8");
-            reviewHunks.push({
-                path: file,
-                patchPath,
-                sha256: createHash("sha256").update(artifact).digest("hex"),
-                bytes: Buffer.byteLength(artifact),
-                part,
-                parts: fragments.length,
-            });
-        }
-    }
-    const reviewIndexPath = "contracts/frontend-review-diff-index.json";
-    await writeDagRunJsonArtifact(input.runDir, reviewIndexPath, {
-        schemaVersion: 1,
-        schemaId: FRONTEND_REVIEW_DIFF_INDEX_SCHEMA_ID,
-        patchSha256,
-        hunks: reviewHunks,
-        untrackedFiles,
-    });
-    const reviewSummaryPath = "artifacts/diff_summary.md";
-    await writeFile(path.join(input.runDir, ...reviewSummaryPath.split("/")), buildReviewDiffSummary({
-        patchSha256,
-        patchBytes: Buffer.byteLength(patchText),
-        hunks: reviewHunks,
-        untrackedFiles,
-    }), "utf8");
     const payload = {
         schemaVersion: 1,
         schemaId: FRONTEND_WORKTREE_DIFF_SCHEMA_ID,
         patchPath: relativePatch,
         patchSha256,
-        reviewSummaryPath,
-        reviewIndexPath,
         changedFiles,
         untrackedFiles,
         empty: changedFiles.length === 0 && untrackedFiles.length === 0,
@@ -373,8 +177,6 @@ export async function runFrontendWorktreeDiffGate(input) {
         patchPath: relativePatch,
         patchAbsolutePath: absolutePatch,
         patchSha256,
-        reviewSummaryPath,
-        reviewIndexPath,
         changedFiles,
         untrackedFiles,
         empty: payload.empty,
@@ -387,8 +189,6 @@ export function formatFrontendWorktreeDiffStdout(result) {
         `schemaId=${result.schemaId}`,
         `patchPath=${result.patchPath}`,
         `patchSha256=${result.patchSha256}`,
-        `reviewSummaryPath=${result.reviewSummaryPath}`,
-        `reviewIndexPath=${result.reviewIndexPath}`,
         `changedFiles=${result.changedFiles.length}`,
         `untrackedFiles=${result.untrackedFiles.length}`,
         `empty=${result.empty ? "true" : "false"}`,
@@ -399,36 +199,3 @@ export function formatFrontendWorktreeDiffStdout(result) {
         .filter(Boolean)
         .join("\n");
 }
-/**
- * Expand glob-shaped contract paths into concrete workspace file paths.
- *
- * The frontend contract schema allows `targets.files` entries such as
- * `src/**` (skeleton inherits the task allowedPaths), but writer admission
- * derives the concrete writeSet and requires real file paths. This helper
- * matches every candidate against the enumerated workspace files and returns
- * the concrete paths. Candidates that are already concrete are kept as-is;
- * globs that match nothing are dropped (the derived writeSet only contains
- * paths the writer can actually touch).
- */
-export function expandFrontendGlobPaths(input) {
-    const concrete = new Set();
-    const patterns = [];
-    for (const candidate of input.candidates) {
-        const normalized = candidate.replace(/\\/g, "/");
-        if (normalized.includes("*")) {
-            patterns.push(normalized);
-        }
-        else {
-            concrete.add(normalized);
-        }
-    }
-    if (patterns.length === 0)
-        return [...concrete].sort();
-    const workspace = [...new Set(input.workspaceFiles.map((f) => f.replace(/\\/g, "/")))];
-    for (const file of workspace) {
-        if (patterns.some((pattern) => pathMatchesPattern(file, pattern))) {
-            concrete.add(file);
-        }
-    }
-    return [...concrete].sort();
-}

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

@@ -370,6 +370,38 @@ async function inspectPath(repoRoot, relPath, deps) {
         throw error;
     }
 }
+/**
+ * Build the CAS attempt side of a rollback journal from the current worktree.
+ * This is used by high-risk artifact continuations, where the baseline is
+ * captured before the child starts and the complete attempt inventory is
+ * derived after the child settles (including changes from dynamic writers).
+ */
+export async function recordWriterAttemptFromCurrent(snapshot, options) {
+    const deps = resolveDeps(options.dependencies);
+    const working = structuredClone(snapshot);
+    const baselineByPath = new Map(working.existingFiles.map((file) => [file.path, file]));
+    const currentMatches = [];
+    await walkMatchingEntries(options.repoRoot, "", working.writeSet, deps, (match) => currentMatches.push(match));
+    const candidatePaths = new Set([
+        ...baselineByPath.keys(),
+        ...currentMatches.map((match) => match.relPath),
+    ]);
+    const attemptChangedPaths = [];
+    const attemptFileHashes = {};
+    for (const relPath of [...candidatePaths].sort((left, right) => left.localeCompare(right))) {
+        const baseline = baselineByPath.get(relPath);
+        const current = await inspectPath(options.repoRoot, relPath, deps);
+        const currentHash = current.kind === "absent" ? "absent" : current.hash;
+        const baselineHash = baseline?.baselineSha256 ?? "absent";
+        if (currentHash === baselineHash)
+            continue;
+        attemptChangedPaths.push(relPath);
+        attemptFileHashes[relPath] = currentHash;
+    }
+    working.attemptChangedPaths = attemptChangedPaths;
+    working.attemptFileHashes = attemptFileHashes;
+    return frontendWriterRollbackV1Schema.parse(working);
+}
 function ensureJournalFile(working, relPath, baselineSha256, attemptSha256) {
     let file = working.journal.files[relPath];
     if (!file) {