@tea-agent/loop-agent 0.39.1 → 0.40.0-next.10

package/dist/executors/pi-writer-tool-policy.js

@@ -154,6 +154,28 @@ function assertMkdirRelative(relative, ctx) {
         throw new PiWriterPathDeniedError("forbidden", relative || ".");
     }
 }
+export async function assertReadablePath(targetPath, ctx) {
+    const raw = String(targetPath ?? "").trim();
+    if (!raw)
+        throw new PiWriterPathDeniedError("empty-path", targetPath ?? "");
+    const repoRoot = path.resolve(ctx.repoRoot);
+    const absoluteTarget = path.isAbsolute(raw)
+        ? path.resolve(raw)
+        : path.resolve(repoRoot, raw);
+    if (!isPathInside(repoRoot, absoluteTarget)) {
+        throw new PiWriterPathDeniedError("outside-repo", raw);
+    }
+    const effective = await resolveEffectiveMutationTarget(repoRoot, absoluteTarget);
+    const relative = repoRelativePath(repoRoot, absoluteTarget, raw, false);
+    const effectiveRelative = repoRelativePath(effective.realRoot, effective.absoluteTarget, raw, false);
+    const readSet = ctx.readSet ?? [];
+    for (const candidate of [relative, effectiveRelative]) {
+        if (readSet.length === 0 || !matchesAnyPattern(candidate, readSet)) {
+            throw new PiWriterPathDeniedError("read-outside-read-set", candidate, "path is outside the node readSet");
+        }
+    }
+    return relative;
+}
 /**
  * Assert a mutation target is writable under the DAG writer policy.
  * Returns the normalized lexical repo-relative path on success.
@@ -201,11 +223,30 @@ export async function assertMkdirPath(dirPath, ctx) {
     assertMkdirRelative(effectiveRelative, ctx);
     return lexicalRelative;
 }
+export function createPiReaderFsOperations(ctx) {
+    return {
+        readFile: async (absolutePath) => {
+            await assertReadablePath(absolutePath, ctx);
+            return fsReadFile(absolutePath);
+        },
+        access: async (absolutePath) => {
+            await assertReadablePath(absolutePath, ctx);
+            await fsAccess(absolutePath);
+        },
+    };
+}
 /** Build FS operations that enforce writer policy before mutations. */
 export function createPiWriterFsOperations(ctx) {
+    const strictReadSet = (ctx.readSet?.length ?? 0) > 0;
     return {
-        readFile: (absolutePath) => fsReadFile(absolutePath),
+        readFile: async (absolutePath) => {
+            if (strictReadSet)
+                await assertReadablePath(absolutePath, ctx);
+            return fsReadFile(absolutePath);
+        },
         access: async (absolutePath) => {
+            if (strictReadSet)
+                await assertReadablePath(absolutePath, ctx);
             await fsAccess(absolutePath);
         },
         writeFile: async (absolutePath, content) => {
@@ -218,6 +259,20 @@ export function createPiWriterFsOperations(ctx) {
         },
     };
 }
+export async function createPiReaderCustomTools(ctx) {
+    const sdk = (await import("@earendil-works/pi-coding-agent"));
+    const createReadToolDefinition = sdk.createReadToolDefinition;
+    if (typeof createReadToolDefinition !== "function") {
+        throw new Error("pi read tool policy unavailable: createReadToolDefinition missing from SDK");
+    }
+    const read = createReadToolDefinition(path.resolve(ctx.repoRoot), {
+        operations: createPiReaderFsOperations(ctx),
+    });
+    if (read?.name !== "read") {
+        throw new Error("pi read tool policy unavailable: SDK tool must be named read");
+    }
+    return [read];
+}
 /**
  * Create same-name custom edit/write tool definitions that override built-ins
  * via Pi SDK customTools registration. Fails closed when SDK factories are missing.
@@ -262,5 +317,6 @@ export function buildPiWriterToolPolicyContext(input) {
         writeSet: input.writeSet ?? [],
         forbiddenPaths: input.forbiddenPaths ?? [],
         writePolicy: input.writePolicy ?? "exclusive",
+        readSet: input.readSet ?? [],
     };
 }

package/dist/executors/shell-executor.js

@@ -41,6 +41,7 @@ import { computeL5ReportMetrics } from "../workflows/dag/l5-report-metrics.js";
 import { buildBackendTestCanonicalResultFromInitialShellSnippet, materializeBackendTestClassification, } from "../workflows/dag/backend-test-classification-contract.js";
 import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview, } from "../workflows/dag/backend-test-semantic-review-contract.js";
 import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { captureWorkspaceWriteSnapshot, diffWorkspaceWriteSnapshots, } from "./workspace-write-snapshot.js";
 import { parseAndValidateFinalWriteSetApproval, } from "../workflows/dag/node-execution.js";
 import { buildShellProcessEnv } from "./shell-verification.js";
 import { readRunState } from "../workflows/dag/run-store.js";
@@ -539,13 +540,22 @@ async function executeBackendTestPipeline(input, meta) {
     const started = Date.now();
     // Plan A: prefer the frozen layout carried by the compiled spec; fall back
     // to the historical default for hand-written legacy DAGs.
-    const backendLayout = resolveBackendTestLayout(meta.spec.backendTestLayout
+    const baseBackendLayout = resolveBackendTestLayout(meta.spec.backendTestLayout
         ? {
             testRoot: meta.spec.backendTestLayout.testRoot,
             markdownRel: meta.spec.backendTestLayout.markdownRel,
             scriptRel: meta.spec.backendTestLayout.scriptRel,
         }
         : undefined);
+    const markdownPlanArtifact = path.join(meta.runDir, "generate-backend-md-plan-pi", "plan.md");
+    const backendLayout = existsSync(markdownPlanArtifact)
+        ? {
+            ...baseBackendLayout,
+            readmePath: path
+                .relative(input.cwd, markdownPlanArtifact)
+                .replaceAll(path.sep, "/"),
+        }
+        : baseBackendLayout;
     try {
         if (!pipeline)
             throw new Error("missing backend-test pipeline id");
@@ -915,6 +925,7 @@ async function executeBackendTestPipeline(input, meta) {
                 effective = await materializeEffectiveBackendPytestCollection({
                     workspaceRoot: input.cwd,
                     initial,
+                    layout: backendLayout,
                 });
             }
             else if (initial.status === "REPAIRABLE") {
@@ -974,6 +985,7 @@ async function executeBackendTestPipeline(input, meta) {
                     workspaceRoot: input.cwd,
                     initial,
                     final: finalFacts,
+                    layout: backendLayout,
                 });
             }
             else {
@@ -1036,6 +1048,7 @@ async function executeBackendTestPipeline(input, meta) {
                 scenarioParamRepairAttempt: scenarioFacts.repairAttempt,
                 eligibility,
                 eligibilityInputHashes,
+                layout: backendLayout,
             });
             return {
                 ok: true,
@@ -1144,7 +1157,7 @@ async function executeBackendTestPipeline(input, meta) {
         }
         else if (pipeline === "markdown-execute-html") {
             const executionReadiness = await readBackendTestExecutionReadiness(path.join(meta.runDir, "contracts", "backend-test-execution-readiness.json"));
-            await assertBackendTestExecutionReadinessFresh(input.cwd, executionReadiness);
+            await assertBackendTestExecutionReadinessFresh(input.cwd, executionReadiness, backendLayout);
             const mappedScripts = await collectBackendTestMappedPytestScripts(input.cwd, backendLayout);
             let eligibleItemIds = executionReadiness.eligibleItemIds;
             // Plan D gap-fill executeScope=affected: when a gap plan exists in
@@ -1719,6 +1732,33 @@ async function executeBackendTestPipeline(input, meta) {
     }
 }
 async function executeBackendTestPipelineWithWriteGuard(input, meta) {
+    if (meta.spec.backendTestWorkspaceControl === "filesystem-only") {
+        const paths = input.task.writeSet ?? input.task.allowedPaths;
+        let beforeSnapshot;
+        try {
+            beforeSnapshot = await captureWorkspaceWriteSnapshot({ rootCwd: input.cwd, paths });
+        }
+        catch (error) {
+            return { ok: false, stdout: "", stderr: `workspace filesystem baseline unavailable: ${error instanceof Error ? error.message : String(error)}`, failureCategory: "write-guard", durationMs: 0 };
+        }
+        const result = await executeBackendTestPipeline(input, meta);
+        try {
+            const afterSnapshot = await captureWorkspaceWriteSnapshot({ rootCwd: input.cwd, paths });
+            const guard = validateShellWriteGuard({
+                changedPaths: diffWorkspaceWriteSnapshots(beforeSnapshot, afterSnapshot),
+                writePolicy: input.task.writePolicy,
+                writeSet: input.task.writeSet,
+                allowedPaths: input.task.allowedPaths,
+                forbiddenPaths: input.task.forbiddenPaths,
+            });
+            if (!guard.ok)
+                return { ...result, ok: false, stderr: [result.stderr, `filesystem write guard failed: ${guard.violations.join(", ")}`].filter(Boolean).join("\n\n"), failureCategory: "write-guard" };
+            return result;
+        }
+        catch (error) {
+            return { ...result, ok: false, stderr: [result.stderr, `filesystem write guard failed: ${error instanceof Error ? error.message : String(error)}`].filter(Boolean).join("\n\n"), failureCategory: "write-guard" };
+        }
+    }
     let beforeStatus;
     try {
         beforeStatus = await readGitStatusPorcelain(input.cwd);

package/dist/executors/workspace-write-snapshot.js

@@ -0,0 +1,68 @@
+import { createHash } from "node:crypto";
+import { lstat, readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { pathMatchesPattern } from "../shared/git-progress.js";
+const normalize = (value) => value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+function rootBeforeWildcard(pattern) {
+    const value = normalize(pattern);
+    const wildcard = value.search(/[?*]/);
+    if (wildcard < 0)
+        return path.posix.dirname(value);
+    const prefix = value.slice(0, wildcard);
+    return prefix.slice(0, prefix.lastIndexOf("/")) || ".";
+}
+async function walk(rootCwd, relative, files) {
+    let entries;
+    try {
+        entries = await readdir(path.resolve(rootCwd, relative), { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if ([".git", ".harness", "node_modules"].includes(entry.name))
+            continue;
+        const child = normalize(path.posix.join(relative, entry.name));
+        if (entry.isDirectory())
+            await walk(rootCwd, child, files);
+        else if (entry.isFile())
+            files.add(child);
+    }
+}
+export async function captureWorkspaceWriteSnapshot(input) {
+    const candidates = new Set();
+    for (const pattern of input.paths) {
+        await walk(input.rootCwd, rootBeforeWildcard(pattern), candidates);
+        if (!/[?*]/.test(pattern)) {
+            try {
+                if ((await lstat(path.resolve(input.rootCwd, pattern))).isFile())
+                    candidates.add(normalize(pattern));
+            }
+            catch { /* absent target */ }
+        }
+    }
+    const files = {};
+    let totalBytes = 0;
+    for (const relative of [...candidates].filter((file) => input.paths.some((pattern) => pathMatchesPattern(file, pattern))).sort()) {
+        if (Object.keys(files).length >= 20_000)
+            throw new Error("workspace snapshot file limit exceeded");
+        const absolute = path.resolve(input.rootCwd, relative);
+        const stat = await lstat(absolute);
+        if (!stat.isFile())
+            throw new Error(`workspace snapshot encountered non-regular file: ${relative}`);
+        totalBytes += stat.size;
+        if (totalBytes > 64 * 1024 * 1024)
+            throw new Error("workspace snapshot byte limit exceeded");
+        files[relative] = { size: stat.size, sha256: createHash("sha256").update(await readFile(absolute)).digest("hex") };
+    }
+    const body = JSON.stringify(files);
+    return { schemaVersion: 1, controlMode: "filesystem-only", files, sha256: createHash("sha256").update(body).digest("hex") };
+}
+export function diffWorkspaceWriteSnapshots(before, after) {
+    const paths = new Set([...Object.keys(before.files), ...Object.keys(after.files)]);
+    return [...paths].sort().filter((file) => {
+        const left = before.files[file];
+        const right = after.files[file];
+        return !left || !right || left.size !== right.size || left.sha256 !== right.sha256;
+    });
+}

