@ryanfw/prompt-orchestration-pipeline 0.11.0 → 0.12.0

package/src/core/status-writer.js

@@ -208,6 +208,26 @@ export async function writeJobStatus(jobDir, updateFn) {
         logger.error("Failed to emit SSE event:", error);
       }
 
+      // Emit lifecycle_block event if update contains lifecycle block reason
+      if (snapshot.lifecycleBlockReason) {
+        try {
+          const lifecycleEventData = {
+            jobId,
+            taskId: snapshot.lifecycleBlockTaskId,
+            op: snapshot.lifecycleBlockOp,
+            reason: snapshot.lifecycleBlockReason,
+          };
+          await logger.sse("lifecycle_block", lifecycleEventData);
+          logger.log(
+            "lifecycle_block SSE event broadcasted successfully",
+            lifecycleEventData
+          );
+        } catch (error) {
+          // Don't fail the write if SSE emission fails
+          logger.error("Failed to emit lifecycle_block SSE event:", error);
+        }
+      }
+
       logger.groupEnd();
       resultSnapshot = snapshot;
     })
@@ -485,6 +505,70 @@ export async function resetJobToCleanSlate(
   });
 }
 
+/**
+ * Reset a single task to pending state without affecting other tasks
+ *
+ * @param {string} jobDir - Job directory path containing tasks-status.json
+ * @param {string} taskId - Task identifier to reset
+ * @param {Object} options - Reset options
+ * @param {boolean} [options.clearTokenUsage=true] - Whether to clear token usage arrays
+ * @returns {Promise<Object>} The updated status snapshot
+ */
+export async function resetSingleTask(
+  jobDir,
+  taskId,
+  { clearTokenUsage = true } = {}
+) {
+  if (!jobDir || typeof jobDir !== "string") {
+    throw new Error("jobDir must be a non-empty string");
+  }
+
+  if (!taskId || typeof taskId !== "string") {
+    throw new Error("taskId must be a non-empty string");
+  }
+
+  return writeJobStatus(jobDir, (snapshot) => {
+    // Ensure tasks object exists
+    if (!snapshot.tasks || typeof snapshot.tasks !== "object") {
+      snapshot.tasks = {};
+    }
+
+    // Ensure the target task exists
+    if (!snapshot.tasks[taskId]) {
+      snapshot.tasks[taskId] = {};
+    }
+
+    const task = snapshot.tasks[taskId];
+
+    // Reset only the target task state and metadata
+    task.state = TaskState.PENDING;
+    task.currentStage = null;
+
+    // Remove error-related fields
+    delete task.failedStage;
+    delete task.error;
+
+    // Reset counters
+    task.attempts = 0;
+    task.refinementAttempts = 0;
+
+    // Clear token usage if requested
+    if (clearTokenUsage) {
+      task.tokenUsage = [];
+    }
+
+    // Update lastUpdated timestamp
+    snapshot.lastUpdated = new Date().toISOString();
+
+    // Do not modify:
+    // - Any other tasks within snapshot.tasks
+    // - snapshot.files.artifacts|logs|tmp
+    // - Root-level fields other than lastUpdated
+
+    return snapshot;
+  });
+}
+
 /**
  * Consolidated path jail security validation with generic error messages
  * @param {string} filename - Filename to validate

package/src/pages/Code.jsx

@@ -86,7 +86,14 @@ export default function CodePage() {
   useEffect(() => {
     fetch("/api/llm/functions")
       .then((res) => res.json())
-      .then(setLlmFunctions)
+      .then(({ ok, data }) => {
+        if (!ok || typeof data !== "object" || data === null) {
+          throw new Error(
+            "Invalid /api/llm/functions response: expected { ok:true, data:Object }"
+          );
+        }
+        setLlmFunctions(data);
+      })
       .catch(console.error);
   }, []);
 

package/src/pages/PipelineDetail.jsx

@@ -1,6 +1,6 @@
-import React from "react";
+import React, { useState } from "react";
 import { data, useParams } from "react-router-dom";
-import { Box, Flex, Text } from "@radix-ui/themes";
+import { Box, Flex, Text, Button } from "@radix-ui/themes";
 import * as Tooltip from "@radix-ui/react-tooltip";
 import JobDetail from "../components/JobDetail.jsx";
 import { useJobDetailWithUpdates } from "../ui/client/hooks/useJobDetailWithUpdates.js";
@@ -8,9 +8,15 @@ import Layout from "../components/Layout.jsx";
 import PageSubheader from "../components/PageSubheader.jsx";
 import { statusBadge } from "../utils/ui.jsx";
 import { formatCurrency4, formatTokensCompact } from "../utils/formatters.js";
+import { rescanJob } from "../ui/client/api.js";
+import StopJobModal from "../components/ui/StopJobModal.jsx";
+import { stopJob } from "../ui/client/api.js";
 
 export default function PipelineDetail() {
   const { jobId } = useParams();
+  const [isRescanning, setIsRescanning] = useState(false);
+  const [isStopModalOpen, setIsStopModalOpen] = useState(false);
+  const [isStopping, setIsStopping] = useState(false);
 
   // Handle missing job ID (undefined/null)
   if (jobId === undefined || jobId === null) {
@@ -143,6 +149,12 @@ export default function PipelineDetail() {
     ...(job.name ? [{ label: job.name }] : []),
   ];
 
+  // Determine if job is currently running
+  const isRunning =
+    job?.status === "running" ||
+    (job?.tasks &&
+      Object.values(job.tasks).some((task) => task?.state === "running"));
+
   // Derive cost data from job object with safe fallbacks
   const totalCost = job?.totalCost || job?.costs?.summary?.totalCost || 0;
   const totalTokens = job?.totalTokens || job?.costs?.summary?.totalTokens || 0;
@@ -193,13 +205,75 @@ export default function PipelineDetail() {
       costIndicator
     );
 
-  // Right side content for PageSubheader: job ID, cost indicator, and status badge
+  const handleRescan = async () => {
+    setIsRescanning(true);
+    try {
+      const result = await rescanJob(jobId);
+      if (result.ok) {
+        const addedCount = result.added ? result.added.length : 0;
+        const removedCount = result.removed ? result.removed.length : 0;
+        let message = "Rescan complete.";
+        if (addedCount > 0 && removedCount > 0) {
+          message += ` Added ${addedCount} task${addedCount > 1 ? "s" : ""}: ${JSON.stringify(result.added)}. Removed ${removedCount} task${removedCount > 1 ? "s" : ""}: ${JSON.stringify(result.removed)}.`;
+        } else if (addedCount > 0) {
+          message += ` Added ${addedCount} task${addedCount > 1 ? "s" : ""}: ${JSON.stringify(result.added)}.`;
+        } else if (removedCount > 0) {
+          message += ` Removed ${removedCount} task${removedCount > 1 ? "s" : ""}: ${JSON.stringify(result.removed)}.`;
+        } else {
+          message += " No changes found.";
+        }
+        console.log(message);
+      }
+    } catch (err) {
+      console.error("Rescan failed:", err);
+      alert("Rescan failed: " + err.message);
+    } finally {
+      setIsRescanning(false);
+    }
+  };
+
+  const openStopModal = () => setIsStopModalOpen(true);
+  const closeStopModal = () => setIsStopModalOpen(false);
+
+  const handleStopConfirm = async () => {
+    setIsStopping(true);
+    try {
+      await stopJob(jobId);
+      closeStopModal();
+    } catch (error) {
+      console.warn("Failed to stop job:", error);
+      closeStopModal();
+    } finally {
+      setIsStopping(false);
+    }
+  };
+
+  // Right side content for PageSubheader: job ID, cost indicator, status badge, and Stop control
   const subheaderRightContent = (
     <Flex align="center" gap="3" className="shrink-0 flex-wrap">
       <Text size="2" color="gray">
         ID: {job.id || jobId}
       </Text>
       {costIndicatorWithTooltip}
+      {isRunning && (
+        <Button
+          size="1"
+          variant="solid"
+          color="red"
+          disabled={isStopping}
+          onClick={openStopModal}
+        >
+          {isStopping ? "Stopping..." : "Stop"}
+        </Button>
+      )}
+      <Button
+        size="1"
+        variant="soft"
+        disabled={isRescanning}
+        onClick={handleRescan}
+      >
+        {isRescanning ? "Rescanning..." : "Rescan"}
+      </Button>
       {statusBadge(job.status)}
     </Flex>
   );
@@ -215,6 +289,14 @@ export default function PipelineDetail() {
         )}
       </PageSubheader>
       <JobDetail job={job} pipeline={pipeline} />
+      <StopJobModal
+        isOpen={isStopModalOpen}
+        onClose={closeStopModal}
+        onConfirm={handleStopConfirm}
+        runningJobs={[{ id: job.id, name: job.name, progress: job.progress }]}
+        defaultJobId={job.id}
+        isSubmitting={isStopping}
+      />
     </Layout>
   );
 }

package/src/pages/PromptPipelineDashboard.jsx

@@ -7,24 +7,23 @@ import { Box, Flex, Text, Tabs } from "@radix-ui/themes";
 import { Progress } from "../components/ui/progress";
 import { useJobListWithUpdates } from "../ui/client/hooks/useJobListWithUpdates";
 import { adaptJobSummary } from "../ui/client/adapters/job-adapter";
-import { TaskState, JobStatus } from "../config/statuses.js";
 
 // Referenced components — leave these alone
 import JobTable from "../components/JobTable";
 import Layout from "../components/Layout.jsx";
 
-export default function PromptPipelineDashboard({ isConnected }) {
+export default function PromptPipelineDashboard() {
   const navigate = useNavigate();
   const hookResult = useJobListWithUpdates();
 
   if (
+    /* eslint-disable-next-line no-undef */
     process.env.NODE_ENV === "test" &&
     (hookResult === undefined ||
       hookResult === null ||
       typeof hookResult !== "object" ||
       Array.isArray(hookResult))
   ) {
-    // eslint-disable-next-line no-console
     console.error(
       "[PromptPipelineDashboard] useJobListWithUpdates returned unexpected value",
       {
@@ -39,7 +38,7 @@ export default function PromptPipelineDashboard({ isConnected }) {
     );
   }
 
-  const { data: apiJobs, loading, error, connectionStatus } = hookResult;
+  const { data: apiJobs, error } = hookResult;
 
   const jobs = useMemo(() => {
     const src = Array.isArray(apiJobs) ? apiJobs : [];
@@ -57,26 +56,26 @@ export default function PromptPipelineDashboard({ isConnected }) {
   // Shared ticker for live duration updates - removed useTicker
 
   const errorCount = useMemo(
-    () => jobs.filter((j) => j.status === TaskState.FAILED).length,
+    () => jobs.filter((j) => j.displayCategory === "errors").length,
     [jobs]
   );
   const currentCount = useMemo(
-    () => jobs.filter((j) => j.status === TaskState.RUNNING).length,
+    () => jobs.filter((j) => j.displayCategory === "current").length,
     [jobs]
   );
   const completedCount = useMemo(
-    () => jobs.filter((j) => j.status === JobStatus.COMPLETE).length,
+    () => jobs.filter((j) => j.displayCategory === "complete").length,
     [jobs]
   );
 
   const filteredJobs = useMemo(() => {
     switch (activeTab) {
       case "current":
-        return jobs.filter((j) => j.status === TaskState.RUNNING);
+        return jobs.filter((j) => j.displayCategory === "current");
       case "errors":
-        return jobs.filter((j) => j.status === TaskState.FAILED);
+        return jobs.filter((j) => j.displayCategory === "errors");
       case "complete":
-        return jobs.filter((j) => j.status === JobStatus.COMPLETE);
+        return jobs.filter((j) => j.displayCategory === "complete");
       default:
         return [];
     }
@@ -86,7 +85,7 @@ export default function PromptPipelineDashboard({ isConnected }) {
 
   // Aggregate progress for currently running jobs (for a subtle top progress bar)
   const runningJobs = useMemo(
-    () => jobs.filter((j) => j.status === TaskState.RUNNING),
+    () => jobs.filter((j) => j.displayCategory === "current"),
     [jobs]
   );
   const aggregateProgress = useMemo(() => {

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

@@ -3,6 +3,8 @@ import {
   normalizeTaskState,
   deriveJobStatusFromTasks,
 } from "../../../config/statuses.js";
+import { classifyJobForDisplay } from "../../../utils/jobs.js";
+import { decideTransition } from "../../../core/lifecycle-policy.js";
 
 /**
  * Normalize a raw task state into canonical enum.
@@ -225,6 +227,9 @@ export function adaptJobSummary(apiJob) {
     job.totalTokens = job.costsSummary.totalTokens;
   }
 
+  // Compute and attach display category for UI bucketing
+  job.displayCategory = classifyJobForDisplay(job);
+
   // Include warnings for debugging
   if (warnings.length > 0) job.__warnings = warnings;
 
@@ -284,8 +289,63 @@ export function adaptJobDetail(apiDetail) {
     detail.costs = apiDetail.costs;
   }
 
+  // Compute and attach display category for UI bucketing
+  detail.displayCategory = classifyJobForDisplay(detail);
+
   // Include warnings for debugging
   if (warnings.length > 0) detail.__warnings = warnings;
 
   return detail;
 }
+
+/**
+ * deriveAllowedActions(adaptedJob, pipelineTasks)
+ * - adaptedJob: normalized job object from adaptJobSummary/adaptJobDetail
+ * - pipelineTasks: array of task names in execution order from pipeline.json
+ * Returns { start, restart } boolean flags for UI controls.
+ */
+export function deriveAllowedActions(adaptedJob, pipelineTasks) {
+  // Check if any task is running
+  const hasRunningTask = Object.values(adaptedJob.tasks || {}).some(
+    (task) => task.state === "running"
+  );
+
+  // Default to disabled if job state is running or any task is running
+  if (adaptedJob.status === "running" || hasRunningTask) {
+    return { start: false, restart: false };
+  }
+
+  // Default to enabled for restart if not running
+  const restart = true;
+
+  // Start requires checking if ANY task can be started (not ALL tasks)
+  // Edge case: if no pipeline tasks, default to enabled
+  if (pipelineTasks.length === 0) {
+    return { start: true, restart };
+  }
+
+  const start = pipelineTasks.some((taskName) => {
+    const task = adaptedJob.tasks[taskName];
+    if (!task) return false; // Task not found, skip
+
+    const taskState = task.state || "pending";
+
+    // Check if all upstream tasks are done for dependency evaluation
+    const taskIndex = pipelineTasks.indexOf(taskName);
+    const upstreamTasks = pipelineTasks.slice(0, taskIndex);
+    const dependenciesReady = upstreamTasks.every((upstreamTaskName) => {
+      const upstreamTask = adaptedJob.tasks[upstreamTaskName];
+      return upstreamTask && upstreamTask.state === "done";
+    });
+
+    const startDecision = decideTransition({
+      op: "start",
+      taskState,
+      dependenciesReady,
+    });
+
+    return startDecision.ok;
+  });
+
+  return { start, restart };
+}

package/src/ui/client/api.js

@@ -3,12 +3,14 @@
  */
 
 /**
- * Restart a job with clean-slate mode
+ * Restart a job with clean-slate mode or from a specific task
  *
  * @param {string} jobId - The ID of the job to restart
  * @param {Object} opts - Options object
- * @param {Object} opts.options - Additional options for the restart
- * @param {boolean} opts.options.clearTokenUsage - Whether to clear token usage (default: true)
+ * @param {string} [opts.fromTask] - Task ID to restart from (inclusive)
+ * @param {boolean} [opts.singleTask] - Whether to run only the target task and then stop
+ * @param {Object} [opts.options] - Additional options for the restart
+ * @param {boolean} [opts.options.clearTokenUsage=true] - Whether to clear token usage
  * @returns {Promise<Object>} Parsed JSON response from the server
  * @throws {Object} Structured error object with { code, message } for non-2xx responses
  */
@@ -19,8 +21,16 @@ export async function restartJob(jobId, opts = {}) {
   };
 
   const requestBody = opts.fromTask
-    ? { fromTask: opts.fromTask, options }
-    : { mode: "clean-slate", options };
+    ? {
+        fromTask: opts.fromTask,
+        options,
+        ...(opts.singleTask !== undefined && { singleTask: opts.singleTask }),
+      }
+    : {
+        mode: "clean-slate",
+        options,
+        ...(opts.singleTask !== undefined && { singleTask: opts.singleTask }),
+      };
 
   try {
     const response = await fetch(
@@ -67,6 +77,164 @@ export async function restartJob(jobId, opts = {}) {
   }
 }
 
+/**
+ * Rescan a job to synchronize tasks with the pipeline definition, detecting both added and removed tasks.
+ *
+ * @param {string} jobId - The ID of the job to rescan
+ * @returns {Promise<Object>} Parsed JSON response from the server
+ * @throws {Object} Structured error object with { code, message } for non-2xx responses
+ */
+export async function rescanJob(jobId) {
+  try {
+    const response = await fetch(
+      `/api/jobs/${encodeURIComponent(jobId)}/rescan`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      // Try to parse error response, fall back to status text if parsing fails
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+
+      // Throw structured error with code and message
+      throw {
+        code: errorData.code || getErrorCodeFromStatus(response.status),
+        message:
+          errorData.message || getErrorMessageFromStatus(response.status),
+        status: response.status,
+      };
+    }
+
+    // Return parsed JSON for successful responses
+    return await response.json();
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (error.code && error.message) {
+      throw error;
+    }
+
+    // Handle network errors or other unexpected errors
+    throw {
+      code: "network_error",
+      message: error.message || "Failed to connect to server",
+    };
+  }
+}
+
+/**
+ * Start a specific pending task for a job that is not actively running
+ *
+ * @param {string} jobId - The ID of the job
+ * @param {string} taskId - The ID of the task to start
+ * @returns {Promise<Object>} Parsed JSON response from the server
+ * @throws {Object} Structured error object with { code, message } for non-2xx responses
+ */
+export async function startTask(jobId, taskId) {
+  try {
+    const response = await fetch(
+      `/api/jobs/${encodeURIComponent(jobId)}/tasks/${encodeURIComponent(taskId)}/start`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      // Try to parse error response, fall back to status text if parsing fails
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+
+      // Throw structured error with code and message
+      throw {
+        code: errorData.code || getErrorCodeFromStatus(response.status),
+        message: getStartTaskErrorMessage(errorData, response.status),
+        status: response.status,
+      };
+    }
+
+    // Return parsed JSON for successful responses
+    return await response.json();
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (error.code && error.message) {
+      throw error;
+    }
+
+    // Handle network errors or other unexpected errors
+    throw {
+      code: "network_error",
+      message: error.message || "Failed to connect to server",
+    };
+  }
+}
+
+/**
+ * Stop a running job's pipeline
+ *
+ * @param {string} jobId - The ID of the job to stop
+ * @returns {Promise<Object>} Parsed JSON response from the server
+ * @throws {Object} Structured error object with { code, message } for non-2xx responses
+ */
+export async function stopJob(jobId) {
+  try {
+    const response = await fetch(
+      `/api/jobs/${encodeURIComponent(jobId)}/stop`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      }
+    );
+
+    if (!response.ok) {
+      // Try to parse error response, fall back to status text if parsing fails
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = { message: response.statusText };
+      }
+
+      // Throw structured error with code and message
+      throw {
+        code: errorData.code || getErrorCodeFromStatus(response.status),
+        message: getStopErrorMessage(errorData, response.status),
+        status: response.status,
+      };
+    }
+
+    // Return parsed JSON for successful responses
+    return await response.json();
+  } catch (error) {
+    // Re-throw structured errors as-is
+    if (error.code && error.message) {
+      throw error;
+    }
+
+    // Handle network errors or other unexpected errors
+    throw {
+      code: "network_error",
+      message: error.message || "Failed to connect to server",
+    };
+  }
+}
+
 /**
  * Map HTTP status codes to error codes for structured error handling
  */
@@ -108,9 +276,6 @@ function getRestartErrorMessage(errorData, status) {
     if (errorData.code === "job_running") {
       return "Job is currently running; restart is unavailable.";
     }
-    if (errorData.code === "unsupported_lifecycle") {
-      return "Job must be in current to restart.";
-    }
     if (errorData.message?.includes("job_running")) {
       return "Job is currently running; restart is unavailable.";
     }
@@ -132,3 +297,63 @@ function getRestartErrorMessage(errorData, status) {
   // Fall back to provided message or default
   return errorData.message || "Failed to restart job.";
 }
+
+/**
+ * Get specific error message from error response for start task functionality
+ */
+function getStartTaskErrorMessage(errorData, status) {
+  // Handle specific 409 conflict errors
+  if (status === 409) {
+    if (errorData.code === "job_running") {
+      return "Job is currently running; start is unavailable.";
+    }
+    if (errorData.code === "dependencies_not_satisfied") {
+      return "Dependencies not satisfied for task.";
+    }
+    if (errorData.code === "unsupported_lifecycle") {
+      return "Job must be in current to start a task.";
+    }
+    return "Request conflict.";
+  }
+
+  // Handle 404 errors
+  if (status === 404) {
+    return "Job not found.";
+  }
+
+  // Handle 400 errors
+  if (status === 400) {
+    return errorData.message || "Bad request";
+  }
+
+  // Handle 500 errors
+  if (status === 500) {
+    return "Internal server error";
+  }
+
+  // Fall back to provided message or default
+  return errorData.message || "Failed to start task.";
+}
+
+/**
+ * Get specific error message from error response for stop functionality
+ */
+function getStopErrorMessage(errorData, status) {
+  // Handle 404 errors
+  if (status === 404) {
+    return "Job not found.";
+  }
+
+  // Handle 409 errors
+  if (status === 409) {
+    return errorData.message || "Job stop is already in progress.";
+  }
+
+  // Handle 500 errors
+  if (status === 500) {
+    return "Internal server error";
+  }
+
+  // Fall back to provided message or default
+  return errorData.message || `Request failed with status ${status}`;
+}

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

@@ -20,7 +20,20 @@ export function useJobList() {
         setData(null);
       } else {
         const json = await res.json();
-        setData(json);
+        if (json && typeof json === "object" && "ok" in json) {
+          if (json.ok && Array.isArray(json.data)) {
+            setData(json.data);
+          } else if (!json.ok) {
+            setError({ code: json.code, message: json.message });
+            setData(null);
+          } else {
+            // Fallback: data is not an array; treat as empty to avoid crashes
+            setData([]);
+          }
+        } else {
+          // Legacy path: response is already an array
+          setData(Array.isArray(json) ? json : []);
+        }
       }
     } catch (err) {
       if (err.name === "AbortError") {