stageflow 0.2.0 → 0.8.0

package/dist/project/findProjectRoot.js

@@ -0,0 +1,51 @@
+import { existsSync, realpathSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+const cache = new Map();
+function normalizeRoot(dir) {
+    try {
+        return realpathSync(path.resolve(dir));
+    }
+    catch {
+        return path.resolve(dir);
+    }
+}
+export function findProjectRoot(startDir) {
+    const normalized = path.resolve(startDir);
+    if (cache.has(normalized)) {
+        return cache.get(normalized) ?? null;
+    }
+    let result = null;
+    try {
+        const stdout = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd: normalized,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const trimmed = stdout.trim();
+        if (trimmed.length > 0) {
+            result = normalizeRoot(trimmed);
+        }
+    }
+    catch {
+        result = walkForGitRoot(normalized);
+    }
+    cache.set(normalized, result);
+    return result;
+}
+function walkForGitRoot(startDir) {
+    let dir = path.resolve(startDir);
+    for (;;) {
+        if (existsSync(path.join(dir, ".git"))) {
+            return normalizeRoot(dir);
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return null;
+        }
+        dir = parent;
+    }
+}
+export function clearFindProjectRootCacheForTests() {
+    cache.clear();
+}

package/dist/project/globalHome.d.ts

@@ -0,0 +1,2 @@
+export declare function globalStageflowHome(): string;
+export declare function ensureGlobalHome(): string;

package/dist/project/globalHome.js

@@ -0,0 +1,19 @@
+import { chmodSync, mkdirSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function globalStageflowHome() {
+    return path.join(os.homedir(), ".stageflow");
+}
+export function ensureGlobalHome() {
+    const globalHome = globalStageflowHome();
+    mkdirSync(globalHome, { recursive: true });
+    const agentDir = path.join(globalHome, "agent");
+    mkdirSync(agentDir, { recursive: true });
+    try {
+        chmodSync(agentDir, 0o700);
+    }
+    catch {
+        // best-effort on non-POSIX
+    }
+    return globalHome;
+}

package/dist/project/resolveProjectContext.d.ts

@@ -0,0 +1,9 @@
+export type ProjectContext = {
+    invocationCwd: string;
+    projectRoot: string;
+    globalHome: string;
+    isGitProject: boolean;
+};
+export declare function resolveProjectContext(invocationCwd: string): ProjectContext;
+export declare function legacyProjectContext(cwd: string): ProjectContext;
+export declare function asProjectContext(input: ProjectContext | string): ProjectContext;

package/dist/project/resolveProjectContext.js

@@ -0,0 +1,38 @@
+import os from "node:os";
+import path from "node:path";
+import { findProjectRoot } from "./findProjectRoot.js";
+import { ensureGlobalHome, globalStageflowHome } from "./globalHome.js";
+export function resolveProjectContext(invocationCwd) {
+    const resolvedInvocation = path.resolve(invocationCwd);
+    const gitRoot = findProjectRoot(resolvedInvocation);
+    const globalHome = ensureGlobalHome();
+    if (gitRoot !== null) {
+        return {
+            invocationCwd: resolvedInvocation,
+            projectRoot: gitRoot,
+            globalHome,
+            isGitProject: true,
+        };
+    }
+    return {
+        invocationCwd: resolvedInvocation,
+        projectRoot: os.homedir(),
+        globalHome,
+        isGitProject: false,
+    };
+}
+export function legacyProjectContext(cwd) {
+    const invocationCwd = path.resolve(cwd);
+    return {
+        invocationCwd,
+        projectRoot: invocationCwd,
+        globalHome: globalStageflowHome(),
+        isGitProject: false,
+    };
+}
+export function asProjectContext(input) {
+    if (typeof input !== "string") {
+        return input;
+    }
+    return resolveProjectContext(input);
+}

package/dist/project/resolveStageflowContext.d.ts

@@ -0,0 +1,11 @@
+import type { LoadedManifest } from "../types/stageflowManifest.js";
+import type { LoadIssue } from "../config/loadOutcome.js";
+import type { ProjectContext } from "./resolveProjectContext.js";
+export type CatalogManifestStatus = "ok" | "missing" | "invalid" | "not_git";
+export type StageflowContext = ProjectContext & {
+    manifest: LoadedManifest | null;
+    manifestStatus: CatalogManifestStatus;
+    manifestIssues: LoadIssue[];
+};
+export declare function projectContextFromStageflow(ctx: StageflowContext): ProjectContext;
+export declare function resolveStageflowContext(invocationCwd: string): Promise<StageflowContext>;

package/dist/project/resolveStageflowContext.js

@@ -0,0 +1,66 @@
+import { access } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { loadStageflowManifestOutcome, manifestPathForProject, } from "../config/loadStageflowManifest.js";
+import { findProjectRoot } from "./findProjectRoot.js";
+import { ensureGlobalHome } from "./globalHome.js";
+export function projectContextFromStageflow(ctx) {
+    return {
+        invocationCwd: ctx.invocationCwd,
+        projectRoot: ctx.projectRoot,
+        globalHome: ctx.globalHome,
+        isGitProject: ctx.isGitProject,
+    };
+}
+export async function resolveStageflowContext(invocationCwd) {
+    const resolvedInvocation = path.resolve(invocationCwd);
+    const gitRoot = findProjectRoot(resolvedInvocation);
+    const globalHome = ensureGlobalHome();
+    if (gitRoot === null) {
+        return {
+            invocationCwd: resolvedInvocation,
+            projectRoot: os.homedir(),
+            globalHome,
+            isGitProject: false,
+            manifest: null,
+            manifestStatus: "not_git",
+            manifestIssues: [],
+        };
+    }
+    const manifestPath = manifestPathForProject(gitRoot);
+    try {
+        await access(manifestPath);
+    }
+    catch {
+        return {
+            invocationCwd: resolvedInvocation,
+            projectRoot: gitRoot,
+            globalHome,
+            isGitProject: true,
+            manifest: null,
+            manifestStatus: "missing",
+            manifestIssues: [],
+        };
+    }
+    const outcome = await loadStageflowManifestOutcome(gitRoot);
+    if (!outcome.ok) {
+        return {
+            invocationCwd: resolvedInvocation,
+            projectRoot: gitRoot,
+            globalHome,
+            isGitProject: true,
+            manifest: null,
+            manifestStatus: "invalid",
+            manifestIssues: outcome.issues,
+        };
+    }
+    return {
+        invocationCwd: resolvedInvocation,
+        projectRoot: gitRoot,
+        globalHome,
+        isGitProject: true,
+        manifest: outcome.value,
+        manifestStatus: "ok",
+        manifestIssues: [],
+    };
+}

package/dist/projection/projectRun.d.ts

@@ -0,0 +1,44 @@
+import type { RunDetail, StageSnapshot } from "../runstore/port.js";
+import type { PipelineTrackProjection, RunSummary } from "../runstore/port.js";
+import type { AskOperatorPrompt } from "../tools/askOperator.js";
+import type { StageEnvelope } from "../types/envelope.js";
+import type { CloneForkItem } from "../types/forkChoice.js";
+export type StageProjection = {
+    stage_id: string;
+    status: StageSnapshot["status"];
+    envelope: {
+        status: StageEnvelope["status"];
+        summary: string;
+        artifacts: string[];
+        payload?: Record<string, unknown>;
+        fork_choice?: string[];
+        clone_forks?: CloneForkItem[];
+    } | null;
+    artifacts: string[];
+    last_at?: string;
+    pending_prompt?: AskOperatorPrompt;
+};
+export type RunProjection = {
+    run_id: string;
+    pipeline_id: string;
+    task_id?: string;
+    pipeline_path?: string;
+    task_path?: string;
+    project_root?: string;
+    status: RunDetail["status"];
+    created_at: string;
+    updated_at?: string;
+    stages: StageProjection[];
+    pipeline_track: PipelineTrackProjection;
+    waiting_stage_id?: RunSummary["waiting_stage_id"];
+    waiting_stage_ids?: RunSummary["waiting_stage_ids"];
+    waiting_summary?: RunSummary["waiting_summary"];
+    waiting_kind?: RunSummary["waiting_kind"];
+    waiting_prompt_id?: RunSummary["waiting_prompt_id"];
+    waiting_artifacts?: RunSummary["waiting_artifacts"];
+    waiting_questions?: RunSummary["waiting_questions"];
+    failed_stage_id?: RunSummary["failed_stage_id"];
+    failed_reason?: RunSummary["failed_reason"];
+};
+export declare function projectRun(detail: RunDetail): RunProjection;
+export { projectRun as projectRunForMcp };

package/dist/projection/projectRun.js

@@ -0,0 +1,71 @@
+export function projectRun(detail) {
+    return {
+        run_id: detail.run_id,
+        pipeline_id: detail.pipeline_id,
+        task_id: detail.task_id,
+        ...(detail.pipeline_path !== undefined
+            ? { pipeline_path: detail.pipeline_path }
+            : {}),
+        ...(detail.task_path !== undefined ? { task_path: detail.task_path } : {}),
+        ...(detail.project_root !== undefined
+            ? { project_root: detail.project_root }
+            : {}),
+        status: detail.status,
+        created_at: detail.created_at,
+        updated_at: detail.updated_at,
+        pipeline_track: detail.pipeline_track,
+        ...(detail.waiting_stage_id !== undefined
+            ? { waiting_stage_id: detail.waiting_stage_id }
+            : {}),
+        ...(detail.waiting_stage_ids !== undefined
+            ? { waiting_stage_ids: detail.waiting_stage_ids }
+            : {}),
+        ...(detail.waiting_summary !== undefined
+            ? { waiting_summary: detail.waiting_summary }
+            : {}),
+        ...(detail.waiting_kind !== undefined
+            ? { waiting_kind: detail.waiting_kind }
+            : {}),
+        ...(detail.waiting_prompt_id !== undefined
+            ? { waiting_prompt_id: detail.waiting_prompt_id }
+            : {}),
+        ...(detail.waiting_artifacts !== undefined
+            ? { waiting_artifacts: detail.waiting_artifacts }
+            : {}),
+        ...(detail.waiting_questions !== undefined
+            ? { waiting_questions: detail.waiting_questions }
+            : {}),
+        ...(detail.failed_stage_id !== undefined
+            ? { failed_stage_id: detail.failed_stage_id }
+            : {}),
+        ...(detail.failed_reason !== undefined
+            ? { failed_reason: detail.failed_reason }
+            : {}),
+        stages: detail.stages.map((stage) => ({
+            stage_id: stage.stage_id,
+            status: stage.status,
+            envelope: stage.envelope
+                ? {
+                    status: stage.envelope.status,
+                    summary: stage.envelope.summary,
+                    artifacts: stage.envelope.artifacts,
+                    ...(stage.envelope.payload !== undefined
+                        ? { payload: stage.envelope.payload }
+                        : {}),
+                    ...(stage.envelope.fork_choice !== undefined
+                        ? { fork_choice: stage.envelope.fork_choice }
+                        : {}),
+                    ...(stage.envelope.clone_forks !== undefined
+                        ? { clone_forks: stage.envelope.clone_forks }
+                        : {}),
+                }
+                : null,
+            artifacts: stage.artifacts,
+            last_at: stage.last_at,
+            ...(stage.pending_prompt
+                ? { pending_prompt: stage.pending_prompt }
+                : {}),
+        })),
+    };
+}
+export { projectRun as projectRunForMcp };

package/dist/prompt/priorEnvelope.d.ts

@@ -1,2 +1,2 @@
 import type { StageEnvelope } from "../types/envelope.js";
-export declare function formatPriorEnvelope(priorEnvelope: StageEnvelope | null): string;
+export declare function formatPriorEnvelope(priorEnvelope: StageEnvelope | null, priorEnvelopes?: StageEnvelope[]): string;

package/dist/prompt/priorEnvelope.js

@@ -1,4 +1,7 @@
-export function formatPriorEnvelope(priorEnvelope) {
+export function formatPriorEnvelope(priorEnvelope, priorEnvelopes) {
+    if (priorEnvelopes !== undefined && priorEnvelopes.length > 0) {
+        return `Prior envelopes (${priorEnvelopes.length} clones, clone-list order):\n${JSON.stringify(priorEnvelopes, null, 2)}`;
+    }
     return priorEnvelope === null
         ? "No prior envelope (first stage)."
         : `Prior envelope JSON:\n${JSON.stringify(priorEnvelope, null, 2)}`;

package/dist/runstore/normalizeCatalogPath.d.ts

@@ -0,0 +1 @@
+export declare function normalizeCatalogPath(raw: string): string;

package/dist/runstore/normalizeCatalogPath.js

@@ -0,0 +1,4 @@
+import path from "node:path";
+export function normalizeCatalogPath(raw) {
+    return path.resolve(raw);
+}

package/dist/runstore/paths.js

@@ -1,6 +1,7 @@
 import { randomBytes } from "node:crypto";
 import { readdirSync, renameSync, rmdirSync, statSync } from "node:fs";
 import path from "node:path";
+import { guardStageId } from "./workspaceLayout.js";
 export function newRunId() {
     const stamp = new Date().toISOString().replace(/[:.]/g, "-");
     return `${stamp}-${randomBytes(3).toString("hex")}`;
@@ -56,5 +57,6 @@ export function runWorkspaceDir(storeRoot, runId) {
     return path.join(runsDir(storeRoot), runId);
 }
 export function stageDir(workspaceDir, stageId) {
+    guardStageId(stageId);
     return path.join(workspaceDir, "stages", stageId);
 }

package/dist/runstore/pipelineDagSnapshot.d.ts

@@ -3,3 +3,12 @@ import type { RunPipelineDagSnapshot } from "./port.js";
 export declare function buildPipelineDagSnapshotFromLoaded(loaded: LoadedPipeline): RunPipelineDagSnapshot;
 export declare function linearCompatDagSnapshot(stageIds: string[]): RunPipelineDagSnapshot;
 export declare function parsePipelineDagSnapshot(raw: unknown): RunPipelineDagSnapshot | null;
+export declare function instancesOfDefinition(snapshot: RunPipelineDagSnapshot, catalogId: string): string[];
+export declare function appendCloneInstances(snapshot: RunPipelineDagSnapshot, input: {
+    catalogId: string;
+    predecessorId: string;
+    count: number;
+}): {
+    snapshot: RunPipelineDagSnapshot;
+    instanceIds: string[];
+};

package/dist/runstore/pipelineDagSnapshot.js

@@ -1,3 +1,4 @@
+import { mintCloneInstanceIds } from "./stageInstanceId.js";
 export function buildPipelineDagSnapshotFromLoaded(loaded) {
     const gate_kinds = {};
     for (const stage of loaded.stages) {
@@ -7,7 +8,10 @@ export function buildPipelineDagSnapshotFromLoaded(loaded) {
     }
     return {
         stage_ids: [...loaded.pipeline.stages],
-        nodes: loaded.dag.nodes,
+        nodes: loaded.dag.nodes.map((node) => ({
+            ...node,
+            definition_id: node.id,
+        })),
         roots: loaded.dag.roots,
         childrenOf: loaded.dag.childrenOf,
         ...(Object.keys(gate_kinds).length > 0 ? { gate_kinds } : {}),
@@ -19,6 +23,7 @@ export function linearCompatDagSnapshot(stageIds) {
         needs: index === 0 ? null : stageIds[index - 1],
         ancestors: index === 0 ? [] : stageIds.slice(0, index),
         stageIndex: index,
+        definition_id: id,
     }));
     const childrenOf = {};
     for (let i = 1; i < stageIds.length; i++) {
@@ -41,3 +46,87 @@ export function parsePipelineDagSnapshot(raw) {
         return null;
     return raw;
 }
+export function instancesOfDefinition(snapshot, catalogId) {
+    const nodeById = new Map(snapshot.nodes.map((n) => [n.id, n]));
+    return snapshot.stage_ids.filter((id) => {
+        const node = nodeById.get(id);
+        return (node?.definition_id ?? node?.id) === catalogId;
+    });
+}
+export function appendCloneInstances(snapshot, input) {
+    const { catalogId, predecessorId, count } = input;
+    if (!snapshot.stage_ids.includes(catalogId)) {
+        throw new Error(`catalog stage "${catalogId}" is not in the run DAG snapshot`);
+    }
+    const predNode = snapshot.nodes.find((n) => n.id === predecessorId);
+    if (!predNode) {
+        throw new Error(`predecessor "${predecessorId}" is not in the run DAG snapshot`);
+    }
+    const instanceIds = mintCloneInstanceIds(catalogId, count);
+    for (const id of instanceIds) {
+        if (snapshot.stage_ids.includes(id) ||
+            snapshot.nodes.some((n) => n.id === id)) {
+            throw new Error(`instance id "${id}" already exists in the run DAG snapshot`);
+        }
+    }
+    const catalogNode = snapshot.nodes.find((n) => n.id === catalogId);
+    if (!catalogNode) {
+        throw new Error(`catalog stage "${catalogId}" is not in the run DAG snapshot`);
+    }
+    const catalogIdx = snapshot.stage_ids.indexOf(catalogId);
+    const stage_ids = [
+        ...snapshot.stage_ids.slice(0, catalogIdx),
+        ...instanceIds,
+        ...snapshot.stage_ids.slice(catalogIdx + 1),
+    ];
+    const instanceNodes = instanceIds.map((id) => ({
+        id,
+        definition_id: catalogId,
+        needs: predecessorId,
+        ancestors: [...predNode.ancestors, predecessorId],
+        stageIndex: 0,
+        ...(catalogNode.fork !== undefined ? { fork: catalogNode.fork } : {}),
+    }));
+    const remaining = new Map(snapshot.nodes
+        .filter((n) => n.id !== catalogId)
+        .map((n) => [n.id, n]));
+    const minted = new Map(instanceNodes.map((n) => [n.id, n]));
+    const nodes = stage_ids.map((id, index) => {
+        const node = minted.get(id) ?? remaining.get(id);
+        if (!node) {
+            throw new Error(`missing node for "${id}" after clone fan-out`);
+        }
+        return { ...node, stageIndex: index };
+    });
+    const childrenOf = {};
+    for (const [key, children] of Object.entries(snapshot.childrenOf)) {
+        childrenOf[key] = [...children];
+    }
+    const predChildren = childrenOf[predecessorId] ?? [];
+    const predIdx = predChildren.indexOf(catalogId);
+    childrenOf[predecessorId] =
+        predIdx === -1
+            ? [...predChildren, ...instanceIds]
+            : [
+                ...predChildren.slice(0, predIdx),
+                ...instanceIds,
+                ...predChildren.slice(predIdx + 1),
+            ];
+    const definitionParent = catalogNode.needs;
+    if (definitionParent && definitionParent !== predecessorId) {
+        const parentChildren = childrenOf[definitionParent] ?? [];
+        childrenOf[definitionParent] = parentChildren.filter((id) => id !== catalogId);
+        if (childrenOf[definitionParent].length === 0) {
+            delete childrenOf[definitionParent];
+        }
+    }
+    return {
+        snapshot: {
+            ...snapshot,
+            stage_ids,
+            nodes,
+            childrenOf,
+        },
+        instanceIds,
+    };
+}

package/dist/runstore/port.d.ts

@@ -18,6 +18,7 @@ export type PipelineTrackNode = {
     blocked_by?: string[];
     gate_kinds?: StageGateKind[];
     attempt_count?: number;
+    definition_id?: string;
 };
 export type PipelineTrackEdge = {
     from: string;
@@ -40,6 +41,9 @@ export type RunMeta = {
     ci_pr_url?: string;
     ci_job_url?: string;
     pipeline_dag?: RunPipelineDagSnapshot;
+    pipeline_path?: string;
+    task_path?: string;
+    project_root?: string;
 };
 export type CreatedRun = {
     runId: string;
@@ -52,7 +56,8 @@ export type StageLogEvent = StageLogLine & {
 };
 export type StageSnapshot = {
     stage_id: string;
-    status: "pending" | "running" | "waiting_for_input" | "succeeded" | "failed";
+    definition_id?: string;
+    status: "pending" | "running" | "waiting_for_input" | "succeeded" | "failed" | "skipped";
     events: StageLogEvent[];
     envelope: StageEnvelope | null;
     artifacts: string[];
@@ -79,11 +84,15 @@ export type CompactStage = {
     id: string;
     status: StageSnapshot["status"];
     attempt_count: number;
+    definition_id?: string;
 };
 export type RunSummary = {
     run_id: string;
     pipeline_id: string;
     task_id?: string;
+    pipeline_path?: string;
+    task_path?: string;
+    project_root?: string;
     status: RunStatus;
     created_at: string;
     updated_at?: string;
@@ -115,6 +124,16 @@ export type CreateRunInput = {
     ciPrUrl?: string;
     ciJobUrl?: string;
     pipelineDag?: RunPipelineDagSnapshot;
+    pipelinePath?: string;
+    taskPath?: string;
+    projectRoot?: string;
+};
+export type ListRunsFilter = {
+    status?: RunStatus;
+    /** ISO timestamp; keep runs with created_at >= since */
+    since?: string;
+    /** Match pipeline_id or pipeline_path */
+    pipeline?: string;
 };
 /**
  * Persistence port for pipeline run state.
@@ -145,8 +164,9 @@ export interface RunStore {
         attempt?: number;
     }): Promise<void>;
     listStageEvents(runId: string, stageId: string, attempt?: number): Promise<StageLogEvent[]>;
-    listRuns(): Promise<RunSummary[]>;
+    listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
     readRun(runId: string): Promise<RunDetail>;
+    updatePipelineDag(runId: string, dag: RunPipelineDagSnapshot): Promise<void>;
 }
 export declare function stageStatusFromEvents(events: StageLogEvent[]): StageSnapshot["status"];
 export declare function deriveStatusFromStages(stages: StageSnapshot[]): RunStatus;

package/dist/runstore/port.js

@@ -9,6 +9,8 @@ export function stageStatusFromEvents(events) {
             status = "succeeded";
         if (ev.event === "failed")
             status = "failed";
+        if (ev.event === "skipped")
+            status = "skipped";
     }
     return status;
 }
@@ -17,8 +19,9 @@ export function deriveStatusFromStages(stages) {
         return "created";
     if (stages.some((s) => s.status === "failed"))
         return "failed";
-    if (stages.every((s) => s.status === "succeeded"))
+    if (stages.every((s) => s.status === "succeeded" || s.status === "skipped")) {
         return "succeeded";
+    }
     if (stages.some((s) => s.status === "running" ||
         s.status === "waiting_for_input" ||
         s.status === "succeeded")) {

package/dist/runstore/runProjection.d.ts

@@ -1,6 +1,6 @@
 import type { RunDetail, RunMeta, RunPipelineDagSnapshot, RunSummary, StageSnapshot } from "./port.js";
 export { syntheticPendingSnapshot } from "./syntheticStageSnapshot.js";
-export declare function overlayPlannedStages(stageIds: string[], snapshots: StageSnapshot[]): StageSnapshot[];
+export declare function overlayPlannedStages(stageIds: string[], snapshots: StageSnapshot[], dag?: Pick<RunPipelineDagSnapshot, "nodes"> | null): StageSnapshot[];
 export declare function orderStageSnapshots(stageIds: string[], snapshots: StageSnapshot[]): StageSnapshot[];
 export declare function projectRunSummary(meta: RunMeta, stages: StageSnapshot[]): RunSummary;
 export declare function projectRunDetail(meta: RunMeta, stages: StageSnapshot[], task_yaml: string, dagSnapshot?: RunPipelineDagSnapshot | null): RunDetail;

package/dist/runstore/runProjection.js

@@ -3,9 +3,19 @@ import { linearCompatDagSnapshot } from "./pipelineDagSnapshot.js";
 import { syntheticPendingSnapshot } from "./syntheticStageSnapshot.js";
 import { buildPipelineTrack } from "./trackProjection.js";
 export { syntheticPendingSnapshot } from "./syntheticStageSnapshot.js";
-export function overlayPlannedStages(stageIds, snapshots) {
+export function overlayPlannedStages(stageIds, snapshots, dag) {
     const byId = new Map(snapshots.map((s) => [s.stage_id, s]));
-    return stageIds.map((id) => byId.get(id) ?? syntheticPendingSnapshot(id));
+    const nodeById = new Map((dag?.nodes ?? []).map((n) => [n.id, n]));
+    return stageIds.map((id) => {
+        const node = nodeById.get(id);
+        const definitionId = node?.definition_id ?? node?.id;
+        const existing = byId.get(id);
+        const base = existing ?? syntheticPendingSnapshot(id, definitionId);
+        if (definitionId === undefined || base.definition_id === definitionId) {
+            return base;
+        }
+        return { ...base, definition_id: definitionId };
+    });
 }
 export function orderStageSnapshots(stageIds, snapshots) {
     return overlayPlannedStages(stageIds, snapshots);
@@ -15,6 +25,7 @@ function compactStages(stages) {
         id: s.stage_id,
         status: s.status,
         attempt_count: s.attempt_count,
+        ...(s.definition_id !== undefined ? { definition_id: s.definition_id } : {}),
     }));
 }
 function waitingSummaryFromPrompt(prompt) {
@@ -65,14 +76,24 @@ function failedFieldsFromStages(stages) {
     };
 }
 function resolveListedStatus(stages, meta) {
+    if (stages.length === 0)
+        return meta.status ?? "created";
     const derived = deriveStatusFromStages(stages);
-    return stages.length > 0 ? derived : (meta.status ?? derived);
+    if (meta.status === "succeeded" && derived === "running") {
+        const hasActiveStage = stages.some((s) => s.status === "running" || s.status === "waiting_for_input");
+        if (!hasActiveStage)
+            return "succeeded";
+    }
+    return derived;
 }
 export function projectRunSummary(meta, stages) {
     return {
         run_id: meta.run_id,
         pipeline_id: meta.pipeline_id,
         task_id: meta.task_id,
+        ...(meta.pipeline_path !== undefined ? { pipeline_path: meta.pipeline_path } : {}),
+        ...(meta.task_path !== undefined ? { task_path: meta.task_path } : {}),
+        ...(meta.project_root !== undefined ? { project_root: meta.project_root } : {}),
         status: resolveListedStatus(stages, meta),
         created_at: meta.created_at,
         updated_at: meta.updated_at,
@@ -83,7 +104,7 @@ export function projectRunSummary(meta, stages) {
 }
 export function projectRunDetail(meta, stages, task_yaml, dagSnapshot) {
     const ordered = dagSnapshot
-        ? overlayPlannedStages(dagSnapshot.stage_ids, stages)
+        ? overlayPlannedStages(dagSnapshot.stage_ids, stages, dagSnapshot)
         : stages;
     const summary = projectRunSummary(meta, ordered);
     const snapshot = dagSnapshot ??