stageflow 0.2.0 → 0.8.0

package/dist/server/mcpHost.d.ts

@@ -0,0 +1,22 @@
+import type { AgentPort } from "../agent/port.js";
+import type { ProviderAuthContext } from "../agent/providerAuth.js";
+import type { RunStoreKind } from "../runstore/createStore.js";
+import type { RunStore } from "../runstore/port.js";
+import type { RunChangeBus } from "../runtime/runChangeBus.js";
+import { DEFAULT_PORT, type HttpHostEnvelope } from "./createHttpHost.js";
+export type McpServerOptions = {
+    agent: AgentPort;
+    cwd?: string;
+    agentDir?: string;
+    rootDir?: string;
+    store?: RunStore;
+    storeKind?: RunStoreKind;
+    port?: number;
+    host?: string;
+    maxConcurrent?: number;
+    providerAuthContext?: ProviderAuthContext;
+    mcpStateless?: boolean;
+    runChangeBus?: RunChangeBus;
+};
+export declare function startMcpServer(options: McpServerOptions): Promise<HttpHostEnvelope>;
+export { DEFAULT_PORT };

package/dist/server/mcpHost.js

@@ -0,0 +1,21 @@
+import { bootstrapStageflowHost, } from "./bootstrap.js";
+import { createHttpHost, DEFAULT_PORT, } from "./createHttpHost.js";
+export async function startMcpServer(options) {
+    const host = options.host ?? "127.0.0.1";
+    const port = options.port ?? DEFAULT_PORT;
+    const boot = await bootstrapStageflowHost(options);
+    return createHttpHost({
+        boot,
+        host,
+        port,
+        routes: async ({ method, pathname, res, json, boot: b }) => {
+            if (method === "GET" && pathname === "/api/health") {
+                json(res, 200, b.manager.getHealth());
+                return true;
+            }
+            json(res, 404, { error: "Not found" });
+            return true;
+        },
+    });
+}
+export { DEFAULT_PORT };

package/dist/server/operatorResults.d.ts

@@ -0,0 +1,13 @@
+import type { RetryStageResult, StartRunResult } from "../runtime/runManager.js";
+export declare function inferRetryStageErrorCode(reason: string): string | undefined;
+export declare function mapRetryStageFailure(result: Extract<RetryStageResult, {
+    ok: false;
+}>): {
+    error: string;
+    code?: string;
+} & Record<string, unknown>;
+export declare function mapStartFailure(result: Extract<StartRunResult, {
+    ok: false;
+}>): {
+    error: string;
+} & Record<string, unknown>;

package/dist/server/operatorResults.js

@@ -0,0 +1,22 @@
+export function inferRetryStageErrorCode(reason) {
+    if (/retry already in progress/i.test(reason))
+        return "retry_in_progress";
+    if (/waiting for input/i.test(reason))
+        return "hitl_not_retriable";
+    if (/already has active orchestration/i.test(reason))
+        return "run_not_retryable";
+    if (/run is not failed/i.test(reason))
+        return "run_not_retryable";
+    if (/stage is not failed/i.test(reason))
+        return "stage_not_failed";
+    return undefined;
+}
+export function mapRetryStageFailure(result) {
+    const { ok: _ok, status: _status, reason, ...rest } = result;
+    const code = inferRetryStageErrorCode(reason);
+    return { error: reason, ...(code ? { code } : {}), ...rest };
+}
+export function mapStartFailure(result) {
+    const { ok: _ok, status: _status, reason, ...rest } = result;
+    return { error: reason, ...rest };
+}

package/dist/tools/emitStageEnvelope.d.ts

@@ -11,11 +11,12 @@
  */
 import { Type } from "typebox";
 import type { StageEnvelope } from "../types/envelope.js";
+import type { CloneEmitContext, 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, cloneEmitContext?: CloneEmitContext): {
     name: string;
     label: string;
     description: string;
@@ -24,6 +25,16 @@ export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloa
         summary: Type.TString;
         artifacts: Type.TArray<Type.TString>;
         payload: Type.TSchema;
+        fork_choice: Type.TArray<Type.TString>;
+        clone_forks?: Type.TArray<Type.TObject<{
+            successor_id: Type.TString;
+            action: Type.TUnion<[Type.TLiteral<"skip">, Type.TLiteral<"once">, Type.TLiteral<"fanout">]>;
+            envelope: Type.TOptional<Type.TUnknown>;
+            mode: Type.TOptional<Type.TUnion<[Type.TLiteral<"parallel">, Type.TLiteral<"sequential">]>>;
+            clones: Type.TOptional<Type.TArray<Type.TObject<{
+                envelope: Type.TUnknown;
+            }>>>;
+        }>> | undefined;
         stage_id: Type.TOptional<Type.TString>;
         notes: Type.TOptional<Type.TString>;
     }>;