package/dist/infrastructure/harness/atomic-write.js

@@ -2,6 +2,29 @@ import { copyFile, mkdir, readFile, rename, unlink, writeFile } from "node:fs/pr
 import path from "node:path";
 import { assertHarnessWriteAllowed, } from "./completed-facts-guard.js";
 let atomicWriteSequence = 0;
+function isTransientJsonReadError(error) {
+    if (error instanceof SyntaxError)
+        return true;
+    if (!error || typeof error !== "object" || !("code" in error))
+        return false;
+    const code = String(error.code ?? "");
+    return code === "EBUSY" || code === "EPERM" || code === "EACCES";
+}
+export async function readJsonWithTransientRetry(targetPath, options = {}) {
+    const attempts = Math.max(1, Math.floor(options.attempts ?? 6));
+    const delayMs = Math.max(0, Math.floor(options.delayMs ?? 20));
+    for (let attempt = 1; attempt <= attempts; attempt += 1) {
+        try {
+            return JSON.parse(await readFile(targetPath, "utf-8"));
+        }
+        catch (error) {
+            if (attempt === attempts || !isTransientJsonReadError(error))
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, delayMs * attempt));
+        }
+    }
+    throw new Error("unreachable transient JSON read state");
+}
 async function writeAtomic(targetPath, content, options) {
     assertHarnessWriteAllowed(targetPath, options);
     const resolved = options?.repoRoot && !path.isAbsolute(targetPath)

package/dist/task/config-types.js

@@ -147,6 +147,8 @@ export const backendTestConfigSchema = z
     gapDoc: z.string().min(1).optional(),
     /** gap-fill pytest execution scope: only affected items (default) or all eligible. */
     executeScope: z.enum(["affected", "all"]).optional(),
+    /** Backend-test-only workspace mutation control; omitted means Git guard. */
+    workspaceControl: z.enum(["git", "filesystem-only"]).optional(),
 })
     .strict()
     .optional();
