stageflow 0.1.0 → 0.3.0

package/dist/runtime/settingsFile.d.ts

@@ -1,3 +1,5 @@
+import type { ProjectContext } from "../project/resolveProjectContext.js";
+import type { StageflowContext } from "../project/resolveStageflowContext.js";
 export declare const SETTINGS_FILE_NAME = "settings.json";
 export declare const INVALID_SLOT_COUNT_MESSAGE = "maxConcurrent must be an integer >= 1";
 export declare const INVALID_CREDENTIAL_SOURCE_MESSAGE = "credentialSource must be \"pi_home\" or \"sf_owned\"";
@@ -6,12 +8,22 @@ export type FactorySettings = {
     maxConcurrent?: number;
     credentialSource?: CredentialSource;
 };
+export declare function globalSettingsFilePath(): string;
+export declare function settingsFilePathForContext(ctx: ProjectContext | StageflowContext): string;
 export declare function settingsFilePath(cwd: string): string;
 export declare function parseSlotCount(value: unknown): number | undefined;
 export declare function parseCredentialSource(value: unknown): CredentialSource | undefined;
+export declare function readCredentialSourceFromContext(ctx: ProjectContext): CredentialSource | undefined;
+export declare function readPersistedCredentialSourceFromContext(ctx: ProjectContext): CredentialSource | undefined;
+export declare function readFactorySettingsForContext(ctx: ProjectContext): FactorySettings;
 export declare function readFactorySettings(cwd: string): FactorySettings;
+export declare function writeFactorySettingsForContext(ctx: ProjectContext, patch: FactorySettings): void;
 export declare function writeFactorySettings(cwd: string, patch: FactorySettings): void;
+export declare function readMaxConcurrentFromContext(ctx: ProjectContext): number | undefined;
 export declare function readMaxConcurrentFromFile(cwd: string): number | undefined;
+export declare function writeMaxConcurrentToContext(ctx: ProjectContext, maxConcurrent: number): void;
 export declare function writeMaxConcurrentToFile(cwd: string, maxConcurrent: number): void;
 export declare function readCredentialSourceFromFile(cwd: string): CredentialSource | undefined;
+export declare function writeCredentialSourceToContext(ctx: ProjectContext, credentialSource: CredentialSource): void;
 export declare function writeCredentialSourceToFile(cwd: string, credentialSource: CredentialSource): void;
+export declare function projectSettingsContext(cwd: string, projectRoot: string, isGitProject: boolean): ProjectContext;

package/dist/runtime/settingsFile.js

@@ -1,11 +1,25 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
 import path from "node:path";
+import { globalStageflowHome } from "../project/globalHome.js";
 import { storeRootFor } from "../runstore/paths.js";
 export const SETTINGS_FILE_NAME = "settings.json";
 export const INVALID_SLOT_COUNT_MESSAGE = "maxConcurrent must be an integer >= 1";
 export const INVALID_CREDENTIAL_SOURCE_MESSAGE = 'credentialSource must be "pi_home" or "sf_owned"';
+export function globalSettingsFilePath() {
+    return path.join(globalStageflowHome(), SETTINGS_FILE_NAME);
+}
+export function settingsFilePathForContext(ctx) {
+    if (ctx.isGitProject) {
+        return path.join(storeRootFor(ctx.projectRoot), SETTINGS_FILE_NAME);
+    }
+    if (path.resolve(ctx.projectRoot) === path.resolve(os.homedir())) {
+        return path.join(ctx.globalHome, SETTINGS_FILE_NAME);
+    }
+    return path.join(storeRootFor(ctx.projectRoot), SETTINGS_FILE_NAME);
+}
 export function settingsFilePath(cwd) {
-    return path.join(storeRootFor(cwd), SETTINGS_FILE_NAME);
+    return path.join(storeRootFor(path.resolve(cwd)), SETTINGS_FILE_NAME);
 }
 export function parseSlotCount(value) {
     if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
@@ -19,8 +33,7 @@ export function parseCredentialSource(value) {
     }
     return undefined;
 }