package/dist/tools/emitStageEnvelope.js

@@ -11,6 +11,8 @@
  */
 import { Type } from "typebox";
 import { assertRequiredEnvelope, isAdvancingEnvelope, } from "../envelope/check.js";
+import { assertCloneForks } from "../envelope/cloneForks.js";
+import { normalizeForkChoice } from "../envelope/forkChoice.js";
 import { assertEnvelopePayload, compilePayloadSchema, } from "../envelope/payloadSchema.js";
 function toolResult(text, details, options) {
     return {
@@ -20,10 +22,23 @@ function toolResult(text, details, options) {
         ...(options?.terminate ? { terminate: true } : {}),
     };
 }
-export function createEmitStageEnvelopeTool(capture, payloadSchema) {
+export function createEmitStageEnvelopeTool(capture, payloadSchema, forkEmitContext, cloneEmitContext) {
     const compiledPayload = payloadSchema !== undefined
         ? compilePayloadSchema(payloadSchema)
         : undefined;
+    const cloneForksSchema = Type.Array(Type.Object({
+        successor_id: Type.String(),
+        action: Type.Union([
+            Type.Literal("skip"),
+            Type.Literal("once"),
+            Type.Literal("fanout"),
+        ]),
+        envelope: Type.Optional(Type.Unknown()),
+        mode: Type.Optional(Type.Union([Type.Literal("parallel"), Type.Literal("sequential")])),
+        clones: Type.Optional(Type.Array(Type.Object({
+            envelope: Type.Unknown(),
+        }))),
+    }));
     return {
         name: "emit_stage_envelope",
         label: "Emit stage envelope",
@@ -35,6 +50,10 @@ 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())),
+            ...(cloneEmitContext !== undefined ? { clone_forks: cloneForksSchema } : {}),
             stage_id: Type.Optional(Type.String()),
             notes: Type.Optional(Type.String()),
         }),
@@ -43,6 +62,13 @@ export function createEmitStageEnvelopeTool(capture, payloadSchema) {
                 return toolResult("Envelope already accepted; later emits are ignored.", { advancing: isAdvancingEnvelope(capture.envelope), error: "" }, { terminate: true });
             }
             try {
+                const record = params;
+                if (record.status !== "failure" && forkEmitContext !== undefined) {
+                    normalizeForkChoice(record.fork_choice, "emit", forkEmitContext);
+                }
+                if (record.status !== "failure" && cloneEmitContext !== undefined) {
+                    assertCloneForks(params, cloneEmitContext);
+                }
                 const envelope = assertRequiredEnvelope(params);
                 assertEnvelopePayload(envelope, payloadSchema);
                 capture.envelope = envelope;

package/dist/types/envelope.d.ts

@@ -1,9 +1,12 @@
+import type { CloneForkItem } from "./forkChoice.js";
 export type EnvelopeStatus = "success" | "failure";
 export type StageEnvelope = {
     status: EnvelopeStatus;
     summary: string;
     artifacts: string[];
     payload?: Record<string, unknown>;
+    fork_choice?: string[];
+    clone_forks?: CloneForkItem[];
     stage_id?: string;
     notes?: string;
 };

package/dist/types/forkChoice.d.ts

@@ -0,0 +1,30 @@
+import type { StageEnvelope } from "./envelope.js";
+export type ForkChoiceShape = {
+    cardinality: "one" | "subset";
+    allowNone: boolean;
+};
+export type ForkEmitContext = {
+    immediateSuccessorIds: string[];
+    forkShape: ForkChoiceShape | null;
+};
+export type CloneForkItem = {
+    successor_id: string;
+    action: "skip";
+} | {
+    successor_id: string;
+    action: "once";
+    envelope: StageEnvelope;
+} | {
+    successor_id: string;
+    action: "fanout";
+    mode: "parallel" | "sequential";
+    clones: Array<{
+        envelope: StageEnvelope;
+    }>;
+};
+export type CloneEmitContext = {
+    clonableSuccessors: Array<{
+        successorId: string;
+        cloneCap: number;
+    }>;
+};

package/dist/types/forkChoice.js

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

package/dist/types/pipeline.d.ts

@@ -1,17 +1,72 @@
+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;
+    };
+    clonable?: boolean;
+    clone_cap?: number;
+};
+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;
+    };
+    clonable?: boolean;
+    clone_cap?: number;
+    skill?: string;
+    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;
+    clonable?: boolean;
+    clone_cap?: number;
+    definition_id?: string;
 };
 export type ResolvedPipelineDag = {
     nodes: ResolvedPipelineStageNode[];
@@ -20,6 +75,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 {};