@ryanfw/prompt-orchestration-pipeline 0.9.1 → 0.11.0

package/src/core/symlink-utils.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createLogger } from "./logger.js";
+import { ensureTaskSymlinkBridge } from "./symlink-bridge.js";
 
 const logger = createLogger("SymlinkUtils");
 
@@ -49,6 +50,201 @@ export async function ensureSymlink(linkPath, targetPath, type) {
   }
 }
 
+/**
+ * Validates that required task symlinks exist and point to accessible targets.
+ *
+ * @param {string} taskDir - The task directory containing symlinks
+ * @param {Object} expectedTargets - Expected symlink targets
+ * @param {string} expectedTargets.nodeModules - Expected target for node_modules symlink
+ * @param {string} expectedTargets.taskRoot - Expected target for _task_root symlink
+ * @returns {Object} Validation result with isValid flag and details
+ */
+export async function validateTaskSymlinks(taskDir, expectedTargets) {
+  const startTime = Date.now();
+  const validationErrors = [];
+  const validationDetails = {};
+
+  const symlinksToValidate = [
+    { name: "node_modules", expectedTarget: expectedTargets.nodeModules },
+    { name: "_task_root", expectedTarget: expectedTargets.taskRoot },
+  ];
+
+  for (const { name, expectedTarget } of symlinksToValidate) {
+    const linkPath = path.join(taskDir, name);
+
+    try {
+      // Check if symlink exists
+      const stats = await fs.lstat(linkPath);
+
+      if (!stats.isSymbolicLink()) {
+        validationErrors.push(
+          `${name} exists but is not a symlink (type: ${stats.isFile() ? "file" : "directory"})`
+        );
+        validationDetails[name] = {
+          exists: true,
+          isSymlink: false,
+          targetAccessible: false,
+        };
+        continue;
+      }
+
+      // Read the symlink target
+      const actualTarget = await fs.readlink(linkPath);
+
+      // Check if target matches expected (normalize paths for comparison)
+      const normalizedActual = path.resolve(taskDir, actualTarget);
+      const normalizedExpected = path.resolve(expectedTarget);
+
+      if (normalizedActual !== normalizedExpected) {
+        validationErrors.push(
+          `${name} points to wrong target: expected ${expectedTarget}, got ${actualTarget}`
+        );
+        validationDetails[name] = {
+          exists: true,
+          isSymlink: true,
+          targetAccessible: false,
+          actualTarget,
+          expectedTarget,
+        };
+        continue;
+      }
+
+      // Check if target is accessible
+      const targetStats = await fs.stat(normalizedActual).catch(() => null);
+      if (!targetStats) {
+        validationErrors.push(
+          `${name} target is not accessible: ${actualTarget}`
+        );
+        validationDetails[name] = {
+          exists: true,
+          isSymlink: true,
+          targetAccessible: false,
+          actualTarget,
+        };
+        continue;
+      }
+
+      if (!targetStats.isDirectory()) {
+        validationErrors.push(
+          `${name} target is not a directory: ${actualTarget}`
+        );
+        validationDetails[name] = {
+          exists: true,
+          isSymlink: true,
+          targetAccessible: false,
+          actualTarget,
+          targetType: "file",
+        };
+        continue;
+      }
+
+      // Symlink is valid
+      validationDetails[name] = {
+        exists: true,
+        isSymlink: true,
+        targetAccessible: true,
+        actualTarget,
+      };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        validationErrors.push(`${name} symlink does not exist`);
+        validationDetails[name] = {
+          exists: false,
+          isSymlink: false,
+          targetAccessible: false,
+        };
+      } else {
+        validationErrors.push(`${name} validation failed: ${error.message}`);
+        validationDetails[name] = {
+          exists: false,
+          isSymlink: false,
+          targetAccessible: false,
+          error: error.message,
+        };
+      }
+    }
+  }
+
+  const isValid = validationErrors.length === 0;
+  const duration = Date.now() - startTime;
+
+  logger.debug("Symlink validation completed", {
+    taskDir,
+    isValid,
+    errorsCount: validationErrors.length,
+    duration,
+    details: validationDetails,
+  });
+
+  return {
+    isValid,
+    errors: validationErrors,
+    details: validationDetails,
+    duration,
+  };
+}
+
+/**
+ * Repairs task symlinks by recreating them using the existing symlink bridge.
+ *
+ * @param {string} taskDir - The task directory where symlinks should be created
+ * @param {string} poRoot - The repository root directory
+ * @param {string} taskModulePath - Absolute path to the original task module
+ * @returns {Object} Repair result with success flag and details
+ */
+export async function repairTaskSymlinks(taskDir, poRoot, taskModulePath) {
+  const startTime = Date.now();
+
+  try {
+    logger.log("Repairing task symlinks", {
+      taskDir,
+      poRoot,
+      taskModulePath,
+    });
+
+    // Use existing ensureTaskSymlinkBridge for repairs
+    const relocatedEntry = await ensureTaskSymlinkBridge({
+      taskDir,
+      poRoot,
+      taskModulePath,
+    });
+
+    const duration = Date.now() - startTime;
+
+    logger.log("Task symlinks repaired successfully", {
+      taskDir,
+      duration,
+      relocatedEntry,
+    });
+
+    return {
+      success: true,
+      relocatedEntry,
+      duration,
+      errors: [],
+    };
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const errorMessage = `Failed to repair task symlinks: ${error.message}`;
+
+    logger.error("Task symlink repair failed", {
+      taskDir,
+      poRoot,
+      taskModulePath,
+      duration,
+      error: error.message,
+      stack: error.stack,
+    });
+
+    return {
+      success: false,
+      relocatedEntry: null,
+      duration,
+      errors: [errorMessage],
+    };
+  }
+}
+
 /**
  * Removes task symlinks from a completed job directory to avoid dangling links.
  *

package/src/core/task-runner.js

@@ -4,12 +4,13 @@ import fs from "fs";
 import { createLLM, getLLMEvents } from "../llm/index.js";
 import { loadFreshModule } from "./module-loader.js";
 import { loadEnvironment } from "./environment.js";
-import { createTaskFileIO } from "./file-io.js";
+import { createTaskFileIO, generateLogName } from "./file-io.js";
 import { writeJobStatus } from "./status-writer.js";
 import { computeDeterministicProgress } from "./progress.js";
 import { TaskState } from "../config/statuses.js";
 import { validateWithSchema } from "../api/validators/json.js";
 import { createJobLogger } from "./logger.js";
+import { LogEvent, LogFileExtension } from "../config/log-events.js";
 
 /**
  * Derives model key and token counts from LLM metric event.
@@ -67,13 +68,13 @@ function assertStageResult(stageName, result) {
     );
   }
 
-  if (!result.hasOwnProperty("output")) {
+  if (!Object.prototype.hasOwnProperty.call(result, "output")) {
     throw new Error(
       `Stage "${stageName}" result missing required property: output`
     );
   }
 
-  if (!result.hasOwnProperty("flags")) {
+  if (!Object.prototype.hasOwnProperty.call(result, "flags")) {
     throw new Error(
       `Stage "${stageName}" result missing required property: flags`
     );
@@ -507,7 +508,11 @@ export async function runPipeline(modulePath, initialContext = {}) {
     }
 
     // Add console output capture before stage execution using IO
-    const logName = `stage-${stageName}.log`;
+    const logName = generateLogName(
+      context.meta.taskName,
+      stageName,
+      LogEvent.START
+    );
     const logPath = path.join(context.meta.workDir, "files", "logs", logName);
     console.debug("[task-runner] stage log path resolution via IO", {
       stage: stageName,
@@ -593,7 +598,12 @@ export async function runPipeline(modulePath, initialContext = {}) {
       },
     };
     await context.io.writeLog(
-      `stage-${stageName}-context.json`,
+      generateLogName(
+        context.meta.taskName,
+        stageName,
+        LogEvent.CONTEXT,
+        LogFileExtension.JSON
+      ),
       JSON.stringify(snapshot, null, 2),
       { mode: "replace" }
     );
@@ -696,6 +706,18 @@ export async function runPipeline(modulePath, initialContext = {}) {
         }
       }
 
+      // Add explicit completion log after stage completion
+      const completeLogName = generateLogName(
+        context.meta.taskName,
+        stageName,
+        LogEvent.COMPLETE
+      );
+      await context.io.writeLog(
+        completeLogName,
+        `Stage ${stageName} completed at ${new Date().toISOString()}\n`,
+        { mode: "replace" }
+      );
+
       const ms = +(performance.now() - start).toFixed(2);
       logger.log("Stage completed successfully", {
         stage: stageName,
@@ -729,9 +751,17 @@ export async function runPipeline(modulePath, initialContext = {}) {
           context.meta.workDir,
           "files",
           "logs",
-          `stage-${stageName}.log`
+          generateLogName(context.meta.taskName, stageName, LogEvent.START)
+        ),
+        snapshotPath: path.join(
+          logsDir,
+          generateLogName(
+            context.meta.taskName,
+            stageName,
+            LogEvent.CONTEXT,
+            LogFileExtension.JSON
+          )
         ),
-        snapshotPath: path.join(logsDir, `stage-${stageName}-context.json`),
         dataHasSeed: !!context.data?.seed,
         seedHasData: context.data?.seed?.data !== undefined,
         flagsKeys: Object.keys(context.flags || {}),

package/src/ui/client/adapters/job-adapter.js

@@ -75,6 +75,8 @@ function normalizeTasks(rawTasks) {
           : undefined,
         // Preserve tokenUsage if present
         ...(t && t.tokenUsage ? { tokenUsage: t.tokenUsage } : {}),
+        // Preserve error object if present
+        ...(t && t.error ? { error: t.error } : {}),
       };
       tasks[name] = taskObj;
     });
@@ -106,11 +108,28 @@ function normalizeTasks(rawTasks) {
         ...(typeof t?.failedStage === "string" && t.failedStage.length > 0
           ? { failedStage: t.failedStage }
           : {}),
+        // Prefer new files.* schema, fallback to legacy artifacts
+        files:
+          t && t.files
+            ? {
+                artifacts: Array.isArray(t.files.artifacts)
+                  ? t.files.artifacts.slice()
+                  : [],
+                logs: Array.isArray(t.files.logs) ? t.files.logs.slice() : [],
+                tmp: Array.isArray(t.files.tmp) ? t.files.tmp.slice() : [],
+              }
+            : {
+                artifacts: [],
+                logs: [],
+                tmp: [],
+              },
         artifacts: Array.isArray(t && t.artifacts)
           ? t.artifacts.slice()
           : undefined,
         // Preserve tokenUsage if present
         ...(t && t.tokenUsage ? { tokenUsage: t.tokenUsage } : {}),
+        // Preserve error object if present
+        ...(t && t.error ? { error: t.error } : {}),
       };
     });
     return { tasks, warnings };
@@ -152,7 +171,7 @@ export function adaptJobSummary(apiJob) {
   // Demo-only: read canonical fields strictly
   const id = apiJob.jobId;
   const name = apiJob.title || "";
-  const rawTasks = apiJob.tasks;
+  const rawTasks = apiJob.tasks || apiJob.tasksStatus; // Handle both formats for backward compatibility
   const location = apiJob.location;
 
   // Job-level stage metadata
@@ -221,7 +240,7 @@ export function adaptJobDetail(apiDetail) {
   // Demo-only: read canonical fields strictly
   const id = apiDetail.jobId;
   const name = apiDetail.title || "";
-  const rawTasks = apiDetail.tasks;
+  const rawTasks = apiDetail.tasks || apiDetail.tasksStatus; // Handle both formats for backward compatibility
   const location = apiDetail.location;
 
   // Job-level stage metadata

package/src/ui/client/hooks/useJobDetailWithUpdates.js

@@ -347,6 +347,7 @@ export function useJobDetailWithUpdates(jobId) {
               newEs.addEventListener("job:removed", onJobRemoved);
               newEs.addEventListener("status:changed", onStatusChanged);
               newEs.addEventListener("state:change", onStateChange);
+              newEs.addEventListener("task:updated", onTaskUpdated);
               newEs.addEventListener("error", onError);
 
               esRef.current = newEs;
@@ -373,6 +374,94 @@ export function useJobDetailWithUpdates(jobId) {
             return;
           }
 
+          // Handle task:updated events with task-level merge logic
+          if (type === "task:updated") {
+            const p = payload || {};
+            const { jobId: eventJobId, taskId, task } = p;
+
+            // Filter by jobId
+            if (eventJobId && eventJobId !== jobId) {
+              return;
+            }
+
+            // Validate required fields
+            if (!taskId || !task) {
+              return;
+            }
+
+            startTransition(() => {
+              setData((prev) => {
+                // If no previous data or tasks, return unchanged
+                if (!prev || !prev.tasks) {
+                  return prev;
+                }
+
+                const prevTask = prev.tasks[taskId];
+
+                // Compare observable fields to determine if update is needed
+                const fieldsToCompare = [
+                  "state",
+                  "currentStage",
+                  "failedStage",
+                  "startedAt",
+                  "endedAt",
+                  "attempts",
+                  "executionTimeMs",
+                  "error",
+                ];
+
+                let hasChanged = false;
+
+                // If task doesn't exist yet, always treat as changed
+                if (!prevTask) {
+                  hasChanged = true;
+                } else {
+                  // Compare observable fields to determine if update is needed
+                  for (const field of fieldsToCompare) {
+                    if (prevTask[field] !== task[field]) {
+                      hasChanged = true;
+                      break;
+                    }
+                  }
+
+                  // Also compare tokenUsage and files arrays by reference
+                  if (
+                    prevTask.tokenUsage !== task.tokenUsage ||
+                    prevTask.files !== task.files
+                  ) {
+                    hasChanged = true;
+                  }
+                }
+
+                if (!hasChanged) {
+                  return prev; // No change, preserve identity
+                }
+
+                // Create new tasks map with updated task
+                const nextTasks = { ...prev.tasks, [taskId]: task };
+
+                // Recompute job-level summary fields
+                const taskCount = Object.keys(nextTasks).length;
+                const doneCount = Object.values(nextTasks).filter(
+                  (t) => t.state === "done"
+                ).length;
+                const progress =
+                  taskCount > 0 ? (doneCount / taskCount) * 100 : 0;
+
+                // Return new job object with updated tasks and summary
+                return {
+                  ...prev,
+                  tasks: nextTasks,
+                  doneCount,
+                  taskCount,
+                  progress,
+                  lastUpdated: new Date().toISOString(),
+                };
+              });
+            });
+            return; // Skip generic handling for task:updated
+          }
+
           // Path-matching state:change → schedule debounced refetch
           if (type === "state:change") {
             const d = (payload && (payload.data || payload)) || {};
@@ -415,6 +504,7 @@ export function useJobDetailWithUpdates(jobId) {
       const onStatusChanged = (evt) =>
         handleIncomingEvent("status:changed", evt);
       const onStateChange = (evt) => handleIncomingEvent("state:change", evt);
+      const onTaskUpdated = (evt) => handleIncomingEvent("task:updated", evt);
 
       es.addEventListener("open", onOpen);
       es.addEventListener("job:updated", onJobUpdated);
@@ -422,6 +512,7 @@ export function useJobDetailWithUpdates(jobId) {
       es.addEventListener("job:removed", onJobRemoved);
       es.addEventListener("status:changed", onStatusChanged);
       es.addEventListener("state:change", onStateChange);
+      es.addEventListener("task:updated", onTaskUpdated);
       es.addEventListener("error", onError);
 
       // Set connection status from readyState when possible
@@ -439,6 +530,7 @@ export function useJobDetailWithUpdates(jobId) {
           es.removeEventListener("job:removed", onJobRemoved);
           es.removeEventListener("status:changed", onStatusChanged);
           es.removeEventListener("state:change", onStateChange);
+          es.removeEventListener("task:updated", onTaskUpdated);
           es.removeEventListener("error", onError);
           es.close();
         } catch (err) {