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

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

@@ -77,6 +77,44 @@ export async function checkPiSdkAvailability(_repoRoot) {
         return { ok: false, detail: `pi SDK not available: ${message}` };
     }
 }
+/** Fail-closed probe for the SDK-only structured custom-tool surface. */
+export async function checkPiSdkCustomToolCapability(_repoRoot) {
+    if (sdkSessionFactoryOverride) {
+        return {
+            ok: true,
+            detail: "pi SDK custom-tool session factory override active",
+        };
+    }
+    try {
+        const imported = sdkImportOverrideForTests
+            ? await sdkImportOverrideForTests()
+            : await loadPiSdkModule();
+        const sdk = imported;
+        const { Type } = await import("typebox");
+        const ModelRuntime = sdk.ModelRuntime;
+        if (typeof sdk.createAgentSession !== "function" ||
+            typeof sdk.getAgentDir !== "function" ||
+            typeof ModelRuntime?.create !== "function" ||
+            typeof sdk.defineTool !== "function" ||
+            typeof Type?.Object !== "function") {
+            return {
+                ok: false,
+                detail: "pi SDK custom-tool capability incompatible: requires createAgentSession, getAgentDir, ModelRuntime.create, defineTool, and typebox Type.Object",
+            };
+        }
+        return {
+            ok: true,
+            detail: "pi SDK structured custom-tool capability available",
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            detail: `pi SDK custom-tool capability unavailable: ${message}`,
+        };
+    }
+}
 async function resolveModel(modelRuntime, provider, modelId) {
     const fromRuntime = modelRuntime.getModel(provider, modelId);
     if (fromRuntime)
@@ -159,6 +197,24 @@ async function createSdkSession(sdk, input, shared) {
             ? { customTools: input.customTools }
             : {}),
     });
