@ryanfw/prompt-orchestration-pipeline 1.3.2 → 1.3.4

package/src/ui/state/transformers/status-transformer.ts

@@ -1,14 +1,8 @@
-import {
-  deriveJobStatusFromTasks,
-  normalizeJobStatus,
-  normalizeTaskState,
-} from "../../../config/statuses";
+import { normalizeJobView } from "../../../core/job-view";
 import type {
   CanonicalJob,
-  CanonicalJobStatus,
   CanonicalTask,
   ComputedStatus,
-  GateInfo,
   JobReadResult,
   TransformationStats,
 } from "../types";
@@ -18,141 +12,13 @@ function asRecord(value: unknown): Record<string, unknown> | null {
   return value as Record<string, unknown>;
 }
 
-function asTaskFiles(value: unknown): CanonicalTask["files"] {
-  const record = asRecord(value);
-  return {
-    artifacts: Array.isArray(record?.["artifacts"]) ? (record["artifacts"] as string[]) : [],
-    logs: Array.isArray(record?.["logs"]) ? (record["logs"] as string[]) : [],
-    tmp: Array.isArray(record?.["tmp"]) ? (record["tmp"] as string[]) : [],
-  };
-}
-
-function toGateInfo(value: unknown): GateInfo | null | undefined {
-  if (value === null) return null;
-  const record = asRecord(value);
-  if (!record) return undefined;
-
-  const artifacts = Array.isArray(record["artifacts"])
-    ? record["artifacts"].filter((artifact): artifact is string => typeof artifact === "string")
-    : undefined;
-
-  return {
-    afterTask: typeof record["afterTask"] === "string" ? record["afterTask"] : "",
-    message: typeof record["message"] === "string" ? record["message"] : "",
-    requestedAt: typeof record["requestedAt"] === "string" ? record["requestedAt"] : "",
-    ...(artifacts && artifacts.length > 0 ? { artifacts } : {}),
-  };
-}
-
-function toTask(name: string, value: unknown): CanonicalTask {
-  const task = asRecord(value) ?? {};
-  return {
-    name,
-    state: normalizeTaskState(task["state"]),
-    files: asTaskFiles(task["files"]),
-    startedAt: typeof task["startedAt"] === "string" ? task["startedAt"] : null,
-    endedAt: typeof task["endedAt"] === "string" ? task["endedAt"] : null,
-    attempts: typeof task["attempts"] === "number" ? task["attempts"] : undefined,
-    restartCount: typeof task["restartCount"] === "number" ? task["restartCount"] : undefined,
-    retrying: typeof task["retrying"] === "boolean" ? task["retrying"] : undefined,
-    nextRetryAt: typeof task["nextRetryAt"] === "string" ? task["nextRetryAt"] : undefined,
-    lastRetryError: Object.hasOwn(task, "lastRetryError") ? task["lastRetryError"] as import("../types").RetryError | null : undefined,
-    executionTimeMs:
-      typeof task["executionTimeMs"] === "number" ? task["executionTimeMs"] : undefined,
-    refinementAttempts:
-      typeof task["refinementAttempts"] === "number"
-        ? task["refinementAttempts"]
-        : undefined,
-    stageLogPath: typeof task["stageLogPath"] === "string" ? task["stageLogPath"] : undefined,
-    errorContext: task["errorContext"],
-    currentStage: typeof task["currentStage"] === "string" ? task["currentStage"] : undefined,
-    failedStage: typeof task["failedStage"] === "string" ? task["failedStage"] : undefined,
-    artifacts: task["artifacts"],
-    error: asRecord(task["error"]) as CanonicalTask["error"],
-    skipReason: typeof task["skipReason"] === "string" ? task["skipReason"] : undefined,
-    skippedBy: typeof task["skippedBy"] === "string" ? task["skippedBy"] : undefined,
-    controlApplied: typeof task["controlApplied"] === "boolean" ? task["controlApplied"] : undefined,
-  };
-}
-
-function getStatusValue(status: ReturnType<typeof deriveJobStatusFromTasks>): CanonicalJobStatus {
-  return status === "failed" ? "error" : status;
-}
-
-function getProgress(tasks: CanonicalTask[]): number {
-  if (tasks.length === 0) return 0;
-
-  const completed = tasks.filter((task) => task.state === "done" || task.state === "skipped").length;
-  return Math.floor((completed / tasks.length) * 100);
-}
-
-function getTitle(raw: Record<string, unknown>, jobId: string): string {
-  const title = raw["title"] ?? raw["name"];
-  return typeof title === "string" && title.trim() !== "" ? title : jobId;
-}
-
-function getCosts(raw: Record<string, unknown>): Record<string, unknown> {
-  const explicit = asRecord(raw["costs"]);
-  if (explicit) return explicit;
-
-  // Aggregate cost and token totals from individual task entries
-  const tasks = asRecord(raw["tasks"]);
-  if (!tasks) return {};
-
-  let totalCost = 0;
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-
-  for (const value of Object.values(tasks)) {
-    const task = asRecord(value);
-    if (!task) continue;
-
-    // Sum from [model, input, output, cost?] tuples
-    const usage = task["tokenUsage"];
-    if (Array.isArray(usage)) {
-      for (const entry of usage) {
-        if (Array.isArray(entry) && entry.length >= 3) {
-          if (typeof entry[1] === "number") totalInputTokens += entry[1];
-          if (typeof entry[2] === "number") totalOutputTokens += entry[2];
-          if (typeof entry[3] === "number") totalCost += entry[3];
-        }
-      }
-    }
-  }
-
-  const totalTokens = totalInputTokens + totalOutputTokens;
-  if (totalCost === 0 && totalTokens === 0) return {};
-
-  return { totalCost, totalTokens, totalInputTokens, totalOutputTokens };
-}
-
 export function computeJobStatus(tasksInput: unknown): ComputedStatus {
-  const tasks = Object.values(transformTasks(tasksInput));
-  if (tasks.length === 0) {
-    return { status: "pending", progress: 0 };
-  }
-
-  return {
-    status: getStatusValue(deriveJobStatusFromTasks(tasks)),
-    progress: getProgress(tasks),
-  };
+  const view = normalizeJobView({ tasks: tasksInput }, "", "");
+  return { status: view.status, progress: view.progress };
 }
 
 export function transformTasks(rawTasks: unknown): Record<string, CanonicalTask> {
-  if (Array.isArray(rawTasks)) {
-    return Object.fromEntries(
-      rawTasks.map((task, index) => {
-        const record = asRecord(task);
-        const name = typeof record?.["name"] === "string" ? (record["name"] as string) : `task-${index + 1}`;
-        return [name, toTask(name, task)];
-      }),
-    );
-  }
-
-  const record = asRecord(rawTasks);
-  if (!record) return {};
-
-  return Object.fromEntries(Object.entries(record).map(([name, task]) => [name, toTask(name, task)]));
+  return normalizeJobView({ tasks: rawTasks }, "", "").tasks;
 }
 
 export function transformJobStatus(raw: unknown, jobId: string, location: string): CanonicalJob | null {
@@ -164,42 +30,41 @@ export function transformJobStatus(raw: unknown, jobId: string, location: string
     console.warn(`job id mismatch: expected "${jobId}" but received "${rawJobId}"`);
   }
 
-  const tasks = transformTasks(record["tasks"]);
-  const computed = computeJobStatus(tasks);
-  const snapshotStatus = normalizeJobStatus(record["status"] ?? record["state"]);
-  const gate = toGateInfo(record["gate"]);
-  const title = getTitle(record, jobId);
+  return normalizeJobView(raw, jobId, location);
+}
 