-function readRawSettings(cwd) {
-    const filePath = settingsFilePath(cwd);
+function readRawSettingsFromFile(filePath) {
     if (!existsSync(filePath))
         return {};
     try {
@@ -34,8 +47,10 @@ function readRawSettings(cwd) {
         return {};
     }
 }
-export function readFactorySettings(cwd) {
-    const raw = readRawSettings(cwd);
+function readRawSettings(ctx) {
+    return readRawSettingsFromFile(settingsFilePathForContext(ctx));
+}
+function parseFactorySettingsFromRaw(raw) {
     const settings = {};
     const maxConcurrent = parseSlotCount(raw.maxConcurrent);
     if (maxConcurrent !== undefined) {
@@ -47,6 +62,54 @@ export function readFactorySettings(cwd) {
     }
     return settings;
 }
+export function readCredentialSourceFromContext(ctx) {
+    if (ctx.isGitProject) {
+        const fromProject = parseCredentialSource(readRawSettingsFromFile(settingsFilePathForContext(ctx)).credentialSource);
+        if (fromProject !== undefined) {
+            return fromProject;
+        }
+    }
+    return parseCredentialSource(readRawSettingsFromFile(globalSettingsFilePath()).credentialSource);
+}
+export function readPersistedCredentialSourceFromContext(ctx) {
+    return parseCredentialSource(readRawSettingsFromFile(settingsFilePathForContext(ctx)).credentialSource);
+}
+export function readFactorySettingsForContext(ctx) {
+    return parseFactorySettingsFromRaw(readRawSettings(ctx));
+}
+export function readFactorySettings(cwd) {
+    return parseFactorySettingsFromRaw(readRawSettingsFromFile(settingsFilePath(cwd)));
+}
+function ensureSettingsDirForContext(ctx) {
+    mkdirSync(path.dirname(settingsFilePathForContext(ctx)), { recursive: true });
+}
+export function writeFactorySettingsForContext(ctx, patch) {
+    if (patch.credentialSource !== undefined &&
+        parseCredentialSource(patch.credentialSource) === undefined) {
+        throw new Error(INVALID_CREDENTIAL_SOURCE_MESSAGE);
+    }
+    if (patch.maxConcurrent !== undefined &&
+        parseSlotCount(patch.maxConcurrent) === undefined) {
+        throw new Error(INVALID_SLOT_COUNT_MESSAGE);
+    }
+    const current = readFactorySettingsForContext(ctx);
+    const next = { ...current };
+    if (patch.maxConcurrent !== undefined) {
+        next.maxConcurrent = patch.maxConcurrent;
+    }
+    if (patch.credentialSource !== undefined) {
+        next.credentialSource = patch.credentialSource;
+    }
+    const out = {};
+    if (next.maxConcurrent !== undefined) {
+        out.maxConcurrent = next.maxConcurrent;
+    }
+    if (next.credentialSource !== undefined) {
+        out.credentialSource = next.credentialSource;
+    }
+    ensureSettingsDirForContext(ctx);
+    writeFileSync(settingsFilePathForContext(ctx), `${JSON.stringify(out, null, 2)}\n`, "utf8");
+}
 export function writeFactorySettings(cwd, patch) {
     if (patch.credentialSource !== undefined &&
         parseCredentialSource(patch.credentialSource) === undefined) {
@@ -71,18 +134,36 @@ export function writeFactorySettings(cwd, patch) {
     if (next.credentialSource !== undefined) {
         out.credentialSource = next.credentialSource;
     }
-    mkdirSync(storeRootFor(cwd), { recursive: true });
+    const root = path.resolve(cwd);
+    mkdirSync(storeRootFor(root), { recursive: true });
     writeFileSync(settingsFilePath(cwd), `${JSON.stringify(out, null, 2)}\n`, "utf8");
 }
+export function readMaxConcurrentFromContext(ctx) {
+    return readFactorySettingsForContext(ctx).maxConcurrent;
+}
 export function readMaxConcurrentFromFile(cwd) {
     return readFactorySettings(cwd).maxConcurrent;
 }
+export function writeMaxConcurrentToContext(ctx, maxConcurrent) {
+    writeFactorySettingsForContext(ctx, { maxConcurrent });
+}
 export function writeMaxConcurrentToFile(cwd, maxConcurrent) {
     writeFactorySettings(cwd, { maxConcurrent });
 }
 export function readCredentialSourceFromFile(cwd) {
     return readFactorySettings(cwd).credentialSource;
 }
+export function writeCredentialSourceToContext(ctx, credentialSource) {
+    writeFactorySettingsForContext(ctx, { credentialSource });
+}
 export function writeCredentialSourceToFile(cwd, credentialSource) {
     writeFactorySettings(cwd, { credentialSource });
 }
+export function projectSettingsContext(cwd, projectRoot, isGitProject) {
+    return {
+        invocationCwd: path.resolve(cwd),
+        projectRoot: path.resolve(projectRoot),
+        globalHome: globalStageflowHome(),
+        isGitProject,
+    };
+}

package/dist/runtime/stageAttemptBootstrap.js

@@ -1,4 +1,5 @@
 import { resolveSkillByName } from "../config/listSkills.js";
+import { resolveForkEmitContext } from "../config/resolveForkEmitContext.js";
 import { buildCompletedEnvelopesFromRun, resolvePriorEnvelope, } from "./envelopeRouting.js";
 import { resumeSessionFilePath } from "./stageAttemptContext.js";
 import { buildStageRoots, rootsForStageWorker, withResolvedAuthPath, } from "./stageRoots.js";
@@ -63,6 +64,7 @@ export async function openStageAttempt(input) {
     const attempt = input.attemptCtx?.attempt ?? 1;
     const resumeToken = input.resumeToken ??
         resumeSessionFilePath(input.workspaceDir, input.stage.id, attempt);
+    const forkEmitContext = resolveForkEmitContext(input.dag, input.stage.id);
     const opened = await openStageWithOperatorCatalog(input.agent, {
         roots,
         stage: input.stage,
@@ -70,6 +72,7 @@ export async function openStageAttempt(input) {
         priorEnvelope: priorResult.prior,
         resumeToken,
         onActivity: input.onActivity,
+        forkEmitContext,
     }, input.operatorCatalog);
     if (!opened.ok)
         return opened;

package/dist/runtime/stageProcessLauncher.d.ts

@@ -8,6 +8,7 @@ export type StageLaunchInput = {
     attempt?: number;
     sessionFilePath?: string;
     operatorCatalog?: OperatorCatalog;
+    skipGates?: boolean;
 };
 export type StageLaunchResult = {
     type: "succeeded";

package/dist/runtime/stageProcessLauncher.js

@@ -132,9 +132,15 @@ export class StageProcessLauncher {
         if (input.sessionFilePath !== undefined) {
             args.push("--session-file", input.sessionFilePath);
         }
+        if (input.operatorCatalog?.cwd !== undefined) {
+            args.push("--operator-cwd", input.operatorCatalog.cwd);
+        }
         if (input.operatorCatalog?.agentDir !== undefined) {
             args.push("--operator-agent-dir", input.operatorCatalog.agentDir);
         }
+        if (input.skipGates) {
+            args.push("--skip-gates");
+        }
         const child = fork(this.cliEntry, args, {
             cwd: input.rootDir,
             env: { ...process.env, ...this.env, [SF_STAGE_WORKER]: "1" },

package/dist/runtime/stageRecovery.js

@@ -34,9 +34,11 @@ export async function failStageAsInterrupted(options) {
     }
 }
 export async function syncRunStatusFromStages(store, runId) {
+    const meta = await store.readRunMeta(runId);
+    if (meta.status === "succeeded")
+        return;
     const run = await store.readRun(runId);
     const derived = deriveStatusFromStages(run.stages);
-    const meta = await store.readRunMeta(runId);
     if ((meta.status ?? "created") !== derived) {
         await store.updateRunStatus(runId, derived);
     }

package/dist/runtime/stageRunner.d.ts

@@ -43,6 +43,7 @@ export type RunStageOptions = {
     factoryCwd?: string;
     operatorCatalog?: OperatorCatalog;
     completedEnvelopes?: Map<string, StageEnvelope>;
+    skipGates?: boolean;
 };
 /**
  * Yield loop: next() until completed; on wait, coordinator enterWait (KTD6).
@@ -55,5 +56,6 @@ export declare function runStageYieldLoop(options: {
     workerMode?: boolean;
     store?: RunStore;
     attemptCtx?: StageAttemptContext;
+    skipGates?: boolean;
 }): Promise<RunStageYieldLoopResult>;
 export declare function runStage(options: RunStageOptions): Promise<RunStageOutcome>;

package/dist/runtime/stageRunner.js

@@ -73,10 +73,16 @@ async function finalizeStageResult(options) {
  * Yield loop: next() until completed; on wait, coordinator enterWait (KTD6).
  */
 export async function runStageYieldLoop(options) {
-    const { handle, runId, stageId, hitl, workerMode, store, attemptCtx } = options;
+    const { handle, runId, stageId, hitl, workerMode, store, attemptCtx, skipGates } = options;
     while (true) {
         const event = await handle.next();
         if (event.status === "waiting_for_input") {
+            if (skipGates) {
+                return {
+                    ok: false,
+                    reason: "skip-gates: stage requested wait",
+                };
+            }
             if (workerMode) {
                 if (!store) {
                     return {
@@ -107,7 +113,7 @@ export async function runStageYieldLoop(options) {
     }
 }
 export async function runStage(options) {
-    const { agent, store, runId, stage, task, dag, checkoutRoot, workspaceDir, hitl, skipStarted, existingHandle, workerMode, roots: rootsOverride, attemptCtx, factoryCwd, operatorCatalog, completedEnvelopes, } = options;
+    const { agent, store, runId, stage, task, dag, checkoutRoot, workspaceDir, hitl, skipStarted, existingHandle, workerMode, roots: rootsOverride, attemptCtx, factoryCwd, operatorCatalog, completedEnvelopes, skipGates, } = options;
     const attemptOpt = attemptCtx?.eventOptions();
     const baseRoots = rootsOverride ??
         buildStageRoots(workspaceDir ?? store.getWorkspaceDir(runId), stage.id, checkoutRoot, attemptCtx);
@@ -183,6 +189,7 @@ export async function runStage(options) {
             workerMode,
             store: workerMode ? store : undefined,
             attemptCtx,
+            skipGates,
         });
     }
     catch (err) {

package/dist/runtime/stageWorker.js

@@ -1,7 +1,6 @@
 import { PiAgentAdapter } from "../agent/piAdapter.js";
-import { loadPipeline } from "../config/loadPipeline.js";
-import { loadTaskFromYaml } from "../config/loadTask.js";
 import { createRunStore } from "../runstore/createStore.js";
+import { loadRunContext } from "./resumeReconstruct.js";
 import { bindPiAgentDirEnv, rootsForStageWorker, withResolvedAuthPath, } from "./stageRoots.js";
 import { runStage, isRunStageWaiting, } from "./stageRunner.js";
 import { openStageAttempt } from "./stageAttemptBootstrap.js";
@@ -9,10 +8,7 @@ import { attemptContext } from "./stageAttemptContext.js";
 import { outcomeToWorkerResult, STAGE_WORKER_EXIT, } from "./stageWorkerProtocol.js";
 export async function runStageWorker(input) {
     const store = createRunStore({ rootDir: input.rootDir });
-    const meta = await store.readRunMeta(input.runId);
-    const taskYaml = await store.readTaskYaml(input.runId);
-    const task = loadTaskFromYaml(taskYaml, `run ${input.runId} task`);
-    const loaded = await loadPipeline(meta.pipeline_id, { cwd: input.rootDir });
+    const { meta, task, loaded } = await loadRunContext(store, input.runId, input.rootDir);
     const stage = loaded.stages.find((s) => s.id === input.stageId);
     if (!stage) {
         return {
@@ -68,6 +64,7 @@ export async function runStageWorker(input) {
                 attemptCtx,
                 factoryCwd: input.rootDir,
                 operatorCatalog: input.operatorCatalog,
+                skipGates: input.skipGates,
             });
             return outcome;
         }
@@ -85,6 +82,7 @@ export async function runStageWorker(input) {
             attemptCtx,
             factoryCwd: input.rootDir,
             operatorCatalog: input.operatorCatalog,
+            skipGates: input.skipGates,
         });
     }
     finally {

package/dist/runtime/stageWorkerProtocol.d.ts

@@ -15,6 +15,7 @@ export type StageWorkerInput = {
     attempt?: number;
     sessionFilePath?: string;
     operatorCatalog?: OperatorCatalog;
+    skipGates?: boolean;
 };
 export type StageWorkerResult = {
     type: "succeeded";

package/dist/server/http.js

@@ -8,12 +8,14 @@ import { getCredentialSourceSettings, setCredentialSource, } from "../agent/prov
 import { handleProviderRoutes, providerAuthErrorBody, } from "./providerRoutes.js";
 import { createPipeline, parseCreatePipelineBody } from "../config/createPipeline.js";
 import { createStage, parseCreateStageBody } from "../config/createStage.js";
-import { listModels, listPipelines, listStages, listTasks, } from "../config/listConfig.js";
+import { browseCatalog } from "../config/browseCatalog.js";
 import { listExtensions } from "../config/listExtensions.js";
 import { listSkills } from "../config/listSkills.js";
 import { readRunArtifact } from "../mcp/readArtifact.js";
 import { handleMcpHttpRequest } from "../mcp/server.js";
 import { createRunStore } from "../runstore/createStore.js";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { findProjectRoot } from "../project/findProjectRoot.js";
 import { RunManager, } from "../runtime/runManager.js";
 import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, } from "../runtime/settingsFile.js";
 import { isTaskFile } from "../runtime/taskInput.js";
@@ -202,9 +204,14 @@ export function defaultUiDistDir() {
     return path.resolve(here, "../ui");
 }
 export async function startUiServer(options) {
-    const cwd = options.cwd ?? process.cwd();
+    const invocationCwd = options.cwd ?? process.cwd();
+    const ctx = await resolveStageflowContext(invocationCwd);
+    const cwd = ctx.invocationCwd;
     const agentDir = options.agentDir ?? getAgentDir();
-    const rootDir = options.rootDir ?? cwd;
+    const rootDir = options.rootDir ?? ctx.projectRoot;
+    const isGitProject = options.rootDir !== undefined
+        ? findProjectRoot(rootDir) !== null
+        : ctx.isGitProject;
     const host = options.host ?? "127.0.0.1";
     const port = options.port ?? DEFAULT_PORT;
     const providerAuthContext = options.providerAuthContext;
@@ -214,6 +221,8 @@ export async function startUiServer(options) {
     const manager = new RunManager({
         agent: options.agent,
         cwd,
+        projectRoot: rootDir,
+        isGitProject,
         store,
         maxConcurrent: options.maxConcurrent,
         operatorCatalog: { cwd, agentDir },
@@ -388,15 +397,19 @@ export async function startUiServer(options) {
                 return;
             }
             if (method === "GET" && pathname === "/api/tasks") {
-                json(res, 200, { tasks: await listTasks(cwd) });
+                const catalog = await browseCatalog(cwd);
+                json(res, 200, { tasks: catalog.tasks });
                 return;
             }
             if (method === "GET" && pathname === "/api/pipelines") {
-                json(res, 200, { pipelines: await listPipelines(cwd) });
+                const catalog = await browseCatalog(cwd);
+                json(res, 200, { pipelines: catalog.pipelines });
                 return;
             }
             if (method === "GET" && pathname === "/api/stages") {
-                json(res, 200, { stages: await listStages(cwd) });
+                json(res, 404, {
+                    error: "Global stage library removed; stages are pipeline-scoped",
+                });
                 return;
             }
             if (method === "POST" && pathname === "/api/stages") {
@@ -413,7 +426,12 @@ export async function startUiServer(options) {
                     json(res, parsed.status, { error: parsed.error });
                     return;
                 }
-                const result = await createStage(cwd, parsed);
+                const ctx = await resolveStageflowContext(cwd);
+                if (!ctx.isGitProject) {
+                    json(res, 400, { error: "Project root not found; initialize stageflow.yaml in a git repo" });
+                    return;
+                }
+                const result = await createStage(ctx.projectRoot, parsed);
                 if (!result.ok) {
                     json(res, result.status, { error: result.error });
                     return;
@@ -435,7 +453,12 @@ export async function startUiServer(options) {
                     json(res, parsed.status, { error: parsed.error });
                     return;
                 }
-                const result = await createPipeline(cwd, parsed);
+                const ctx = await resolveStageflowContext(cwd);
+                if (!ctx.isGitProject) {
+                    json(res, 400, { error: "Project root not found; initialize stageflow.yaml in a git repo" });
+                    return;
+                }
+                const result = await createPipeline(ctx.projectRoot, parsed);
                 if (!result.ok) {
                     json(res, result.status, { error: result.error });
                     return;
@@ -444,7 +467,8 @@ export async function startUiServer(options) {
                 return;
             }
             if (method === "GET" && pathname === "/api/models") {
-                json(res, 200, { models: await listModels(cwd) });
+                const catalog = await browseCatalog(cwd);
+                json(res, 200, { models: catalog.models });
                 return;
             }
             if (await handleProviderRoutes(req, res, {

package/dist/tools/emitStageEnvelope.d.ts

@@ -11,11 +11,12 @@
  */
 import { Type } from "typebox";
 import type { StageEnvelope } from "../types/envelope.js";
+import type { ForkEmitContext } from "../types/forkChoice.js";
 export type EmitCapture = {
     envelope?: StageEnvelope;
     error?: string;
 };
-export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloadSchema?: unknown): {
+export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloadSchema?: unknown, forkEmitContext?: ForkEmitContext): {
     name: string;
     label: string;
     description: string;
@@ -24,6 +25,7 @@ export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloa
         summary: Type.TString;
         artifacts: Type.TArray<Type.TString>;
         payload: Type.TSchema;
+        fork_choice: Type.TArray<Type.TString>;
         stage_id: Type.TOptional<Type.TString>;
         notes: Type.TOptional<Type.TString>;
     }>;

package/dist/tools/emitStageEnvelope.js

@@ -11,6 +11,7 @@
  */
 import { Type } from "typebox";
 import { assertRequiredEnvelope, isAdvancingEnvelope, } from "../envelope/check.js";
+import { normalizeForkChoice } from "../envelope/forkChoice.js";
 import { assertEnvelopePayload, compilePayloadSchema, } from "../envelope/payloadSchema.js";
 function toolResult(text, details, options) {
     return {
@@ -20,7 +21,7 @@ function toolResult(text, details, options) {
         ...(options?.terminate ? { terminate: true } : {}),
     };
 }
-export function createEmitStageEnvelopeTool(capture, payloadSchema) {
+export function createEmitStageEnvelopeTool(capture, payloadSchema, forkEmitContext) {
     const compiledPayload = payloadSchema !== undefined
         ? compilePayloadSchema(payloadSchema)
         : undefined;
@@ -35,6 +36,9 @@ export function createEmitStageEnvelopeTool(capture, payloadSchema) {
             payload: compiledPayload !== undefined
                 ? compiledPayload
                 : Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            fork_choice: forkEmitContext !== undefined
+                ? Type.Array(Type.String())
+                : Type.Optional(Type.Array(Type.String())),
             stage_id: Type.Optional(Type.String()),
             notes: Type.Optional(Type.String()),
         }),
@@ -43,6 +47,12 @@ export function createEmitStageEnvelopeTool(capture, payloadSchema) {
                 return toolResult("Envelope already accepted; later emits are ignored.", { advancing: isAdvancingEnvelope(capture.envelope), error: "" }, { terminate: true });
             }
             try {
+                if (forkEmitContext !== undefined) {
+                    const record = params;
+                    if (record.status !== "failure") {
+                        normalizeForkChoice(record.fork_choice, "emit", forkEmitContext);
+                    }
+                }
                 const envelope = assertRequiredEnvelope(params);
                 assertEnvelopePayload(envelope, payloadSchema);
                 capture.envelope = envelope;

package/dist/types/envelope.d.ts

@@ -4,6 +4,7 @@ export type StageEnvelope = {
     summary: string;
     artifacts: string[];
     payload?: Record<string, unknown>;
+    fork_choice?: string[];
     stage_id?: string;
     notes?: string;
 };

package/dist/types/forkChoice.d.ts

@@ -0,0 +1,8 @@
+export type ForkChoiceShape = {
+    cardinality: "one" | "subset";
+    allowNone: boolean;
+};
+export type ForkEmitContext = {
+    immediateSuccessorIds: string[];
+    forkShape: ForkChoiceShape | null;
+};

package/dist/types/forkChoice.js

@@ -0,0 +1 @@
+export {};

package/dist/types/pipeline.d.ts

@@ -1,17 +1,64 @@
+import type { StageConfig, StageGateKind } from "./stage.js";
 export type PipelineConfig = {
     id: string;
     stages: string[];
 };
+export type PipelineForkConfig = {
+    select: "one" | "subset";
+    allow_none: boolean;
+};
 export type PipelineStageRef = {
     id: string;
     needs?: string;
+    fork?: {
+        select: "one" | "subset";
+        allow_none?: boolean;
+    };
+};
+export type PipelineStageYamlEntry = PipelineStageRef & {
+    uses?: string;
+    system_prompt?: string;
+    model?: string;
+    payload_schema?: unknown;
+    gate_kinds?: StageGateKind[];
+    skill?: string;
+};
+export type PipelineIncludeEntry = {
+    local: string;
+};
+export type PipelineFragmentConfig = {
+    include?: PipelineIncludeEntry[];
+    stages?: PipelineStageYamlEntry[];
+};
+export type NormalizedPipelineStageEntry = {
+    id: string;
+    needs?: string;
+    fork?: {
+        select: "one" | "subset";
+        allow_none?: boolean;
+    };
+    body: {
+        kind: "inline";
+        raw: Record<string, unknown>;
+    } | {
+        kind: "uses";
+        path: string;
+        absolutePath: string;
+    };
+    declaringPath: string;
+};
+export type PipelineStageSource = {
+    kind: "inline";
+} | {
+    kind: "file";
+    path: string;
 };
-export type PipelineStageYamlEntry = string | PipelineStageRef;
 export type ResolvedPipelineStageNode = {
     id: string;
     needs: string | null;
     ancestors: string[];
     stageIndex: number;
+    fork?: PipelineForkConfig;
 };
 export type ResolvedPipelineDag = {
     nodes: ResolvedPipelineStageNode[];
@@ -20,6 +67,8 @@ export type ResolvedPipelineDag = {
 };
 export type LoadedPipeline = {
     pipeline: PipelineConfig;
-    stages: import("./stage.js").StageConfig[];
+    stages: StageConfig[];
     dag: ResolvedPipelineDag;
+    pipelinePath: string;
+    stageSources?: Record<string, PipelineStageSource>;
 };

package/dist/types/stageflowManifest.d.ts

@@ -0,0 +1,23 @@
+export type StageflowManifestVersion = 1;
+export type StageflowManifestCatalog = {
+    pipelines: string[];
+    tasks: string[];
+    patterns?: {
+        pipeline?: string;
+        task?: string;
+    };
+    exclude?: string[];
+};
+export type StageflowManifest = {
+    version: StageflowManifestVersion;
+    catalog: StageflowManifestCatalog;
+};
+export type LoadedManifest = {
+    path: string;
+    projectRoot: string;
+    manifest: StageflowManifest;
+    patterns: {
+        pipeline: string;
+        task: string;
+    };
+};

package/dist/types/stageflowManifest.js

@@ -0,0 +1 @@
+export {};