+    const customToolNames = (input.customTools ?? [])
+        .map((tool) => isRecord(tool) && typeof tool.name === "string" ? tool.name : undefined)
+        .filter((name) => Boolean(name));
+    if (customToolNames.length > 0) {
+        const activeTools = created.session.agent?.state?.tools;
+        if (!Array.isArray(activeTools)) {
+            throw new Error("pi SDK session does not expose agent.state.tools; refusing unverifiable custom-tool activation");
+        }
+        const activeNames = new Set(activeTools
+            .map((tool) => typeof tool?.name === "string" ? tool.name : undefined)
+            .filter((name) => Boolean(name)));
+        for (const customToolName of customToolNames) {
+            const expectedActive = input.toolNames.includes(customToolName);
+            if (activeNames.has(customToolName) !== expectedActive) {
+                throw new Error(`pi SDK custom-tool activation mismatch for ${customToolName}: expectedActive=${expectedActive}`);
+            }
+        }
+    }
     return created.session;
 }
 /**

package/dist/executors/playwright-cli-launcher.js

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+const PACKAGE_NAME = "@playwright/cli";
+function launcherFromManifest(manifestPath) {
+    try {
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+        if (manifest.name !== PACKAGE_NAME)
+            return undefined;
+        const bin = typeof manifest.bin === "string"
+            ? manifest.bin
+            : manifest.bin && typeof manifest.bin === "object"
+                ? manifest.bin["playwright-cli"]
+                : undefined;
+        if (typeof bin !== "string" || !bin || path.isAbsolute(bin) || bin.split(/[\\/]+/).includes(".."))
+            return undefined;
+        const packageRoot = path.dirname(manifestPath);
+        const entryPath = path.resolve(packageRoot, bin);
+        const relative = path.relative(packageRoot, entryPath);
+        if (relative.startsWith("..") || path.isAbsolute(relative) || !existsSync(entryPath))
+            return undefined;
+        return { executable: process.execPath, argvPrefix: [entryPath], entryPath };
+    }
+    catch {
+        return undefined;
+    }
+}
+function candidateManifestPaths(cwd) {
+    const paths = new Set();
+    for (const root of [cwd, process.cwd()]) {
+        try {
+            paths.add(createRequire(path.join(path.resolve(root), "package.json")).resolve(`${PACKAGE_NAME}/package.json`));
+        }
+        catch {
+            // Keep searching controller-known module roots.
+        }
+    }
+    // Npm's Windows/global shim is paired with node_modules in either the shim
+    // directory or its parent (.bin). We read package metadata directly; the
+    // .cmd file itself is never executed or parsed as a command string.
+    for (const binDir of (process.env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
+        paths.add(path.join(binDir, "node_modules", ...PACKAGE_NAME.split("/"), "package.json"));
+        paths.add(path.join(binDir, "..", ...PACKAGE_NAME.split("/"), "package.json"));
+    }
+    return [...paths];
+}
+/** Resolve only a package-declared entry; throws instead of falling back to a PATH executable. */
+export function resolvePlaywrightCliLauncher(cwd) {
+    for (const manifestPath of candidateManifestPaths(cwd)) {
+        const launcher = launcherFromManifest(manifestPath);
+        if (launcher)
+            return launcher;
+    }
+    throw new Error("playwright-cli-unavailable: verified @playwright/cli JavaScript entry was not found");
+}
+export function checkPlaywrightCliLauncher(cwd) {
+    try {
+        return { ok: true, launcher: resolvePlaywrightCliLauncher(cwd) };
+    }
+    catch (error) {
+        return { ok: false, detail: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/executors/shell-executor.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -6,6 +7,10 @@ import { writeDagNodeJsonArtifact, writeDagNodeTextArtifact, } from "../infrastr
 import { captureWorkspaceCheckpoint } from "../workflows/dag/workspace-checkpoint.js";
 import { truncateOutput } from "../shared/output-truncation.js";
 import { processTreeSpawnOptions, terminateProcessTree, } from "./process-tree.js";
+import { createPlaywrightCliTool, defaultPlaywrightCliCommandRunner, } from "./pi-playwright-cli-tool.js";
+import { resolvePiBackend } from "./pi-executor.js";
+import { checkPiSdkCustomToolCapability } from "./pi-sdk-executor.js";
+import { resolvePlaywrightCliLauncher } from "./playwright-cli-launcher.js";
 import { buildRequirementCoverageGateShellCommand, expandShellPreset, buildVerdictGateShellCommand, } from "./shell-presets.js";
 import { materializeBackendTestAnalysisContract } from "../workflows/dag/backend-test-analysis-contract.js";
 import { extractBackendTestContractEnvelope } from "../workflows/dag/backend-test-contract-envelope.js";
@@ -32,6 +37,7 @@ import { backendTestSemanticReviewSchema, materializeBackendTestSemanticReview,
 import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { buildShellProcessEnv } from "./shell-verification.js";
 import { readRunState } from "../workflows/dag/run-store.js";
+import { resolveDagTaskSourcePath } from "../task/dag-source-paths.js";
 import { readProjectGovernanceContext } from "../workflows/dag/project-governance-context.js";
 import { assertMavenPlanFresh, MavenPlanStaleError, } from "../verification/maven/index.js";
 /** In-memory same-run success cache. Never shared across runIds. */
@@ -138,6 +144,56 @@ export function resolveShellCwd(root, requestedCwd) {
     }
     return resolved;
 }
+async function resolveControllerFrontendBaseUrlForPreflight(input) {
+    const binding = input.spec.sourceBinding;
+    const candidates = (binding?.sources ?? []).filter((source) => /(?:^|\/)config\.md$/i.test(source.path));
+    let rawBaseUrl = "http://localhost:5173";
+    let baseUrlSource = "default-localhost-5173";
+    let baseUrlSourceSha256;
+    for (const source of candidates) {
+        const absolutePath = resolveDagTaskSourcePath({
+            workspaceRoot: input.workspaceRoot,
+            taskId: binding.taskId,
+            sourcePath: source.path,
+        });
+        const markdown = await readFile(absolutePath, "utf8");
+        const actualSha256 = createHash("sha256").update(markdown).digest("hex");
+        if (actualSha256 !== source.sha256) {
+            throw new Error(`browser-command-capability-unavailable: stale frontend source ${source.path}`);
+        }
+        const match = markdown.match(/(?:frontend[_-]?base[_-]?url|base[_-]?url|base[- ]url)\s*[:=]\s*["'`]?((?:https?):\/\/[^\s"'`<>]+)/i);
+        if (!match?.[1]) {
+            if (/(?:frontend[_-]?base[_-]?url|base[_-]?url|base[- ]url)\s*[:=]/i.test(markdown)) {
+                throw new Error(`browser-command-capability-unavailable: invalid controller baseUrl from ${source.path}`);
+            }
+            continue;
+        }
+        rawBaseUrl = match[1].replace(/[)\]},.;]+$/, "");
+        baseUrlSource = source.path;
+        baseUrlSourceSha256 = source.sha256;
+        break;
+    }
+    let parsed;
+    try {
+        parsed = new URL(rawBaseUrl);
+    }
+    catch {
+        throw new Error(`browser-command-capability-unavailable: invalid controller baseUrl from ${baseUrlSource}`);
+    }
+    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 baseUrl from ${baseUrlSource}`);
+    }
+    return {
+        baseUrl: parsed.toString(),
+        baseUrlSource,
+        ...(baseUrlSourceSha256 ? { baseUrlSourceSha256 } : {}),
+    };
+}
 async function resolveJsonArtifactSourceNodeId(input) {
     const candidates = [
         input.fromNodeId,
@@ -1671,6 +1727,78 @@ async function executeFrontendLintBaseline(input, meta) {
 }
 export async function executeDagShellNode(input, meta) {
     const shell = input.task.shell;
+    if (shell?.frontendBrowserToolPreflight) {
+        const started = Date.now();
+        try {
+            if (resolvePiBackend() === "cli-only") {
+                throw new Error("browser-command-capability-unavailable: CODE_AGENT_PI_BACKEND=cli-only rejects SDK-only playwright_cli");
+            }
+            const sdkCapability = await checkPiSdkCustomToolCapability(input.cwd);
+            if (!sdkCapability.ok) {
+                throw new Error(`browser-command-capability-unavailable: ${sdkCapability.detail}`);
+            }
+            const controllerOrigin = await resolveControllerFrontendBaseUrlForPreflight({
+                workspaceRoot: input.cwd,
+                spec: meta.spec,
+            });
+            const toolProbe = await createPlaywrightCliTool({
+                repoRoot: input.cwd,
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                caseId: "frontend-browser-preflight",
+                evidenceDir: "testcase/frontend/evidence/frontend-browser-preflight",
+                baseUrl: controllerOrigin.baseUrl,
+                inputRoot: "testcase/frontend/fixtures",
+            });
+            if (toolProbe.name !== "playwright_cli") {
+                throw new Error("browser-command-capability-unavailable: structured playwright_cli tool registration failed");
+            }
+            const launcher = resolvePlaywrightCliLauncher(input.cwd);
+            const result = await defaultPlaywrightCliCommandRunner({
+                executable: launcher.executable,
+                argv: [...launcher.argvPrefix, "--help"],
+                cwd: input.cwd,
+                timeoutMs: 30_000,
+                env: { ...process.env, CI: process.env.CI ?? "1" },
+            });
+            const help = `${result.stdout}\n${result.stderr}`;
+            if (result.exitCode !== 0 ||
+                result.timedOut ||
+                !["open", "close", "snapshot", "click"].every((command) => new RegExp(`\\b${command}\\b`, "i").test(help))) {
+                throw new Error("playwright-cli-contract-incompatible");
+            }
+            const capability = {
+                schemaVersion: 1,
+                status: "ready",
+                tool: "playwright-cli",
+                launcher: "verified-js-entry",
+                sdkCustomToolCapability: true,
+                structuredToolName: toolProbe.name,
+                baseUrl: controllerOrigin.baseUrl,
+                baseUrlSource: controllerOrigin.baseUrlSource,
+                ...(controllerOrigin.baseUrlSourceSha256
+                    ? { baseUrlSourceSha256: controllerOrigin.baseUrlSourceSha256 }
+                    : {}),
+            };
+            await writeDagNodeJsonArtifact(meta.runDir, input.task.id, "frontend-browser-capability.json", capability);
+            return {
+                ok: true,
+                stdout: JSON.stringify(capability),
+                stderr: "",
+                failureCategory: "success",
+                durationMs: Date.now() - started,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                stdout: "",
+                stderr: `playwright-cli-unavailable: ${error instanceof Error ? error.message : String(error)}`,
+                failureCategory: "tool-policy",
+                durationMs: Date.now() - started,
+            };
+        }
+    }
     if (shell?.frontendPrewriteGate) {
         const started = Date.now();
         try {

package/dist/shared/playwright-cli-command-policy.js

@@ -0,0 +1,41 @@
+/**
+ * Neutral command-policy source shared by the structured Pi runtime and
+ * pre-execution frontend case checklist. Keep this list capability-only: argv
+ * and browser-safety validation remain owned by the executor.
+ */
+export const PLAYWRIGHT_CLI_ALLOWED_COMMANDS = [
+    "open",
+    "close",
+    "goto",
+    "snapshot",
+    "find",
+    "click",
+    "dblclick",
+    "fill",
+    "type",
+    "press",
+    "keydown",
+    "keyup",
+    "hover",
+    "select",
+    "check",
+    "uncheck",
+    "drag",
+    "drop",
+    "upload",
+    "go-back",
+    "go-forward",
+    "reload",
+    "dialog-accept",
+    "dialog-dismiss",
+    "resize",
+    "screenshot",
+    "pdf",
+    "console",
+    "requests",
+    "request",
+];
+const allowedCommandSet = new Set(PLAYWRIGHT_CLI_ALLOWED_COMMANDS);
+export function isPlaywrightCliCommand(value) {
+    return allowedCommandSet.has(value);
+}

package/dist/worker/observability/read-model.js

@@ -722,6 +722,7 @@ const ACTIVE_EFFECTIVE_STATUSES = new Set([
     "needs-attention",
     "remote-unknown",
     "pending",
+    "paused",
 ]);
 const TERMINAL_RUN_STATUSES = new Set([
     "finished",
@@ -730,13 +731,51 @@ const TERMINAL_RUN_STATUSES = new Set([
     "superseded",
     "abandoned",
 ]);
+const NON_EXECUTION_MODES = new Set(["dry-run", "init-only"]);
+const SHELL_NODE_STATUSES = new Set(["pending", "queued"]);
+function hasDagExecutionEvidence(dag) {
+    const status = (dag.status ?? "").toLowerCase();
+    if (status === "running" || status === "started" || status === "paused") {
+        return true;
+    }
+    return (dag.nodes ?? []).some((node) => {
+        const nodeStatus = (node.status ?? "").toLowerCase();
+        return nodeStatus.length > 0 && !SHELL_NODE_STATUSES.has(nodeStatus);
+    });
+}
 /**
- * Server-side mirror of app.js isDagRunActive. Derives DAG-run activeness from
- * already-loaded DagRunSummary facts without touching app.js or new files.
+ * Unified overview-active matrix (isOverviewActive). Shared contract with
+ * Observe UI `isDagRunActive` — default total view only shows real execution.
  */
 function isDagRunActiveForHealth(dag) {
+    const executionMode = (dag.executionMode ?? "").toLowerCase();
+    if (NON_EXECUTION_MODES.has(executionMode))
+        return false;
+    const lifecycle = (dag.lifecycle ?? "").toLowerCase();
+    if (NON_EXECUTION_MODES.has(lifecycle))
+        return false;
+    if (lifecycle === "completed")
+        return false;
+    if (dag.effectiveStatus &&
+        TERMINAL_RUN_STATUSES.has(dag.effectiveStatus)) {
+        return false;
+    }
+    // Real execute pause remains overview-visible (AC-003).
+    if (lifecycle === "paused" || dag.effectiveStatus === "paused") {
+        return true;
+    }
+    if (["orphaned", "stale"].includes((dag.liveness ?? "").toLowerCase())) {
+        return false;
+    }
     if (dag.effectiveStatus &&
         ACTIVE_EFFECTIVE_STATUSES.has(dag.effectiveStatus)) {
+        // Legacy active+pending shells without execution evidence are not active.
+        if (!executionMode &&
+            dag.effectiveStatus === "pending" &&
+            !hasDagExecutionEvidence(dag)) {
+            return false;
+        }
+        // execute-mode pending (or any non-legacy execute) stays visible.
         return true;
     }
     // Only "unknown" (and absent) means liveness evidence is insufficient;
@@ -745,14 +784,20 @@ function isDagRunActiveForHealth(dag) {
     if (dag.effectiveStatus && dag.effectiveStatus !== "unknown")
         return false;
     const status = (dag.status ?? "").toLowerCase();
-    if ((dag.lifecycle ?? "").toLowerCase() === "paused")
-        return false;
-    if (["orphaned", "stale"].includes((dag.liveness ?? "").toLowerCase()))
-        return false;
     if (TERMINAL_RUN_STATUSES.has(status))
         return false;
-    if (["running", "pending", "started"].includes(status))
+    if (executionMode === "execute") {
+        if (["running", "pending", "started", "paused"].includes(status)) {
+            return true;
+        }
+        return (dag.nodes ?? []).some((node) => isNodeStatusActive(node.status));
+    }
+    // Historical runs without executionMode: require real execution evidence.
+    if (status === "running" || status === "started")
         return true;
+    if (status === "pending" || status === "") {
+        return hasDagExecutionEvidence(dag);
+    }
     return (dag.nodes ?? []).some((node) => isNodeStatusActive(node.status));
 }
 function isNodeStatusActive(status) {
@@ -769,6 +814,9 @@ function isNodeStatusActive(status) {
     ].includes(normalized)) {
         return false;
     }
+    // pending/queued alone are not enough for overview active without mode/evidence.
+    if (SHELL_NODE_STATUSES.has(normalized))
+        return false;
     return true;
 }
 function computeDagHealth(dagRuns) {
@@ -1276,6 +1324,7 @@ function mergeDagRun(existing, incoming) {
         dagRunId: incoming.dagRunId,
         status: incoming.status ?? existing.status,
         lifecycle: incoming.lifecycle ?? existing.lifecycle,
+        executionMode: incoming.executionMode ?? existing.executionMode,
         liveness: incoming.liveness ?? existing.liveness,
         effectiveStatus: incoming.effectiveStatus ?? existing.effectiveStatus,
         stateConsistent: incoming.stateConsistent ?? existing.stateConsistent,
@@ -1563,11 +1612,19 @@ async function parseDagStateFile(statePath, now) {
         const lifecycleName = path.basename(path.dirname(runDir));
         const lifecycle = lifecycleName === "active" ||
             lifecycleName === "paused" ||
-            lifecycleName === "completed"
+            lifecycleName === "completed" ||
+            lifecycleName === "dry-run" ||
+            lifecycleName === "init-only"
             ? lifecycleName
             : undefined;
         const dagRunId = readString(parsed, "runId") ?? path.basename(runDir);
         const status = readString(parsed, "status");
+        const executionModeRaw = readString(parsed, "executionMode");
+        const executionMode = executionModeRaw === "execute" ||
+            executionModeRaw === "dry-run" ||
+            executionModeRaw === "init-only"
+            ? executionModeRaw
+            : undefined;
         const title = readString(parsed, "title");
         const startedAt = readString(parsed, "startedAt");
         const finishedAt = readString(parsed, "finishedAt");
@@ -1649,6 +1706,7 @@ async function parseDagStateFile(statePath, now) {
             dagRunId,
             status,
             ...(lifecycle ? { lifecycle } : {}),
+            ...(executionMode ? { executionMode } : {}),
             liveness: liveness.status,
             effectiveStatus,
             stateConsistent,

package/dist/worker/observe/static/dag-model.js

@@ -30,29 +30,101 @@ export function dagMetaVisibility(dag) {
 	};
 }
 
+const NON_EXECUTION_MODES = new Set(["dry-run", "init-only"]);
+const SHELL_NODE_STATUSES = new Set(["pending", "queued"]);
+const ACTIVE_EFFECTIVE_STATUSES = new Set([
+	"running",
+	"running-quiet",
+	"running-suspected-stall",
+	"needs-attention",
+	"remote-unknown",
+	"pending",
+	"paused",
+]);
+const TERMINAL_EFFECTIVE_STATUSES = new Set([
+	"finished",
+	"partial_failed",
+	"failed",
+	"superseded",
+	"abandoned",
+]);
+
 function isNodeActive(status) {
 	if (!status) return false;
 	const s = status.toLowerCase();
-	return (
-		s === "running" || s === "started" || s === "pending" || s === "queued"
-	);
+	// pending/queued alone do not prove overview activity without mode/evidence.
+	return s === "running" || s === "started";
 }
 
+function hasDagExecutionEvidence(dag) {
+	const status = (dag?.status ?? "").toLowerCase();
+	if (status === "running" || status === "started" || status === "paused") {
+		return true;
+	}
+	return (dag?.nodes ?? []).some((n) => {
+		const s = (n?.status ?? "").toLowerCase();
+		return s && !SHELL_NODE_STATUSES.has(s);
+	});
+}
+
+/**
+ * Unified overview-active matrix (isOverviewActive).
+ * Default dashboard only lists real execution (incl. paused execute).
+ */
 export function isDagRunActive(dag) {
+	const executionMode = (dag?.executionMode ?? "").toLowerCase();
+	if (NON_EXECUTION_MODES.has(executionMode)) return false;
+
+	const lifecycle = (dag?.lifecycle ?? "").toLowerCase();
+	if (NON_EXECUTION_MODES.has(lifecycle)) return false;
+	if (lifecycle === "completed") return false;
+
 	if (
-		["running", "running-quiet", "remote-unknown", "pending"].includes(
-			dag.effectiveStatus,
-		)
-	)
+		dag?.effectiveStatus &&
+		TERMINAL_EFFECTIVE_STATUSES.has(dag.effectiveStatus)
+	) {
+		return false;
+	}
+
+	// Real execute pause remains overview-visible (AC-003).
+	if (lifecycle === "paused" || dag?.effectiveStatus === "paused") {
 		return true;
-	if (dag.effectiveStatus && dag.effectiveStatus !== "unknown") return false;
-	const status = (dag.status ?? "").toLowerCase();
-	if ((dag.lifecycle ?? "").toLowerCase() === "paused") return false;
-	if (["orphaned", "stale"].includes((dag.liveness ?? "").toLowerCase()))
+	}
+
+	if (["orphaned", "stale"].includes((dag?.liveness ?? "").toLowerCase()))
 		return false;
+
+	if (
+		dag?.effectiveStatus &&
+		ACTIVE_EFFECTIVE_STATUSES.has(dag.effectiveStatus)
+	) {
+		if (
+			!executionMode &&
+			dag.effectiveStatus === "pending" &&
+			!hasDagExecutionEvidence(dag)
+		) {
+			return false;
+		}
+		return true;
+	}
+
+	if (dag?.effectiveStatus && dag.effectiveStatus !== "unknown") return false;
+
+	const status = (dag?.status ?? "").toLowerCase();
 	if (TERMINAL_RUN_STATUSES.has(status)) return false;
-	if (["running", "pending", "started"].includes(status)) return true;
-	return (dag.nodes ?? []).some((n) => isNodeActive(n.status));
+
+	if (executionMode === "execute") {
+		if (["running", "pending", "started", "paused"].includes(status))
+			return true;
+		return (dag?.nodes ?? []).some((n) => isNodeActive(n.status));
+	}
+
+	// Historical runs without executionMode: require real execution evidence.
+	if (status === "running" || status === "started") return true;
+	if (status === "pending" || status === "") {
+		return hasDagExecutionEvidence(dag);
+	}
+	return (dag?.nodes ?? []).some((n) => isNodeActive(n.status));
 }
 
 const DASHBOARD_FEATURE_STATUSES = new Set(["running", "needs_action"]);

package/dist/workflows/dag/dynamic-runtime/loop-until.js

@@ -1,6 +1,7 @@
 import { writeDagRunJsonArtifact } from "../../../infrastructure/harness/artifact-store.js";
 import { executeDagNode, } from "../node-execution.js";
 import { writeRunSpec } from "../run-store.js";
+import { assertValidMaterializedDagTask } from "../validate.js";
 import { freshNodeRecord, lookupPath, parseConditionLiteral, parseJsonFromText, } from "./shared.js";
 function evaluateLoopStopExpression(input) {
     const equality = input.expression.match(/^\s*(\$\..+?)\s*==\s*(.+?)\s*$/);
@@ -38,6 +39,8 @@ export function buildLoopBodyChildTask(input) {
         executor: bodyTask.executor,
         role: bodyTask.role,
         skills: bodyTask.skills,
+        toolProfile: bodyTask.toolProfile,
+        commandPolicy: bodyTask.commandPolicy,
         writePolicy: bodyTask.writePolicy,
         allowedPaths: bodyTask.allowedPaths,
         forbiddenPaths: bodyTask.forbiddenPaths,
@@ -73,6 +76,7 @@ export async function executeDynamicLoopUntil(input) {
             bodyIdMap,
         }));
         for (const child of children) {
+            assertValidMaterializedDagTask(child);
             if (!input.tasksById.has(child.id)) {
                 input.tasksById.set(child.id, child);
                 input.spec.tasks.push(child);