+export function buildUnreadableJob(result: JobReadResult): CanonicalJob {
+  const code = result.code ?? "UNKNOWN_READ_ERROR";
+  const detail = result.message ? ` Reader error: ${result.message}` : "";
+  const message =
+    `Status file is unreadable (${code}). ` +
+    `Repair or delete ${result.path ?? "tasks-status.json"} for job "${result.jobId}" to recover.` +
+    detail;
   return {
-    id: jobId,
-    jobId,
-    name: title,
-    title,
-    status: snapshotStatus === "waiting" || snapshotStatus === "failed"
-      ? getStatusValue(snapshotStatus)
-      : computed.status,
-    progress: computed.progress,
-    createdAt: typeof record["createdAt"] === "string" ? record["createdAt"] : null,
-    updatedAt: typeof record["updatedAt"] === "string" ? record["updatedAt"] : null,
-    location,
-    tasks,
-    files: asRecord(record["files"]) ?? {},
-    costs: getCosts(record),
-    pipeline: typeof record["pipeline"] === "string" ? record["pipeline"] : undefined,
-    pipelineLabel:
-      typeof record["pipelineLabel"] === "string" ? record["pipelineLabel"] : undefined,
-    pipelineConfig: asRecord(record["pipelineConfig"]) ?? undefined,
-    current: record["current"],
-    currentStage: record["currentStage"],
-    gate,
-    warnings: Array.isArray(record["warnings"]) ? (record["warnings"] as string[]) : undefined,
+    id: result.jobId,
+    jobId: result.jobId,
+    name: result.jobId,
+    title: result.jobId,
+    status: "failed",
+    progress: 0,
+    createdAt: null,
+    updatedAt: null,
+    location: result.location ?? null,
+    tasks: {},
+    files: {},
+    costs: {},
+    readable: false,
+    error: { code, message, path: result.path },
   };
 }
 
 export function transformMultipleJobs(jobReadResults: JobReadResult[]): CanonicalJob[] {
   return jobReadResults
-    .filter((result) => result.ok)
-    .map((result) => transformJobStatus(result.data, result.jobId, result.location))
+    .map((result) =>
+      result.ok
+        ? transformJobStatus(result.data, result.jobId, result.location)
+        : result.code === "INVALID_JSON" ? buildUnreadableJob(result) : null,
+    )
     .filter((job): job is CanonicalJob => job !== null);
 }
 
