@tea-agent/loop-agent 0.27.1-beta.2 → 0.28.0

package/dist/commands/init.js

@@ -6,7 +6,7 @@ import { isDeepStrictEqual } from "node:util";
 import { fileURLToPath } from "node:url";
 import { isInitRuntimeActive, } from "../shared/runtime-activity.js";
 import { loadHarnessManifest } from "../governance/harness.js";
-import { OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH, applyPiRetryMerge, buildOpenCodeTransientRetryPluginSource, inspectPiRetryConfig, parseClientRecoveryMode, runClientRecovery, } from "./client-recovery.js";
+import { OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH, OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH, PI_CONTEXT_OVERFLOW_EXTENSION_PATH, applyPiRetryMerge, buildOpenCodeContextOverflowCompactPluginSource, buildOpenCodeTransientRetryPluginSource, buildPiContextOverflowExtensionSource, inspectPiRetryConfig, parseClientRecoveryMode, runClientRecovery, } from "./client-recovery.js";
 const MANAGED_BLOCK_START = "<!-- LOOP_AGENT_INIT_START -->";
 const MANAGED_BLOCK_END = "<!-- LOOP_AGENT_INIT_END -->";
 const GITIGNORE_BLOCK_START = "# LOOP_AGENT_INIT_START";
@@ -1243,6 +1243,8 @@ function inferInitSurfaceMode(relativePath) {
     }
     if (relativePath === "harness.json" ||
         relativePath === OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH ||
+        relativePath === OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH ||
+        relativePath === PI_CONTEXT_OVERFLOW_EXTENSION_PATH ||
         relativePath.startsWith("scripts/") ||
         relativePath.startsWith(".harness/prompts/") ||
         relativePath.startsWith("docs/README.md") ||
@@ -1293,6 +1295,12 @@ async function buildDesiredSurfaceContent(input) {
     if (manifestPath === OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH) {
         return { content: buildOpenCodeTransientRetryPluginSource() };
     }
+    if (manifestPath === OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH) {
+        return { content: buildOpenCodeContextOverflowCompactPluginSource() };
+    }
+    if (manifestPath === PI_CONTEXT_OVERFLOW_EXTENSION_PATH) {
+        return { content: buildPiContextOverflowExtensionSource() };
+    }
     if (manifestPath.startsWith("scripts/")) {
         const scripts = buildInitScriptFiles(input.governanceRoot);
         return { content: scripts[manifestPath] };
@@ -2465,11 +2473,25 @@ export async function initializeLoopAgentProject(options) {
             repoRoot,
             mode: clientRecoveryMode,
         });
-    if (clientRecovery?.plugin.written) {
-        written.push(OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH);
-    }
-    else if (clientRecoveryMode === "off") {
-        skipped.push(OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH);
+    const clientRecoveryPaths = [
+        OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH,
+        OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH,
+        PI_CONTEXT_OVERFLOW_EXTENSION_PATH,
+    ];
+    if (clientRecoveryMode === "off") {
+        for (const recoveryPath of clientRecoveryPaths)
+            skipped.push(recoveryPath);
+    }
+    else if (clientRecovery) {
+        const installResults = [
+            clientRecovery.plugin,
+            clientRecovery.overflowPlugin,
+            clientRecovery.piExtension,
+        ];
+        for (const [index, recoveryPath] of clientRecoveryPaths.entries()) {
+            if (installResults[index]?.written)
+                written.push(recoveryPath);
+        }
     }
     await writeInitSurfaceState({
         repoRoot,
@@ -2562,6 +2584,14 @@ function recommendedNextFor(report) {
         next.push("No init update actions are needed.");
     return next;
 }
+const CLIENT_RECOVERY_SURFACE_PATHS = new Set([
+    OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH,
+    OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH,
+    PI_CONTEXT_OVERFLOW_EXTENSION_PATH,
+]);
+function isClientRecoverySurfacePath(pathName) {
+    return CLIENT_RECOVERY_SURFACE_PATHS.has(pathName);
+}
 export async function checkInitUpdate(input) {
     const repoRoot = path.resolve(input.repoRoot);
     const { projectName, governanceRoot } = await resolveInitProjectContext({
@@ -2569,6 +2599,8 @@ export async function checkInitUpdate(input) {
         projectName: input.projectName,
         governanceRoot: input.governanceRoot,
     });
+    const clientRecoveryMode = input.clientRecovery ?? "auto";
+    const skipClientRecoverySurfaces = clientRecoveryMode === "off";
     const recordedState = await readExistingSurfaceState(repoRoot);
     const assetRoot = await findPackageRoot();
     const surfaceState = recordedState?.stateKind ?? "missing";
@@ -2608,6 +2640,10 @@ export async function checkInitUpdate(input) {
         });
     }
     for (const [pathName, state] of Object.entries(currentState.files)) {
+        // Mirror fresh init: client-recovery=off never reinstalls recovery surfaces.
+        if (skipClientRecoverySurfaces && isClientRecoverySurfacePath(pathName)) {
+            continue;
+        }
         if (state.relationship === "missing-from-target") {
             if (retiredTargetPaths.has(pathName))
                 continue;

package/dist/executors/dag-pi-executor.js

@@ -1,8 +1,11 @@
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
 import { writeDagNodeJsonArtifact, writeTextArtifactFile, } from "../infrastructure/harness/artifact-store.js";
 import { executePiStep, } from "./pi-executor.js";
 import { buildPiWriterToolPolicyContext, createPiWriterCustomTools, } from "./pi-writer-tool-policy.js";
+import { cleanupPlaywrightCliDefaultSession, createPlaywrightCliTool, PI_COMMAND_CAPABILITY_REGISTRY, resolveCaseIdFromWriteSet, resolveEvidenceDirFromWriteSet, } from "./pi-playwright-cli-tool.js";
+import { dagCommandPolicyAllows, resolveDagCommandPolicy, } from "../workflows/dag/types.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
 import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
@@ -122,12 +125,16 @@ export function resolveDagPiStepName(task) {
     }
     return resolvePiExecutorStep(resolveDagPiPersona(task));
 }
-/** Pi DAG nodes are read-only unless they explicitly opt into the bounded write tool profile. */
 export function resolveDagPiToolNames(task) {
-    if (isDagPiWriteTask(task)) {
-        return [...DAG_PI_WRITE_TOOLS];
-    }
-    return [...DAG_PI_READONLY_TOOLS];
+    if (!isDagPiWriteTask(task))
+        return [...DAG_PI_READONLY_TOOLS];
+    const tools = [...DAG_PI_WRITE_TOOLS];
+    // Pi SDK activates custom tools only when they are in this explicit list.
+    // Do not add a command capability to ordinary writers or read-only nodes.
+    if (dagCommandPolicyAllows(task.commandPolicy, "playwright-cli")) {
+        tools.push("playwright_cli");
+    }
+    return tools;
 }
 export function buildDagPiUserMessage(task, persona, step) {
     const role = task.role ?? "unspecified";
@@ -258,6 +265,36 @@ export async function writePiExecutorArtifacts(artifactsDir, input) {
     await writeTextArtifactFile(summaryPath, buildPiResultSummaryMarkdown(input));
     return { promptPath, summaryPath };
 }
+async function resolveControllerOwnedFrontendBaseUrl(runDir) {
+    const capabilityPath = path.join(runDir, "preflight-frontend-browser-tool-shell", "frontend-browser-capability.json");
+    let capability;
+    try {
+        capability = JSON.parse(await readFile(capabilityPath, "utf8"));
+    }
+    catch {
+        throw new Error("browser-command-capability-unavailable: missing controller-owned frontend browser capability artifact");
+    }
+    if (capability.status !== "ready" ||
+        typeof capability.baseUrl !== "string") {
+        throw new Error("browser-command-capability-unavailable: invalid controller-owned frontend browser capability artifact");
+    }
+    let parsed;
+    try {
+        parsed = new URL(capability.baseUrl);
+    }
+    catch {
+        throw new Error("browser-command-capability-unavailable: invalid controller-owned frontend browser origin");
+    }
+    if ((parsed.protocol !== "http:" && parsed.protocol !== "https:") ||
+        parsed.username ||
+        parsed.password ||
+        parsed.search ||
+        parsed.hash ||
+        /(?:^|\.)(?:www\.)?[^.]*(?:prod|production)/i.test(parsed.hostname)) {
+        throw new Error("browser-command-capability-unavailable: unsafe controller-owned frontend browser origin");
+    }
+    return parsed.toString();
+}
 const DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES = {
     readGitStatusPorcelain,
     recoverRootNulArtifact,
@@ -315,52 +352,120 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         }
         : undefined;
     let writerToolPolicy;
-    if (isWriteTask) {
+    const commandPolicy = resolveDagCommandPolicy(input.task.commandPolicy);
+    const allowsPlaywrightCli = dagCommandPolicyAllows(input.task.commandPolicy, "playwright-cli");
+    let playwrightToolContext;
+    if (allowsPlaywrightCli && !isWriteTask) {
+        return {
+            ok: false, stdout: "", stderr: "pi command capability requires an explicit bounded write tool profile", failureCategory: "tool-policy", durationMs: Date.now() - started,
+        };
+    }
+    if (isWriteTask || allowsPlaywrightCli) {
         try {
-            const policyContext = buildPiWriterToolPolicyContext({
-                repoRoot: input.cwd,
-                allowedPaths: input.task.allowedPaths,
-                writeSet: input.task.writeSet,
-                forbiddenPaths: input.task.forbiddenPaths,
-                writePolicy: input.task.writePolicy,
-            });
-            const customTools = await createPiWriterCustomTools(policyContext);
-            writerToolPolicy = { requireSdk: true, customTools };
+            const customTools = [];
+            if (isWriteTask) {
+                const policyContext = buildPiWriterToolPolicyContext({
+                    repoRoot: input.cwd,
+                    allowedPaths: input.task.allowedPaths,
+                    writeSet: input.task.writeSet,
+                    forbiddenPaths: input.task.forbiddenPaths,
+                    writePolicy: input.task.writePolicy,
+                });
+                customTools.push(...(await createPiWriterCustomTools(policyContext)));
+            }
+            if (commandPolicy.mode === "capability-allowlist") {
+                for (const capability of commandPolicy.capabilities) {
+                    const factory = PI_COMMAND_CAPABILITY_REGISTRY[capability];
+                    if (!factory) {
+                        throw new Error(`unknown command capability: ${capability}`);
+                    }
+                    if (capability === "playwright-cli") {
+                        const caseId = resolveCaseIdFromWriteSet(input.task.writeSet) ??
+                            input.task.id;
+                        const evidenceDir = resolveEvidenceDirFromWriteSet(input.task.writeSet) ??
+                            `testcase/frontend/evidence/${caseId}`;
+                        playwrightToolContext = {
+                            repoRoot: input.cwd,
+                            runDir: meta.runDir,
+                            nodeId: input.task.id,
+                            caseId,
+                            evidenceDir,
+                            baseUrl: await resolveControllerOwnedFrontendBaseUrl(meta.runDir),
+                            inputRoot: "testcase/frontend/fixtures",
+                        };
+                        // Cleanup must be confirmed before a new case; otherwise default-session
+                        // isolation is unknown and no Pi invocation is permitted.
+                        const preCleanup = await cleanupPlaywrightCliDefaultSession(playwrightToolContext, undefined, "pre-start");
+                        if (!preCleanup.ok) {
+                            throw new Error(`browser-command-capability-unavailable: pre-start cleanup failed (${preCleanup.errorClass ?? "unknown"})`);
+                        }
+                        customTools.push(await createPlaywrightCliTool(playwrightToolContext));
+                    }
+                    else {
+                        customTools.push(await factory(playwrightToolContext));
+                    }
+                }
+            }
+            if (customTools.length > 0) {
+                writerToolPolicy = { requireSdk: true, customTools };
+            }
         }
         catch (error) {
             return {
                 ok: false,
                 stdout: "",
-                stderr: `pi writer tool policy unavailable before Pi execution: ${error instanceof Error ? error.message : String(error)}`,
+                stderr: `pi writer/command tool policy unavailable before Pi execution: ${error instanceof Error ? error.message : String(error)}`,
                 failureCategory: "tool-policy",
                 durationMs: Date.now() - started,
             };
         }
     }
-    const result = await piStepFn({
-        attachedFiles: [],
-        modelConfig: resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined),
-        prompt: input.prompt,
-        repoRoot: input.cwd,
-        step,
-        toolNames: resolveDagPiToolNames(input.task),
-        userMessage: buildDagPiUserMessage(input.task, persona, step),
-        sessionEventsPath: path.join(meta.runDir, input.task.id, "session-events.jsonl"),
-        // Absolute max wall clock from adaptive liveness policy (defaults to 4h).
-        timeoutMs: input.timeoutMs,
-        stallTimeoutMs: input.stallTimeoutMs,
-        abortGraceMs: input.abortGraceMs,
-        ...(writerToolPolicy ? { writerToolPolicy } : {}),
-        onActivity: bridgeActivity
-            ? (activity) => {
-                if (activity.kind === "lease" ||
-                    activity.kind === "synthetic-heartbeat") {
-                    return;
+    let result;
+    try {
+        result = await piStepFn({
+            attachedFiles: [],
+            modelConfig: resolveDagPiModelConfig(input.model, input.thinking ? { thinking: input.thinking } : undefined),
+            prompt: input.prompt,
+            repoRoot: input.cwd,
+            step,
+            toolNames: resolveDagPiToolNames(input.task),
+            userMessage: buildDagPiUserMessage(input.task, persona, step),
+            sessionEventsPath: path.join(meta.runDir, input.task.id, "session-events.jsonl"),
+            // Absolute max wall clock from adaptive liveness policy (defaults to 4h).
+            timeoutMs: input.timeoutMs,
+            stallTimeoutMs: input.stallTimeoutMs,
+            abortGraceMs: input.abortGraceMs,
+            ...(writerToolPolicy ? { writerToolPolicy } : {}),
+            onActivity: bridgeActivity
+                ? (activity) => {
+                    if (activity.kind === "lease" ||
+                        activity.kind === "synthetic-heartbeat") {
+                        return;
+                    }
+                    bridgeActivity(activity.kind, activity.at);
                 }
-                bridgeActivity(activity.kind, activity.at);
+                : undefined,
+        });
+    }
+    catch (error) {
+        if (playwrightToolContext) {
+            try {
+                await cleanupPlaywrightCliDefaultSession(playwrightToolContext, undefined, "post-execution");
             }
-            : undefined,
-    });
+            catch {
+                // best-effort
+            }
+        }
+        throw error;
+    }
+    if (playwrightToolContext) {
+        try {
+            await cleanupPlaywrightCliDefaultSession(playwrightToolContext, undefined, "post-execution");
+        }
+        catch {
+            // best-effort controller cleanup must not mask the primary result
+        }
+    }
     const context = {
         channel: "dag",
         cwd: input.cwd,
@@ -576,19 +681,32 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
 export function validateWriterImplementationOutcome(text, changedFiles) {
     const parsed = parseWriterImplementationOutcome(text);
     const diagnostics = writerOutcomeDiagnostics(text, parsed, changedFiles.length);
-    // The workspace diff is authoritative. The model outcome is advisory and
-    // may be missing, malformed, or inconsistent without blocking a completed
-    // writer. An explicit blocked signal remains a hard failure.
-    if (parsed.candidates.some((candidate) => candidate.outcome === "blocked")) {
+    if (parsed.kind !== "valid") {
         return {
             ok: false,
-            reason: `writer outcome validation failed: explicit blocked outcome; ${diagnostics}`,
+            reason: `writer outcome validation failed: ${parsed.kind} outcome; ${diagnostics}; expected IMPLEMENTATION_OUTCOME: changed, IMPLEMENTATION_OUTCOME: already-satisfied, or IMPLEMENTATION_OUTCOME: blocked`,
         };
     }
-    return {
-        ok: true,
-        outcome: changedFiles.length > 0 ? "changed" : "already-satisfied",
-    };
+    const outcome = parsed.outcome;
+    if (outcome === "blocked") {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: IMPLEMENTATION_OUTCOME: blocked cannot complete successfully; ${diagnostics}`,
+        };
+    }
+    if (outcome === "changed" && changedFiles.length === 0) {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: changed outcome has an empty diff; ${diagnostics}`,
+        };
+    }
+    if (outcome === "already-satisfied" && changedFiles.length > 0) {
+        return {
+            ok: false,
+            reason: `writer outcome validation failed: already-satisfied outcome has a non-empty diff; ${diagnostics}`,
+        };
+    }
+    return { ok: true, outcome };
 }
 function parseWriterImplementationOutcome(text) {
     const lines = text.split(/\r?\n/);
@@ -719,15 +837,6 @@ function normalizeProtocolLine(line, firstProtocolLine, nextLine) {
         const value = normalizedProtocolValue(direct[1] ?? "");
         return value ? `${firstProtocolLine} ${value}` : undefined;
     }
-    // Writers sometimes place a short delivery sentence before the protocol
-    // line. Accept the protocol token when it appears inline, while preserving
-    // the candidate value so template repetitions still fail as unknown or
-    // conflicting outcomes.
-    const inline = normalizedLine.match(new RegExp(`${labelPattern}\\s*[:：]\\s*(.+)$`, "i"));
-    if (inline) {
-        const value = normalizedProtocolValue(inline[1] ?? "");
-        return value ? `${firstProtocolLine} ${value}` : undefined;
-    }
     const splitValue = normalizedLine.match(new RegExp(`^${labelPattern}\\s*[:：]?\\s*$`, "i"));
     if (splitValue && nextLine !== undefined) {
         const value = normalizedProtocolValue(nextLine);