@@ -237,5 +239,13 @@ export const taskConfigSchema = z.preprocess((raw) => {
     if ("executor" in obj || "cursorModel" in obj) {
         throw new Error(CURSOR_TASK_FIELD_REMOVED_ERROR);
     }
+    const backendTest = obj.backendTest;
+    if (backendTest &&
+        typeof backendTest === "object" &&
+        !Array.isArray(backendTest) &&
+        "workspaceControl" in backendTest &&
+        obj.taskKind !== "backend-test") {
+        throw new Error("backendTest.workspaceControl is only valid when taskKind is backend-test");
+    }
     return raw;
 }, taskConfigObjectSchema);

package/dist/worker/console/chat/chat-event-store.js

@@ -231,6 +231,10 @@ export function projectCompactSnapshot(value) {
         Number.isFinite(record.tokensBefore)
         ? Math.max(0, Math.floor(record.tokensBefore))
         : undefined;
+    const estimatedTokensAfter = typeof record.estimatedTokensAfter === "number" &&
+        Number.isFinite(record.estimatedTokensAfter)
+        ? Math.max(0, Math.floor(record.estimatedTokensAfter))
+        : undefined;
     const details = record.details === undefined
         ? undefined
         : boundedRedactedJson(record.details).preview;
@@ -239,9 +243,16 @@ export function projectCompactSnapshot(value) {
         summary,
         ...(firstKeptEntryId ? { firstKeptEntryId } : {}),
         ...(tokensBefore !== undefined ? { tokensBefore } : {}),
+        ...(estimatedTokensAfter !== undefined ? { estimatedTokensAfter } : {}),
         ...(details ? { details } : {}),
         previewHash: createHash("sha256")
-            .update(JSON.stringify({ summary, firstKeptEntryId, tokensBefore, details }))
+            .update(JSON.stringify({
+            summary,
+            firstKeptEntryId,
+            tokensBefore,
+            estimatedTokensAfter,
+            details,
+        }))
             .digest("hex"),
     };
 }