@@ -208,6 +73,7 @@ export function getTransformationStats(
   transformedJobs: CanonicalJob[],
 ): TransformationStats {
   const successfulReads = readResults.filter((result) => result.ok).length;
+  const successfulTransforms = transformedJobs.filter((job) => job.readable !== false).length;
   const statusDistribution = transformedJobs.reduce<Record<string, number>>((acc, job) => {
     acc[job.status] = (acc[job.status] ?? 0) + 1;
     return acc;
@@ -216,9 +82,9 @@ export function getTransformationStats(
   return {
     totalRead: readResults.length,
     successfulReads,
-    successfulTransforms: transformedJobs.length,
-    failedTransforms: successfulReads - transformedJobs.length,
-    transformationRate: successfulReads === 0 ? 0 : transformedJobs.length / successfulReads,
+    successfulTransforms,
+    failedTransforms: successfulReads - successfulTransforms,
+    transformationRate: successfulReads === 0 ? 0 : successfulTransforms / successfulReads,
     statusDistribution,
   };
 }

package/src/ui/state/types.ts

@@ -1,7 +1,8 @@
 import type { JobStatusValue, TaskStateValue } from "../../config/statuses";
+import type { JobView, JobViewTask } from "../../core/job-view";
 
 export type ChangeType = "created" | "modified" | "deleted";
-export type CanonicalJobStatus = JobStatusValue | "error";
+export type CanonicalJobStatus = JobStatusValue;
 
 export interface ChangeEntry {
   path: string;
@@ -56,7 +57,7 @@ export interface ComposeSnapshotOptions {
 
 export interface SnapshotDeps {
   listAllJobs?: () => { current: string[]; complete: string[] } | Promise<{ current: string[]; complete: string[] }>;
-  readJob?: (id: string, location: string) => Promise<JobReadResult>;
+  readJob?: (id: string) => Promise<JobReadResult>;
   transformMultipleJobs?: (results: JobReadResult[]) => CanonicalJob[];
   now?: () => Date;
   paths?: Record<string, string>;
@@ -126,53 +127,12 @@ export interface GateInfo {
   message: string;
   artifacts?: string[];
   requestedAt: string;
+  kind?: "approval" | "control_invalid";
 }
 
-export interface CanonicalTask {
-  state: TaskStateValue;
-  name: string;
-  files: { artifacts: string[]; logs: string[]; tmp: string[] };
-  startedAt?: string | null;
-  endedAt?: string | null;
-  attempts?: number;
-  restartCount?: number;
-  retrying?: boolean;
-  nextRetryAt?: string;
-  lastRetryError?: RetryError | null;
-  executionTimeMs?: number;
-  refinementAttempts?: number;
-  stageLogPath?: string;
-  errorContext?: unknown;
-  currentStage?: string;
-  failedStage?: string;
-  artifacts?: unknown;
-  error?: { message: string; [key: string]: unknown } | null;
-  skipReason?: string;
-  skippedBy?: string;
-  controlApplied?: boolean;
-}
-
-export interface CanonicalJob {
-  id: string;
-  jobId: string;
-  name: string;
-  title: string;
-  status: CanonicalJobStatus;
-  progress: number;
-  createdAt: string | null;
-  updatedAt: string | null;
-  location: string | null;
-  tasks: Record<string, CanonicalTask>;
-  files: Record<string, unknown>;
-  costs: Record<string, unknown>;
-  pipeline?: string;
-  pipelineLabel?: string;
-  pipelineConfig?: Record<string, unknown>;
-  current?: unknown;
-  currentStage?: unknown;
-  gate?: GateInfo | null;
-  warnings?: string[];
-}
+export type CanonicalTask = JobViewTask;
+
+export type CanonicalJob = JobView;
 
 export interface JobReadResult {
   ok: boolean;
@@ -181,6 +141,7 @@ export interface JobReadResult {
   location: string;
   code?: string;
   message?: string;
+  path?: string;
 }
 
 export interface TransformationStats {
@@ -202,7 +163,7 @@ export interface JobListStats {
 export interface GroupedJobs {
   running: CanonicalJob[];
   waiting: CanonicalJob[];
-  error: CanonicalJob[];
+  failed: CanonicalJob[];
   pending: CanonicalJob[];
   complete: CanonicalJob[];
 }
@@ -214,6 +175,9 @@ export interface CostsSummary {
   totalCost: number;
   totalInputCost: number;
   totalOutputCost: number;
+  estimatedCost: number;
+  hasEstimated: boolean;
+  unavailableCost: number;
 }
 
 export interface APIJob {
@@ -230,10 +194,13 @@ export interface APIJob {
   currentStage?: unknown;
   gate?: GateInfo | null;
   costsSummary: CostsSummary;
+  costs?: Record<string, unknown>;
   pipelineSlug?: string;
   pipeline?: string;
   pipelineLabel?: string;
   pipelineConfig?: Record<string, unknown>;
+  readable?: boolean;
+  error?: { code: string; message: string; path?: string };
 }
 
 export interface AggregationStats {

package/src/utils/__tests__/path-containment.test.ts

@@ -0,0 +1,160 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { resolveUnderRoot, resolveWithin } from "../path-containment";
+
+describe("resolveWithin", () => {
+  const rootDir = "/app/staging";
+
+  it("rejects relative path with parent dir escape", () => {
+    expect(resolveWithin(rootDir, "../x")).toBeNull();
+  });
+
+  it("rejects deeply nested parent dir escape", () => {
+    expect(resolveWithin(rootDir, "../../../../tmp/PWNED.txt")).toBeNull();
+  });
+
+  it("rejects normalized parent dir escape", () => {
+    expect(resolveWithin(rootDir, "a/../../b")).toBeNull();
+  });
+
+  it("rejects absolute path", () => {
+    expect(resolveWithin(rootDir, "/etc/passwd")).toBeNull();
+  });
+
+  it("rejects empty string", () => {
+    expect(resolveWithin(rootDir, "")).toBeNull();
+  });
+
+  it("rejects non-string input", () => {
+    expect(resolveWithin(rootDir, 42)).toBeNull();
+  });
+
+  it("rejects string containing NUL byte", () => {
+    expect(resolveWithin(rootDir, "safe\0/../escape")).toBeNull();
+  });
+
+  it("rejects current-directory root target", () => {
+    expect(resolveWithin(rootDir, ".")).toBeNull();
+  });
+
+  it("rejects nested path that normalizes to root", () => {
+    expect(resolveWithin(rootDir, "dir/..")).toBeNull();
+  });
+
+  it("resolves a plain filename within root", () => {
+    const result = resolveWithin(rootDir, "out.json");
+    expect(result).toBe(path.resolve(rootDir, "out.json"));
+  });
+
+  it("resolves a nested relative path within root", () => {
+    const result = resolveWithin(rootDir, "data/foo.json");
+    expect(result).toBe(path.resolve(rootDir, "data/foo.json"));
+  });
+});
+
+describe("resolveUnderRoot", () => {
+  const rootDir = "/app/staging";
+
+  it("rejects parent dir segment", () => {
+    expect(resolveUnderRoot(rootDir, "..")).toBeNull();
+  });
+
+  it("rejects encoded slash escape that decodes to traversal", () => {
+    expect(resolveUnderRoot(rootDir, "..%2f..%2fetc")).toBeNull();
+  });
+
+  it("rejects decoded null byte", () => {
+    expect(resolveUnderRoot(rootDir, "foo%00bar")).toBeNull();
+  });
+
+  it("rejects malformed percent-encoding", () => {
+    expect(resolveUnderRoot(rootDir, "%zz")).toBeNull();
+  });
+
+  it("rejects truncated percent-encoding", () => {
+    expect(resolveUnderRoot(rootDir, "%2")).toBeNull();
+  });
+
+  it("rejects non-string segment", () => {
+    expect(resolveUnderRoot(rootDir, "a", 42 as unknown as string)).toBeNull();
+  });
+
+  it("resolves a plain encoded filename", () => {
+    expect(resolveUnderRoot(rootDir, "out.json")).toBe(path.resolve(rootDir, "out.json"));
+  });
+
+  it("resolves multiple segments joined under root", () => {
+    expect(resolveUnderRoot(rootDir, "data", "foo.json")).toBe(
+      path.resolve(rootDir, "data/foo.json"),
+    );
+  });
+
+  it("decodes a legitimately encoded space once (AC-9)", () => {
+    expect(resolveUnderRoot(rootDir, "my%20file.json")).toBe(
+      path.resolve(rootDir, "my file.json"),
+    );
+  });
+
+  it("rejects encoded dot-dot (AC-3)", () => {
+    expect(resolveUnderRoot(rootDir, "%2e%2e")).toBeNull();
+  });
+
+  it("rejects mixed-case encoded dot-dot (AC-3)", () => {
+    expect(resolveUnderRoot(rootDir, "%2E%2E")).toBeNull();
+  });
+
+  it("rejects encoded traversal nested under a name (AC-3)", () => {
+    expect(resolveUnderRoot(rootDir, "a%2f..%2f..%2fetc")).toBeNull();
+  });
+
+  it("contains a doubly-encoded dot-dot that decodes to a literal (AC-3)", () => {
+    expect(resolveUnderRoot(rootDir, "%252e%252e")).toBe(path.resolve(rootDir, "%2e%2e"));
+  });
+});
+
+describe("URL parsing characterization (AC-2)", () => {
+  it("normalizes an encoded dot-dot path segment before capture", () => {
+    expect(new URL("https://h/a/%2e%2e/b").pathname).toBe("/b");
+  });
+
+  it("drops a standalone encoded dot-dot segment", () => {
+    expect(new URL("https://h/%2e%2e").pathname).toBe("/");
+  });
+
+  it("normalizes a mixed-case encoded dot-dot segment", () => {
+    expect(new URL("https://h/%2E%2E").pathname).toBe("/");
+  });
+
+  it("keeps an encoded slash encoded within a segment", () => {
+    expect(new URL("https://h/x%2f").pathname).toBe("/x%2f");
+  });
+
+  it("keeps a doubly-encoded dot encoded", () => {
+    expect(new URL("https://h/x%252e").pathname).toBe("/x%252e");
+  });
+
+  it("keeps an encoded space encoded within a segment", () => {
+    expect(new URL("https://h/x%20").pathname).toBe("/x%20");
+  });
+
+  it("URLPattern captures keep an encoded slash encoded", () => {
+    const result = new URLPattern({ pathname: "/:seg" }).exec(new URL("https://h/x%2f"));
+    expect(result?.pathname?.groups?.seg).toBe("x%2f");
+  });
+
+  it("URLPattern captures keep a doubly-encoded dot encoded", () => {
+    const result = new URLPattern({ pathname: "/:seg" }).exec(new URL("https://h/x%252e"));
+    expect(result?.pathname?.groups?.seg).toBe("x%252e");
+  });
+
+  it("URLPattern captures keep an encoded space encoded", () => {
+    const result = new URLPattern({ pathname: "/:seg" }).exec(new URL("https://h/x%20"));
+    expect(result?.pathname?.groups?.seg).toBe("x%20");
+  });
+
+  it("URLSearchParams.get() decodes query values exactly once", () => {
+    const a = new URL("https://h/x?a=%20b%2520c").searchParams.get("a");
+    expect(a).toBe(" b%20c");
+  });
+});

package/src/{ui/server/utils → utils}/path-containment.ts

@@ -16,3 +16,24 @@ export function resolveWithin(rootDir: string, relativePath: unknown): string |
   if (!resolved.startsWith(root + path.sep)) return null;
   return resolved;
 }
+
+/**
+ * Decode each encoded URL path segment/pathname exactly once, then delegate to
+ * `resolveWithin` for lexical containment. For URLPattern path captures and
+ * static pathnames only — do NOT pass `URLSearchParams.get()` values here
+ * (they are already decoded once and would double-decode `%25`).
+ */
+export function resolveUnderRoot(rootDir: string, ...segments: string[]): string | null {
+  const decoded: string[] = [];
+  for (const seg of segments) {
+    if (typeof seg !== "string") return null;
+    let d: string;
+    try {
+      d = decodeURIComponent(seg);
+    } catch {
+      return null;
+    }
+    decoded.push(d);
+  }
+  return resolveWithin(rootDir, decoded.join("/"));
+}

package/src/task-analysis/__tests__/enrichers-analysis-writer.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { mkdtemp, rm } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import { writeAnalysisFile } from "../enrichers/analysis-writer.ts";
-import type { TaskAnalysis } from "../types.ts";
-
-const VALID_ANALYSIS: TaskAnalysis = {
-  taskFilePath: "/pipeline/tasks/research.js",
-  stages: [{ name: "fetchData", order: 0, isAsync: true }],
-  artifacts: {
-    reads: [{ fileName: "input.json", stage: "fetchData", required: true }],
-    writes: [{ fileName: "output.json", stage: "fetchData" }],
-    unresolvedReads: [],
-    unresolvedWrites: [],
-  },
-  models: [{ provider: "openai", method: "chat", stage: "fetchData" }],
-};
-
-let tmpDir: string;
-
-beforeAll(async () => {
-  tmpDir = await mkdtemp(path.join(os.tmpdir(), "analysis-writer-test-"));
-});
-
-afterAll(async () => {
-  await rm(tmpDir, { recursive: true, force: true });
-});
-
-describe("writeAnalysisFile", () => {
-  it("writes analysis file with analyzedAt and all fields for valid input", async () => {
-    const pipelinePath = path.join(tmpDir, "pipeline-1");
-    const before = new Date();
-
-    await writeAnalysisFile(pipelinePath, "research", VALID_ANALYSIS);
-
-    const after = new Date();
-    const filePath = path.join(pipelinePath, "analysis", "research.analysis.json");
-    expect(existsSync(filePath)).toBe(true);
-
-    const content = JSON.parse(await Bun.file(filePath).text()) as Record<string, unknown>;
-
-    expect(typeof content.analyzedAt).toBe("string");
-    const analyzedAt = new Date(content.analyzedAt as string);
-    expect(analyzedAt.getTime()).toBeGreaterThanOrEqual(before.getTime());
-    expect(analyzedAt.getTime()).toBeLessThanOrEqual(after.getTime());
-
-    expect(content.taskFilePath).toBe(VALID_ANALYSIS.taskFilePath);
-    expect(content.stages).toEqual(VALID_ANALYSIS.stages);
-    expect(content.artifacts).toEqual(VALID_ANALYSIS.artifacts);
-    expect(content.models).toEqual(VALID_ANALYSIS.models);
-  });
-
-  it("throws before creating any file when taskFilePath is null", async () => {
-    const pipelinePath = path.join(tmpDir, "pipeline-2");
-    const bad = { ...VALID_ANALYSIS, taskFilePath: null } as unknown as TaskAnalysis;
-
-    await expect(
-      writeAnalysisFile(pipelinePath, "research", bad),
-    ).rejects.toThrow(/taskFilePath/);
-
-    expect(existsSync(path.join(pipelinePath, "analysis"))).toBe(false);
-  });
-
-  it("throws when stages is not an array", async () => {
-    const pipelinePath = path.join(tmpDir, "pipeline-3");
-    const bad = { ...VALID_ANALYSIS, stages: "not-an-array" } as unknown as TaskAnalysis;
-
-    await expect(
-      writeAnalysisFile(pipelinePath, "research", bad),
-    ).rejects.toThrow(/stages/);
-  });
-
-  it("throws when artifacts is missing reads", async () => {
-    const pipelinePath = path.join(tmpDir, "pipeline-4");
-    const bad = {
-      ...VALID_ANALYSIS,
-      artifacts: { writes: [], unresolvedReads: [], unresolvedWrites: [] },
-    } as unknown as TaskAnalysis;
-
-    await expect(
-      writeAnalysisFile(pipelinePath, "research", bad),
-    ).rejects.toThrow(/artifacts/);
-  });
-});