@tea-agent/loop-agent 0.39.0-beta.1 → 0.39.0-beta.11

package/dist/worker/console/workspace-registry.js

@@ -0,0 +1,214 @@
+/**
+ * User-level Workspace Registry (2026-08-22 multi-workspace foundation, W1).
+ *
+ * Persists the set of registered Console workspaces at
+ * `<appDataRoot>/workspaces.json` (user level, shared across Console boots),
+ * independent of per-repo fingerprint namespaces.
+ *
+ * Invariants:
+ *   - workspaceId is stable per normalized realpath: it is derived from
+ *     sha256("loop-console-workspace-v1\0" + realpath) and never minted twice.
+ *   - REMOVE is soft (hidden=true); on-disk directories, AppData namespaces,
+ *     Sessions, Operations and DAGs are never deleted.
+ *   - Re-adding a previously removed workspace RESTORES the original record
+ *     (same workspaceId + repoFingerprint; only lastAccessedAt advances).
+ *   - Duplicate visible realpath is rejected; add failures leave the registry
+ *     byte-identical (same ids and order).
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson, } from "./app-data.js";
+import { normalizeWorktreeRealpath, repoFingerprintV1, } from "./repo-fingerprint.js";
+export const WORKSPACE_REGISTRY_SCHEMA_VERSION = 1;
+/** Stable workspaceId: sha256("loop-console-workspace-v1\0" + normalizedRealpath). */
+export function workspaceIdForRealpath(normalizedRealpath) {
+    return createHash("sha256")
+        .update(`loop-console-workspace-v1\0${normalizedRealpath}`, "utf8")
+        .digest("hex");
+}
+export class WorkspaceRegistry {
+    appData;
+    options;
+    file;
+    cache;
+    constructor(appData, options = {}) {
+        this.appData = appData;
+        this.options = options;
+        this.file = path.join(appData.root, "workspaces.json");
+    }
+    /** Auto-register the startup repoRoot (idempotent). */
+    async ensureStartupWorkspace(repoRoot) {
+        const record = await this.add(repoRoot);
+        if (record.ok)
+            return record.record;
+        // Startup root may already be visible (duplicate) or previously hidden —
+        // re-adding a hidden record restores it via add(); the only expected
+        // failure left is DUPLICATE (already visible), which returns the existing.
+        const existing = await this.findByRealpath(repoRoot);
+        if (existing)
+            return existing;
+        throw new Error(`workspace registry: startup root rejected: ${record.code}`);
+    }
+    /**
+     * Register (or restore) a workspace directory.
+     * Failures never mutate the persisted registry.
+     * `options.name` overrides the default directory-name label.
+     */
+    async add(rawPath, options = {}) {
+        const trimmed = rawPath.trim();
+        if (!trimmed) {
+            return {
+                ok: false,
+                code: "INVALID_PATH",
+                message: "path is required",
+            };
+        }
+        let real;
+        try {
+            real = realpathSync(path.resolve(trimmed));
+        }
+        catch {
+            return {
+                ok: false,
+                code: "NOT_A_DIRECTORY",
+                message: `path does not exist: ${trimmed}`,
+            };
+        }
+        let st;
+        try {
+            st = statSync(real);
+        }
+        catch {
+            return {
+                ok: false,
+                code: "UNREADABLE",
+                message: `path is not readable: ${trimmed}`,
+            };
+        }
+        if (!st.isDirectory()) {
+            return {
+                ok: false,
+                code: "NOT_A_DIRECTORY",
+                message: `path is not a directory: ${trimmed}`,
+            };
+        }
+        const normalized = normalizeWorktreeRealpath(real);
+        const existing = await this.findByRealpathNormalized(normalized);
+        if (existing && !existing.hidden) {
+            return {
+                ok: false,
+                code: "DUPLICATE",
+                message: `workspace already registered: ${existing.displayPath}`,
+            };
+        }
+        const nowIso = (this.options.now ?? (() => new Date()))().toISOString();
+        if (existing) {
+            // Restore the soft-removed record; identity (workspaceId,
+            // repoFingerprint, createdAt, order) is preserved.
+            existing.hidden = undefined;
+            existing.lastAccessedAt = nowIso;
+            if (options.name && options.name.trim()) {
+                existing.name = options.name.trim();
+            }
+            const registry = await this.load();
+            await this.persist(registry);
+            return { ok: true, record: existing, registryUnchanged: false };
+        }
+        const record = {
+            workspaceId: workspaceIdForRealpath(normalized),
+            name: options.name?.trim() || path.basename(normalized) || normalized,
+            displayPath: normalized,
+            repoRoot: real,
+            repoFingerprint: repoFingerprintV1(real),
+            createdAt: nowIso,
+            lastAccessedAt: nowIso,
+        };
+        const registry = await this.load();
+        registry.workspaces.push(record);
+        await this.persist(registry);
+        return { ok: true, record, registryUnchanged: false };
+    }
+    /** Visible list in canonical insertion order. */
+    async listVisible() {
+        const registry = await this.load();
+        return registry.workspaces.filter((workspace) => {
+            if (workspace.hidden)
+                return false;
+            try {
+                return statSync(workspace.repoRoot).isDirectory();
+            }
+            catch {
+                // Keep historical registry data, but do not project stale test roots
+                // into the Workspace browser after their directories disappear.
+                return false;
+            }
+        });
+    }
+    async get(workspaceId) {
+        const registry = await this.load();
+        return registry.workspaces.find((w) => w.workspaceId === workspaceId);
+    }
+    /** Get a VISIBLE workspace by id (removed workspaces are not operable). */
+    async getVisible(workspaceId) {
+        const record = await this.get(workspaceId);
+        if (!record || record.hidden)
+            return undefined;
+        try {
+            return statSync(record.repoRoot).isDirectory() ? record : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Soft-remove: hides the record; never touches directories or AppData. */
+    async remove(workspaceId) {
+        const registry = await this.load();
+        const record = registry.workspaces.find((w) => w.workspaceId === workspaceId);
+        if (!record || record.hidden)
+            return false;
+        record.hidden = true;
+        await this.persist(registry);
+        return true;
+    }
+    async findByRealpath(rawPath) {
+        let normalized;
+        try {
+            normalized = normalizeWorktreeRealpath(path.resolve(rawPath.trim()));
+        }
+        catch {
+            return undefined;
+        }
+        return this.findByRealpathNormalized(normalized);
+    }
+    async findByRealpathNormalized(normalized) {
+        const registry = await this.load();
+        return registry.workspaces.find((w) => w.displayPath === normalized);
+    }
+    async load() {
+        if (this.cache)
+            return this.cache;
+        const raw = await readJsonIfExists(this.file).catch(() => undefined);
+        const registry = {
+            schemaVersion: 1,
+            workspaces: raw && Array.isArray(raw.workspaces)
+                ? raw.workspaces.filter((w) => Boolean(w) &&
+                    typeof w === "object" &&
+                    typeof w.workspaceId === "string" &&
+                    typeof w.displayPath === "string" &&
+                    typeof w.repoRoot === "string")
+                : [],
+        };
+        this.cache = registry;
+        return registry;
+    }
+    async persist(registry) {
+        // writeSecureJson is atomic; a reader mid-write sees the previous bytes.
+        await writeSecureJson(this.file, registry);
+        this.cache = registry;
+    }
+}
+/** Deterministic-looking nonce reserved for tests requiring unique roots. */
+export function mintWorkspaceNonce() {
+    return randomBytes(8).toString("hex");
+}

package/dist/worker/loop-agent/loop-agent-client.js

@@ -292,9 +292,13 @@ function assertControllerIdentityUnchangedBeforeSpawn(identity) {
     }
 }
 function controllerIdentityDriftError(message, cause) {
-    return new Error(`controller identity changed before spawn: ${message}`, {
-        cause,
-    });
+    // Preserve the raw drift detail verbatim; the actionable suffix serves
+    // every consumer surface — operation errorMessage, SSE events, and agent/
+    // API callers that never reach the UI translation layer — with the exact
+    // recovery step: the running Console holds a stale controller fingerprint
+    // after rebuilds or commits touching fingerprint-scoped paths
+    // (package.json, bin/**, dist/**, skills/**).
+    return new Error(`controller identity changed before spawn: ${message}. Fix: restart the Console process so it re-resolves the current build, then retry the operation; avoid rebuilding or committing fingerprint-scoped files (package.json, bin/**, dist/**, skills/**) mid-session.`, { cause });
 }
 /**
  * Detect whether loopAgentBin is a Node-like executable and baseArgs

package/dist/worker/materialize/frontend-split-task-materializer.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { computeFrontendSplitDigest } from "../../workflows/dag/frontend-split-orchestrator.js";
+const idSchema = z.string().trim().min(1);
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const positiveIntegerSchema = z.number().int().positive();
+const pathSchema = z.string().trim().min(1);
+export const frontendSplitTaskMaterializationRequestSchema = z.object({
+    kind: z.enum(["child", "integration"]),
+    parentOperationId: idSchema,
+    manifestDigest: digestSchema,
+    generation: positiveIntegerSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+    payloadDigest: digestSchema,
+    allowedPaths: z.array(pathSchema),
+    writeSet: z.array(pathSchema),
+    verifyRefs: z.array(idSchema),
+}).strict();
+export const frontendSplitTaskMaterializationResultSchema = z.object({
+    idempotencyKey: digestSchema,
+    requestDigest: digestSchema,
+    taskId: idSchema,
+    operationId: idSchema,
+}).strict();
+function identityPayload(request) {
+    return { kind: request.kind, parentOperationId: request.parentOperationId, manifestDigest: request.manifestDigest, generation: request.generation, taskId: request.taskId, operationId: request.operationId };
+}
+export class FrontendSplitTaskMaterializer {
+    backend;
+    completed = new Map();
+    inFlight = new Map();
+    constructor(backend) {
+        this.backend = backend;
+    }
+    async materialize(raw) {
+        const request = frontendSplitTaskMaterializationRequestSchema.parse(raw);
+        const idempotencyKey = computeFrontendSplitDigest(identityPayload(request));
+        const requestDigest = computeFrontendSplitDigest(request);
+        const existing = this.completed.get(idempotencyKey);
+        if (existing) {
+            if (existing.requestDigest !== requestDigest)
+                throw new Error("frontend split materialization payload drift");
+            return existing;
+        }
+        const pending = this.inFlight.get(idempotencyKey);
+        if (pending) {
+            const result = await pending;
+            if (result.requestDigest !== requestDigest)
+                throw new Error("frontend split materialization payload drift");
+            return result;
+        }
+        const promise = this.perform(request, idempotencyKey, requestDigest);
+        this.inFlight.set(idempotencyKey, promise);
+        try {
+            const result = await promise;
+            this.completed.set(idempotencyKey, result);
+            return result;
+        }
+        finally {
+            this.inFlight.delete(idempotencyKey);
+        }
+    }
+    async perform(request, idempotencyKey, requestDigest) {
+        const task = await this.backend.ensureTask({ idempotencyKey, taskId: request.taskId, payloadDigest: requestDigest, request });
+        if (!task.complete || task.taskId !== request.taskId)
+            throw new Error("frontend split task materialization incomplete or drifted");
+        const operation = await this.backend.ensureOperation({ idempotencyKey, taskId: request.taskId, operationId: request.operationId, payloadDigest: requestDigest, request });
+        if (!operation.complete || operation.taskId !== request.taskId || operation.operationId !== request.operationId)
+            throw new Error("frontend split operation materialization incomplete or drifted");
+        return frontendSplitTaskMaterializationResultSchema.parse({ idempotencyKey, requestDigest, taskId: request.taskId, operationId: request.operationId });
+    }
+}

package/dist/worker/materialize/harness-task-lineage.js

@@ -129,11 +129,14 @@ export async function resolveRevisionDigestsForTaskSpec(input) {
     };
 }
 /** Union TaskSpec allowed_paths with workflow-owned write roots. */
-export function expandAllowedPathsForWorkflow(workflow, allowedPaths) {
+export function expandAllowedPathsForWorkflow(workflow, allowedPaths, options) {
     const extras = workflow === "backend-test"
         ? ["testcase/**", "docs/test-reports/**"]
         : workflow === "frontend-test"
-            ? ["testcase/frontend/**", "docs/test-reports/**"]
+            ? [
+                `${options?.frontendTestRoot ?? "testcase/frontend"}/**`,
+                "docs/test-reports/**",
+            ]
             : [];
     return Array.from(new Set([...allowedPaths, ...extras]));
 }

package/dist/worker/observability/init-runtime-activity.js

@@ -0,0 +1,26 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { buildGlobalSnapshot } from "./read-model.js";
+/**
+ * Read-only runtime guard shared by Console maintenance and init-surface
+ * writes. Worker activity remains owned by the Observe projection so both
+ * callers use one canonical liveness interpretation.
+ */
+export async function readInitRuntimeActivity(repoRoot) {
+    const resolvedRoot = path.resolve(repoRoot);
+    const activeDagRoot = path.join(resolvedRoot, ".harness", "dag-runs", "active");
+    const entries = await readdir(activeDagRoot, { withFileTypes: true }).catch(() => []);
+    const activeDagRunIds = entries
+        .filter((entry) => entry.isDirectory() && entry.name !== ".gitkeep")
+        .map((entry) => entry.name)
+        .sort();
+    const snapshot = await buildGlobalSnapshot({ repoRoot: resolvedRoot });
+    return {
+        activeDagRunIds,
+        activeWorkerBatches: snapshot.health.worker.activeBatches,
+        activeWorkerTasks: snapshot.health.worker.activeTasks,
+        ...(snapshot.projectionError
+            ? { workerProjectionError: snapshot.projectionError.message }
+            : {}),
+    };
+}

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

@@ -1483,6 +1483,9 @@ function mergeDagRun(existing, incoming) {
         computeDurationMs(startedAt, finishedAt);
     return {
         dagRunId: incoming.dagRunId,
+        ...((incoming.taskId ?? existing.taskId)
+            ? { taskId: incoming.taskId ?? existing.taskId }
+            : {}),
         status: incoming.status ?? existing.status,
         lifecycle: incoming.lifecycle ?? existing.lifecycle,
         executionMode: incoming.executionMode ?? existing.executionMode,
@@ -1914,8 +1917,10 @@ async function parseDagStateFile(statePath, now) {
             }
             : undefined;
         const failureCategory = readString(parsed, "failureCategory");
+        const boundTaskId = await readRunSpecTaskBinding(runSpecPath);
         return {
             dagRunId,
+            ...(boundTaskId ? { taskId: boundTaskId } : {}),
             status,
             ...(lifecycle ? { lifecycle } : {}),
             ...(executionMode ? { executionMode } : {}),
@@ -2435,6 +2440,23 @@ async function safeReadJson(filePath) {
         return undefined;
     return parsed;
 }
+/** Task binding for a DAG run from run.json — same precedence as
+ *  console/resolve-dag-run-for-task (taskContractBinding → sourceBinding →
+ *  Hybrid DAG title). */
+async function readRunSpecTaskBinding(runSpecPath) {
+    const parsed = await safeReadJson(runSpecPath);
+    if (!parsed)
+        return undefined;
+    const binding = parsed.taskContractBinding;
+    const source = parsed.sourceBinding;
+    const fromBinding = (typeof binding?.taskId === "string" && binding.taskId.trim()) ||
+        (typeof source?.taskId === "string" && source.taskId.trim());
+    if (fromBinding)
+        return fromBinding;
+    const title = typeof parsed.title === "string" ? parsed.title.trim() : "";
+    const hybrid = /^Hybrid DAG:\s*(.+)$/i.exec(title);
+    return hybrid?.[1]?.trim() || undefined;
+}
 function safeParseJson(raw) {
     try {
         const parsed = JSON.parse(raw);

package/dist/worker/observe/node-input.js

@@ -2,7 +2,8 @@ import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
-import { resolveDagNodePromptRedacted, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { resolveDagNodePromptRedacted, resolveDagRunArtifact, resolveDagRunJson, } from "./dag-run-artifacts.js";
+import { namedShellHandlers } from "./shell-handler-keys.js";
 export const NODE_INPUT_SCHEMA_VERSION = 1;
 export const NODE_INPUT_PREVIEW_MAX_BYTES = 64 * 1024;
 const SHELL_GATE_KEYS = [
@@ -30,9 +31,11 @@ function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
         summary: null,
         dependency: null,
         prompt: null,
+        promptCandidates: [],
         executorInput: null,
         boundaries: null,
         promptFingerprint: null,
+        piExtensionRunFacts: null,
         warnings,
     };
 }
@@ -137,7 +140,7 @@ function resolveModelHint(spec, task) {
     }
     return null;
 }
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warnings) {
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings) {
     const defaults = spec.defaults && typeof spec.defaults === "object"
         ? spec.defaults
         : undefined;
@@ -216,6 +219,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
                 : null,
             failFast: typeof shellRaw.failFast === "boolean" ? shellRaw.failFast : null,
             gates: shellGateNames(shellRaw),
+            handlers: namedShellHandlers(shellRaw),
         }
         : null;
     const staticPreview = staticRaw && typeof staticRaw.resultMarkdown === "string"
@@ -264,10 +268,12 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
             maxBytes: promptBody.maxBytes,
             source: promptSource,
         },
+        promptCandidates,
         executorInput: {
             kind,
             skills,
             modelHint: resolveModelHint(spec, task),
+            piExtensions: redactStringList(task.piExtensions),
             shell,
             static: staticBlock,
         },
@@ -284,9 +290,155 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
                 : null,
         },
         promptFingerprint: fingerprint,
+        piExtensionRunFacts,
         warnings,
     };
 }
+async function loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings) {
+    const stateResolved = resolveDagRunArtifact(repoRoot, dagRunId, ["state.json"]);
+    if (!stateResolved.ok)
+        return [];
+    let state;
+    try {
+        state = JSON.parse(await readFile(stateResolved.result.absolutePath, "utf-8"));
+    }
+    catch {
+        warnings.push("state.json could not be read for failed prompt candidates.");
+        return [];
+    }
+    const nodes = state.nodes && typeof state.nodes === "object" && !Array.isArray(state.nodes)
+        ? state.nodes
+        : null;
+    const node = nodes?.[nodeId] &&
+        typeof nodes[nodeId] === "object" &&
+        !Array.isArray(nodes[nodeId])
+        ? nodes[nodeId]
+        : null;
+    if (!node)
+        return [];
+    const failedAttempts = new Set();
+    if (Array.isArray(node.attempts)) {
+        for (const entry of node.attempts) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                continue;
+            const record = entry;
+            if (record.ok === false &&
+                typeof record.attempt === "number" &&
+                Number.isSafeInteger(record.attempt) &&
+                record.attempt > 0) {
+                failedAttempts.add(record.attempt);
+            }
+        }
+    }
+    if (node.status === "ERROR" &&
+        typeof node.currentAttempt === "number" &&
+        Number.isSafeInteger(node.currentAttempt) &&
+        node.currentAttempt > 0) {
+        failedAttempts.add(node.currentAttempt);
+    }
+    const candidates = [];
+    for (const attempt of [...failedAttempts].sort((a, b) => a - b)) {
+        const fileName = `prompt-candidate-attempt-${attempt}.json`;
+        const artifact = path.posix.join(nodeId, fileName);
+        const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [nodeId, fileName]);
+        if (!resolved.ok) {
+            warnings.push(`Failed prompt candidate missing for attempt ${attempt}.`);
+            continue;
+        }
+        try {
+            const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+            if (raw.schemaVersion !== 1 ||
+                raw.attempt !== attempt ||
+                typeof raw.failureCategory !== "string" ||
+                typeof raw.prompt !== "string" ||
+                typeof raw.truncated !== "boolean" ||
+                typeof raw.maxBytes !== "number" ||
+                !Number.isSafeInteger(raw.maxBytes) ||
+                raw.maxBytes < 1 ||
+                raw.maxBytes > NODE_INPUT_PREVIEW_MAX_BYTES ||
+                typeof raw.sha256 !== "string" ||
+                !/^([a-f0-9]{64})$/.test(raw.sha256)) {
+                throw new Error("invalid candidate schema");
+            }
+            const prompt = truncatedField(raw.prompt, raw.maxBytes);
+            candidates.push({
+                attempt,
+                failureCategory: redactSecrets(raw.failureCategory),
+                prompt: prompt.text,
+                truncated: raw.truncated || prompt.truncated,
+                maxBytes: raw.maxBytes,
+                sha256Prefix: raw.sha256.slice(0, 12),
+                artifact,
+            });
+        }
+        catch {
+            warnings.push(`Failed prompt candidate is invalid for attempt ${attempt}.`);
+        }
+    }
+    return candidates;
+}
+/**
+ * Load run-time Pi extension facts from <node>/pi-extensions.json (plan
+ * 2026-08-22 R2). Returns null when the node declares no piExtensions
+ * (no expected artifact). Never throws: unreadable/corrupt artifacts degrade
+ * to parseError stubs so the node-input endpoint stays 200.
+ */
+async function loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declared, warnings) {
+    if (declared.length === 0)
+        return null;
+    const artifact = path.posix.join(nodeId, "pi-extensions.json");
+    const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [
+        nodeId,
+        "pi-extensions.json",
+    ]);
+    if (!resolved.ok) {
+        if (resolved.reason === "ambiguous") {
+            warnings.push("Ambiguous pi-extensions.json lifecycle copies.");
+        }
+        return {
+            artifact,
+            exists: false,
+            requested: [...declared],
+            resolved: [],
+            missing: [],
+        };
+    }
+    const empty = {
+        artifact,
+        exists: false,
+        requested: [...declared],
+        resolved: [],
+        missing: [],
+    };
+    try {
+        const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+        const resolvedList = Array.isArray(raw.resolved) ? raw.resolved : [];
+        const missingList = Array.isArray(raw.missing) ? raw.missing : [];
+        const projected = resolvedList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            packageName: redactSecrets(String(entry.packageName ?? "")),
+            version: redactSecrets(String(entry.version ?? "")),
+        }));
+        const missingProjected = missingList
+            .filter((entry) => Boolean(entry) && typeof entry === "object" && !Array.isArray(entry))
+            .map((entry) => ({
+            id: redactSecrets(String(entry.id ?? "")),
+            reason: redactSecrets(String(entry.reason ?? "")),
+        }));
+        return {
+            artifact,
+            exists: true,
+            requested: redactStringList(raw.requested ?? declared),
+            resolved: projected,
+            missing: missingProjected,
+        };
+    }
+    catch {
+        return { ...empty, parseError: "read-failed" };
+    }
+}
 async function loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings) {
     const resolved = resolveDagNodePromptRedacted(repoRoot, dagRunId, nodeId);
     if (!resolved.ok) {
@@ -415,8 +567,13 @@ export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
     }
     const warnings = [];
     const fingerprint = await loadPromptFingerprint(repoRoot, dagRunId, nodeId, warnings);
+    const declaredPiExtensions = Array.isArray(task.piExtensions)
+        ? task.piExtensions.filter((item) => typeof item === "string")
+        : [];
+    const piExtensionRunFacts = await loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declaredPiExtensions, warnings);
+    const promptCandidates = await loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings);
     // Reject unknown nested leakage by projecting only through allowlist helpers.
-    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, warnings);
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings);
     // Defense-in-depth: ensure raw task never sneaks in.
     if ("task" in body) {
         return {