@@ -433,6 +444,20 @@ function safeSessionId(sessionId) {
  * Link durable Chat refs to the existing canonical operation store/event ring.
  * This owns no operation state and schedules no work; it only projects facts.
  */
+/** R8 AC-R8-001: operationIds whose operation-ref has been overshadowed by
+ *  a later operation-unlinked tombstone in the same ring. A tombstoned
+ *  association must never be restored by recoverSession / replay / fork. */
+function tombstonedOperationIds(events) {
+    const tombstones = new Set();
+    for (const event of events) {
+        if (event.kind !== "operation-unlinked")
+            continue;
+        const operationId = event.data.operationId;
+        if (typeof operationId === "string" && operationId)
+            tombstones.add(operationId);
+    }
+    return tombstones;
+}
 export function createChatOperationLinker(options) {
     const followers = new Map();
     const keyFor = (sessionId, operationId) => `${sessionId}\u0000${operationId}`;
@@ -535,14 +560,37 @@ export function createChatOperationLinker(options) {
     }
     return {
         link,
+        async unlink(input) {
+            // Idempotent removal (AC-R7-001): drop the live follower and the
+            // persisted operation-ref event so the association is truly gone.
+            const key = keyFor(input.sessionId, input.operationId);
+            followers.get(key)?.();
+            followers.delete(key);
+            const ring = options.chatEvents.snapshot(input.sessionId);
+            const refs = ring.filter((event) => event.kind === "operation-ref" &&
+                event.data.operationId ===
+                    input.operationId);
+            for (const event of refs) {
+                options.chatEvents.append(input.sessionId, event.turnId, {
+                    kind: "operation-unlinked",
+                    data: { operationId: input.operationId, unlinkedAt: new Date().toISOString() },
+                });
+            }
+            return refs.length > 0;
+        },
         async recoverSession(sessionId) {
-            const refs = options.chatEvents
-                .snapshot(sessionId)
-                .filter((event) => event.kind === "operation-ref");
+            const snapshot = options.chatEvents.snapshot(sessionId);
+            // R8 AC-R8-001: a tombstoned (unlinked) operationId must NOT be
+            // re-linked on recovery — the persisted operation-unlinked event
+            // overshadows any earlier operation-ref in the same ring.
+            const tombstones = tombstonedOperationIds(snapshot);
+            const refs = snapshot.filter((event) => event.kind === "operation-ref");
             for (const event of refs) {
                 const data = event.data;
                 if (!data.operationId || !data.toolCallId)
                     continue;
+                if (tombstones.has(data.operationId))
+                    continue;
                 await link({
                     sessionId,
                     turnId: event.turnId,
@@ -566,6 +614,19 @@ export function createChatOperationLinker(options) {
         },
     };
 }
+/** R8 AC-R8-001 (fork): same tombstone scan as the linker — kept local to
+ *  the store so forkContextRefs needs no linker dependency. */
+function forkTombstonedOperationIds(events) {
+    const tombstones = new Set();
+    for (const event of events) {
+        if (event.kind !== "operation-unlinked")
+            continue;
+        const operationId = event.data.operationId;
+        if (typeof operationId === "string" && operationId)
+            tombstones.add(operationId);
+    }
+    return tombstones;
+}
 export function createChatEventStore(options) {
     const maxEvents = options?.maxEventsPerSession ?? DEFAULT_MAX_EVENTS;
     const maxBytes = options?.maxBytesPerSession ?? DEFAULT_MAX_BYTES;
@@ -735,13 +796,22 @@ export function createChatEventStore(options) {
                 "assessment",
                 "taskKind-confirmed",
                 "human-gate-card",
+                "compaction_end",
                 "compact",
                 "artifact-ref",
             ]);
             let copiedCount = 0;
-            for (const event of this.snapshot(input.sourceSessionId)) {
+            const source = this.snapshot(input.sourceSessionId);
+            // R8 AC-R8-001: fork excludes tombstoned associations — an unlinked
+            // operationId must not leak its operation-ref into a forked session.
+            const tombstones = forkTombstonedOperationIds(source);
+            for (const event of source) {
                 if (!allowed.has(event.kind))
                     continue;
+                if ((event.kind === "operation-ref" ||
+                    event.kind === "operation-status") &&
+                    tombstones.has(event.data.operationId ?? ""))
+                    continue;
                 const data = structuredClone(event.data);
                 if (event.kind === "human-gate-card") {
                     delete data.humanGateToken;

package/dist/worker/console/chat/context-panel.js

@@ -38,6 +38,13 @@ export function projectTaskContext(input) {
             const previous = gates.get(card.cardId);
             gates.set(card.cardId, safeGate({ ...card, ...(previous?.dagSpine && !card.dagSpine ? { dagSpine: previous.dagSpine } : {}) }));
         }
+        else if (event.kind === "operation-unlinked") {
+            // R8 AC-001/AC-R8-001: tombstone — an operation-unlinked event appended
+            // after its operation-ref removes the card from the projection for good.
+            const operationId = typeof data.operationId === "string" ? data.operationId : "";
+            if (operationId)
+                view.operations = view.operations.filter((operation) => operation.operationId !== operationId);
+        }
         else if (event.kind === "operation-ref" || event.kind === "operation-status") {
             const operation = operationFromEventPayload(data);
             if (operation && (!activeTaskId || !operation.taskId || operation.taskId === activeTaskId))

package/dist/worker/console/chat/deferred-turn.js

@@ -81,11 +81,23 @@ export function projectDeferredTurnSummary(deferredTurn) {
         blockedByTurnId: deferredTurn.blockedByTurnId,
         state: deferredTurn.state,
         updatedAt: deferredTurn.updatedAt,
+        text: deferredTurn.text,
         textPreview: deferredTurn.text.replace(/\s+/g, " ").trim().slice(0, 120),
         imageCount: deferredTurn.images.length,
+        images: structuredClone(deferredTurn.images),
         ...(deferredTurn.acceptedTurnId
             ? { acceptedTurnId: deferredTurn.acceptedTurnId }
             : {}),
         ...(deferredTurn.lastError ? { lastError: deferredTurn.lastError } : {}),
     };
 }
+export function parseDeferredTurns(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => parseDeferredTurn(item))
+        .filter((item) => item !== undefined);
+}
+export function projectDeferredTurnSummaries(deferredTurns) {
+    return deferredTurns.map((item) => projectDeferredTurnSummary(item));
+}