stageflow 0.2.0 → 0.8.0

package/dist/config/validateCatalog.js

@@ -1,12 +1,18 @@
-import { readdir } from "node:fs/promises";
 import path from "node:path";
-import { loadPipelineOutcome, loadPipelineValidated } from "./loadPipeline.js";
+import { loadPipelineOutcome, resolvePipelinePath } from "./loadPipeline.js";
 import { loadStageOutcome } from "./loadStage.js";
+import { loadTaskOutcome } from "./loadTask.js";
 import { readYamlObject } from "./readYamlObject.js";
-import { extractPipelineStageIds } from "./resolvePipelineDag.js";
+import { resolveCatalogContext } from "./resolveCatalogContext.js";
+import { getCatalogScanPaths } from "./browseCatalog.js";
+import { manifestPathForProject } from "./loadStageflowManifest.js";
 export function relPath(cwd, absPath) {
-    return path.relative(cwd, absPath);
+    return path.relative(cwd, absPath).replace(/\\/g, "/");
 }
+const STRICT_CATALOG_WARNINGS = new Set([
+    "catalog.manifest_missing",
+    "catalog.empty_catalog",
+]);
 const SEVERITY_RANK = {
     error: 0,
     warning: 1,
@@ -28,7 +34,7 @@ function sortFindings(findings) {
 export function effectiveSeverity(finding, strict) {
     if (strict &&
         finding.severity === "warning" &&
-        finding.code === "catalog.orphan_stage") {
+        STRICT_CATALOG_WARNINGS.has(finding.code)) {
         return "error";
     }
     return finding.severity;
@@ -82,6 +88,24 @@ function findingStageError(cwd, absPath, message, code, stageId) {
         stageId,
     }, "error");
 }
+function findingTaskError(cwd, absPath, message, code) {
+    return baseFinding({
+        cwd,
+        absPath,
+        message,
+        code,
+        category: "task",
+    }, "error");
+}
+function findingCatalog(cwd, absPath, message, code, severity) {
+    return baseFinding({
+        cwd,
+        absPath,
+        message,
+        code,
+        category: "catalog",
+    }, severity);
+}
 export function findingsFromLoadIssues(cwd, absPath, issues) {
     return issues.flatMap((issue) => {
         if (issue.category === "pipeline") {
@@ -94,6 +118,18 @@ export function findingsFromLoadIssues(cwd, absPath, issues) {
                 findingStageError(cwd, absPath, issue.message, issue.code, issue.stageId),
             ];
         }
+        if (issue.category === "task") {
+            return [
+                findingTaskError(cwd, absPath, issue.message, issue.code),
+            ];
+        }
+        if (issue.category === "catalog") {
+            const code = issue.code;
+            const severity = code === "catalog.manifest_missing" || code === "catalog.empty_catalog"
+                ? "warning"
+                : "error";
+            return [findingCatalog(cwd, absPath, issue.message, code, severity)];
+        }
         return [];
     });
 }
@@ -107,40 +143,6 @@ export function findingStageIdFilenameMismatch(cwd, absPath, fileStem, declaredI
         stageId: declaredId,
     }, "error");
 }
-function findingCatalogDuplicatePipelineId(cwd, absPath, pipelineId, conflictingPaths) {
-    const relConflicts = conflictingPaths.map((p) => relPath(cwd, p));
-    return baseFinding({
-        cwd,
-        absPath,
-        message: `Duplicate pipeline id "${pipelineId}" declared in: ${relConflicts.join(", ")}`,
-        code: "catalog.duplicate_pipeline_id",
-        category: "catalog",
-        pipelineId,
-    }, "error");
-}
-function findingCatalogOrphanStage(cwd, absPath, stageId) {
-    return baseFinding({
-        cwd,
-        absPath,
-        message: `Stage "${stageId}" is not referenced by any pipeline`,
-        code: "catalog.orphan_stage",
-        category: "catalog",
-        stageId,
-    }, "warning");
-}
-async function listYamlFiles(dir) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    return entries
-        .filter((entry) => entry.isFile() && entry.name.endsWith(".yaml"))
-        .map((entry) => path.join(dir, entry.name))
-        .sort((a, b) => a.localeCompare(b));
-}
 async function checkStageIdFilename(cwd, stagePath) {
     const fileStem = path.basename(stagePath, ".yaml");
     try {
@@ -169,52 +171,79 @@ async function validateStageFile(cwd, stagePath) {
     }
     return findings;
 }
-async function validatePipelineFile(pipelinePath, options) {
-    const { cwd, stagesDir, validateStages } = options;
-    const findings = [];
-    const referencedStageIds = new Set();
-    let pipelineId;
+async function runPipelineValidation(nameOrPath, options) {
+    const { cwd, validateStages } = options;
+    let pipelinePath;
     try {
-        const raw = await readYamlObject(pipelinePath);
-        if (typeof raw?.id === "string") {
-            pipelineId = raw.id;
-            if (Array.isArray(raw.stages)) {
-                const stageIds = extractPipelineStageIds(raw.stages);
-                if (stageIds) {
-                    for (const stageId of stageIds) {
-                        referencedStageIds.add(stageId);
-                    }
-                }
-            }
-        }
+        pipelinePath = await resolvePipelinePath(nameOrPath, cwd);
     }
-    catch {
-        // loadPipelineOutcome will report read errors
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            ok: false,
+            findings: findingsFromLoadIssues(cwd, path.resolve(cwd, nameOrPath), [
+                {
+                    code: "pipeline.load_error",
+                    message,
+                    category: "pipeline",
+                },
+            ]),
+        };
     }
-    const outcome = await loadPipelineOutcome(pipelinePath, { cwd, stagesDir });
+    const outcome = await loadPipelineOutcome(pipelinePath, { cwd });
+    const findings = [];
     if (!outcome.ok) {
         findings.push(...findingsFromLoadIssues(cwd, pipelinePath, outcome.issues));
-        if (validateStages) {
-            for (const stageId of referencedStageIds) {
-                const stagePath = path.join(stagesDir, `${stageId}.yaml`);
-                findings.push(...(await validateStageFile(cwd, stagePath)));
+        return { ok: false, findings };
+    }
+    if (validateStages && outcome.value.stageSources) {
+        for (const source of Object.values(outcome.value.stageSources)) {
+            if (source.kind === "file") {
+                findings.push(...(await validateStageFile(cwd, source.path)));
             }
         }
-        return { findings, pipelineId, referencedStageIds };
     }
-    for (const stageId of outcome.value.pipeline.stages) {
-        referencedStageIds.add(stageId);
-        if (validateStages) {
-            const stagePath = path.join(stagesDir, `${stageId}.yaml`);
-            findings.push(...(await validateStageFile(cwd, stagePath)));
-        }
+    if (findings.some((finding) => finding.severity === "error")) {
+        return { ok: false, findings };
     }
-    return { findings, pipelineId: outcome.value.pipeline.id, referencedStageIds };
+    return { ok: true, loaded: outcome.value, findings };
+}
+export async function validatePipeline(nameOrPath, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const validateStages = options.validateStages ?? true;
+    const strict = options.strict ?? false;
+    const core = await runPipelineValidation(nameOrPath, { cwd, validateStages });
+    return buildValidationResult("pipeline", core.findings, strict);
 }
-async function collectPipelineIds(pipelinesDir) {
-    const files = await listYamlFiles(pipelinesDir);
+export async function loadPipelineValidated(nameOrPath, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const validateStages = options.validateStages ?? true;
+    const core = await runPipelineValidation(nameOrPath, { cwd, validateStages });
+    if (core.ok) {
+        return { ok: true, loaded: core.loaded };
+    }
+    return { ok: false, findings: core.findings };
+}
+function findingCatalogDuplicatePipelineId(cwd, absPath, pipelineId, conflictingPaths) {
+    const relConflicts = conflictingPaths.map((p) => relPath(cwd, p));
+    return baseFinding({
+        cwd,
+        absPath,
+        message: `Duplicate pipeline id "${pipelineId}" declared in: ${relConflicts.join(", ")}`,
+        code: "catalog.duplicate_pipeline_id",
+        category: "catalog",
+        pipelineId,
+    }, "error");
+}
+function findingManifestMissing(cwd, projectRoot) {
+    return findingCatalog(cwd, manifestPathForProject(projectRoot), "No stageflow.yaml manifest found at project root", "catalog.manifest_missing", "warning");
+}
+function findingEmptyCatalog(cwd, manifestPath, kind) {
+    return findingCatalog(cwd, manifestPath, `Manifest catalog.${kind} is empty`, "catalog.empty_catalog", "warning");
+}
+async function collectPipelineIdsFromPaths(pipelinePaths) {
     const idToPaths = new Map();
-    for (const filePath of files) {
+    for (const filePath of pipelinePaths) {
         try {
             const raw = await readYamlObject(filePath);
             if (typeof raw?.id !== "string")
@@ -240,83 +269,91 @@ function findingsForDuplicatePipelineIds(cwd, idToPaths) {
     }
     return findings;
 }
-async function collectReferencedStageIds(pipelinesDir) {
-    const files = await listYamlFiles(pipelinesDir);
-    const referenced = new Set();
-    for (const filePath of files) {
-        try {
-            const raw = await readYamlObject(filePath);
-            if (typeof raw?.id !== "string" || !Array.isArray(raw.stages))
-                continue;
-            const stageIds = extractPipelineStageIds(raw.stages);
-            if (!stageIds)
-                continue;
-            for (const stageId of stageIds) {
-                referenced.add(stageId);
-            }
+async function validateManifestAll(invocationCwd) {
+    const ctx = await resolveCatalogContext(invocationCwd);
+    const findings = [];
+    if (ctx.manifestStatus === "not_git" || ctx.manifestStatus === "missing") {
+        if (ctx.projectRoot) {
+            findings.push(findingManifestMissing(invocationCwd, ctx.projectRoot));
         }
-        catch {
-            // skip unreadable
+        else {
+            findings.push(findingCatalog(invocationCwd, path.resolve(invocationCwd), "Not inside a git repository; no catalog manifest", "catalog.manifest_missing", "warning"));
         }
+        return findings;
     }
-    return referenced;
-}
-async function findingsForOrphanStages(cwd, stagesDir, referencedStageIds) {
-    const findings = [];
-    const stageFiles = await listYamlFiles(stagesDir);
-    for (const stagePath of stageFiles) {
-        const stageId = path.basename(stagePath, ".yaml");
-        if (referencedStageIds.has(stageId))
-            continue;
-        findings.push(findingCatalogOrphanStage(cwd, stagePath, stageId));
-        findings.push(...(await validateStageFile(cwd, stagePath)));
+    if (ctx.manifestStatus === "invalid") {
+        const manifestPath = ctx.projectRoot
+            ? manifestPathForProject(ctx.projectRoot)
+            : path.resolve(invocationCwd, "stageflow.yaml");
+        findings.push(...findingsFromLoadIssues(invocationCwd, manifestPath, ctx.issues));
+        return findings;
+    }
+    const { projectRoot, manifest } = ctx;
+    if (!projectRoot || !manifest) {
+        return findings;
+    }
+    if (manifest.manifest.catalog.pipelines.length === 0) {
+        findings.push(findingEmptyCatalog(invocationCwd, manifest.path, "pipelines"));
+    }
+    if (manifest.manifest.catalog.tasks.length === 0) {
+        findings.push(findingEmptyCatalog(invocationCwd, manifest.path, "tasks"));
+    }
+    const scanPaths = await getCatalogScanPaths(ctx);
+    if (!scanPaths) {
+        return findings;
+    }
+    const { pipelinePaths, taskPaths } = scanPaths;
+    for (const pipelinePath of pipelinePaths) {
+        const core = await runPipelineValidation(pipelinePath, {
+            cwd: projectRoot,
+            validateStages: true,
+        });
+        if (!core.ok) {
+            findings.push(...core.findings);
+        }
     }
+    for (const taskPath of taskPaths) {
+        const outcome = await loadTaskOutcome(taskPath);
+        if (!outcome.ok) {
+            findings.push(...findingsFromLoadIssues(projectRoot, taskPath, outcome.issues));
+        }
+    }
+    const idToPaths = await collectPipelineIdsFromPaths(pipelinePaths);
+    findings.push(...findingsForDuplicatePipelineIds(projectRoot, idToPaths));
     return findings;
 }
+async function validateSingleTask(invocationCwd, taskArg) {
+    const ctx = await resolveCatalogContext(invocationCwd);
+    const relCwd = ctx.projectRoot ?? invocationCwd;
+    const taskPath = path.resolve(invocationCwd, taskArg);
+    const outcome = await loadTaskOutcome(taskPath);
+    if (!outcome.ok) {
+        return findingsFromLoadIssues(relCwd, taskPath, outcome.issues);
+    }
+    return [];
+}
 export async function validateCatalog(options) {
     const cwd = options.cwd ?? process.cwd();
-    const stagesDir = options.stagesDir ?? path.join(cwd, "stages");
     const strict = options.strict ?? false;
-    const pipelinesDir = path.join(cwd, "pipelines");
     if (options.scope === "pipeline" && !options.pipeline) {
         throw new Error("validateCatalog: pipeline is required when scope is \"pipeline\"");
     }
+    if (options.scope === "task" && !options.task) {
+        throw new Error("validateCatalog: task is required when scope is \"task\"");
+    }
     const allFindings = [];
     if (options.scope === "pipeline") {
-        const result = await loadPipelineValidated(options.pipeline, {
+        return validatePipeline(options.pipeline, {
             cwd,
-            stagesDir,
             validateStages: true,
+            strict,
         });
-        if (!result.ok) {
-            allFindings.push(...result.findings);
-        }
+    }
+    else if (options.scope === "task") {
+        allFindings.push(...(await validateSingleTask(cwd, options.task)));
     }
     else {
-        const referencedStageIds = await collectReferencedStageIds(pipelinesDir);
-        const pipelineFiles = await listYamlFiles(pipelinesDir);
-        for (const pipelinePath of pipelineFiles) {
-            const result = await validatePipelineFile(pipelinePath, {
-                cwd,
-                stagesDir,
-                validateStages: false,
-            });
-            allFindings.push(...result.findings);
-            for (const stageId of result.referencedStageIds) {
-                referencedStageIds.add(stageId);
-            }
-        }
-        const validatedStages = new Set();
-        for (const stageId of referencedStageIds) {
-            if (validatedStages.has(stageId))
-                continue;
-            validatedStages.add(stageId);
-            const stagePath = path.join(stagesDir, `${stageId}.yaml`);
-            allFindings.push(...(await validateStageFile(cwd, stagePath)));
-        }
-        const idToPaths = await collectPipelineIds(pipelinesDir);
-        allFindings.push(...findingsForDuplicatePipelineIds(cwd, idToPaths));
-        allFindings.push(...(await findingsForOrphanStages(cwd, stagesDir, referencedStageIds)));
+        allFindings.push(...(await validateManifestAll(cwd)));
     }
     return buildValidationResult(options.scope, allFindings, strict);
 }

package/dist/envelope/check.d.ts

@@ -1,3 +1,5 @@
 import { type StageEnvelope } from "../types/envelope.js";
+import type { CloneForkItem } from "../types/forkChoice.js";
+export declare function parseCloneForks(raw: unknown): CloneForkItem[];
 export declare function assertRequiredEnvelope(value: unknown): StageEnvelope;
 export declare function isAdvancingEnvelope(envelope: StageEnvelope): boolean;

package/dist/envelope/check.js

@@ -1,4 +1,52 @@
 import { EnvelopeError, } from "../types/envelope.js";
+function parseCloneForkItem(raw, index) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new EnvelopeError(`clone_forks[${index}] must be an object`);
+    }
+    const record = raw;
+    if (typeof record.successor_id !== "string") {
+        throw new EnvelopeError(`clone_forks[${index}].successor_id must be a string`);
+    }
+    const action = record.action;
+    if (action !== "skip" && action !== "once" && action !== "fanout") {
+        throw new EnvelopeError(`clone_forks[${index}].action must be "skip", "once", or "fanout"`);
+    }
+    const item = {
+        successor_id: record.successor_id,
+        action,
+    };
+    if (record.envelope !== undefined) {
+        item.envelope = assertRequiredEnvelope(record.envelope);
+    }
+    if (record.mode !== undefined) {
+        if (record.mode !== "parallel" && record.mode !== "sequential") {
+            throw new EnvelopeError(`clone_forks[${index}].mode must be "parallel" or "sequential"`);
+        }
+        item.mode = record.mode;
+    }
+    if (record.clones !== undefined) {
+        if (!Array.isArray(record.clones)) {
+            throw new EnvelopeError(`clone_forks[${index}].clones must be an array`);
+        }
+        item.clones = record.clones.map((clone, cloneIndex) => {
+            if (clone === null || typeof clone !== "object" || Array.isArray(clone)) {
+                throw new EnvelopeError(`clone_forks[${index}].clones[${cloneIndex}] must be an object`);
+            }
+            const cloneRecord = clone;
+            if (cloneRecord.envelope === undefined) {
+                throw new EnvelopeError(`clone_forks[${index}].clones[${cloneIndex}].envelope is required`);
+            }
+            return { envelope: assertRequiredEnvelope(cloneRecord.envelope) };
+        });
+    }
+    return item;
+}
+export function parseCloneForks(raw) {
+    if (!Array.isArray(raw)) {
+        throw new EnvelopeError("clone_forks must be an array");
+    }
+    return raw.map((item, index) => parseCloneForkItem(item, index));
+}
 export function assertRequiredEnvelope(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
         throw new EnvelopeError("envelope must be an object");
@@ -25,6 +73,16 @@ export function assertRequiredEnvelope(value) {
         summary: record.summary,
         artifacts: record.artifacts,
     };
+    if (record.fork_choice !== undefined) {
+        if (!Array.isArray(record.fork_choice) ||
+            !record.fork_choice.every((item) => typeof item === "string")) {
+            throw new EnvelopeError("fork_choice must be an array of strings");
+        }
+        envelope.fork_choice = record.fork_choice;
+    }
+    if (record.clone_forks !== undefined) {
+        envelope.clone_forks = parseCloneForks(record.clone_forks);
+    }
     if (record.payload !== undefined) {
         if (record.payload === null ||
             typeof record.payload !== "object" ||

package/dist/envelope/cloneForks.d.ts

@@ -0,0 +1,2 @@
+import type { CloneEmitContext } from "../types/forkChoice.js";
+export declare function assertCloneForks(params: unknown, cloneEmitContext: CloneEmitContext): void;

package/dist/envelope/cloneForks.js

@@ -0,0 +1,62 @@
+import { parseCloneForks } from "./check.js";
+import { EnvelopeError } from "../types/envelope.js";
+function fieldPresent(item, key) {
+    return item[key] !== undefined;
+}
+export function assertCloneForks(params, cloneEmitContext) {
+    const record = params;
+    if (record.status === "failure")
+        return;
+    if (record.clone_forks === undefined || !Array.isArray(record.clone_forks)) {
+        throw new EnvelopeError("clonable successor requires clone_forks on success");
+    }
+    const items = parseCloneForks(record.clone_forks);
+    if (items.length === 0 && cloneEmitContext.clonableSuccessors.length > 0) {
+        throw new EnvelopeError("clone_forks must not be empty when clonable successors exist");
+    }
+    const expectedIds = cloneEmitContext.clonableSuccessors.map((s) => s.successorId);
+    const expectedSet = new Set(expectedIds);
+    const seen = new Set();
+    for (const item of items) {
+        if (seen.has(item.successor_id)) {
+            throw new EnvelopeError(`clone_forks contains duplicate successor_id: ${item.successor_id}`);
+        }
+        if (!expectedSet.has(item.successor_id)) {
+            throw new EnvelopeError(`clone_forks contains extra successor_id: ${item.successor_id}`);
+        }
+        seen.add(item.successor_id);
+        const capEntry = cloneEmitContext.clonableSuccessors.find((s) => s.successorId === item.successor_id);
+        const cloneCap = capEntry?.cloneCap;
+        if (item.action === "skip") {
+            if (fieldPresent(item, "envelope") ||
+                fieldPresent(item, "mode") ||
+                fieldPresent(item, "clones")) {
+                throw new EnvelopeError(`clone_forks skip for ${item.successor_id} must not include envelope, mode, or clones`);
+            }
+        }
+        else if (item.action === "once") {
+            if (!fieldPresent(item, "envelope")) {
+                throw new EnvelopeError(`clone_forks once for ${item.successor_id} requires envelope`);
+            }
+            if (fieldPresent(item, "mode") || fieldPresent(item, "clones")) {
+                throw new EnvelopeError(`clone_forks once for ${item.successor_id} must not include mode or clones`);
+            }
+        }
+        else if (item.action === "fanout") {
+            if (fieldPresent(item, "envelope")) {
+                throw new EnvelopeError(`clone_forks fanout for ${item.successor_id} must not include a top-level envelope`);
+            }
+            if (!fieldPresent(item, "mode") || !fieldPresent(item, "clones") || item.clones === undefined) {
+                throw new EnvelopeError(`clone_forks fanout for ${item.successor_id} requires mode and clones`);
+            }
+            if (cloneCap === undefined || item.clones.length < 2 || item.clones.length > cloneCap) {
+                throw new EnvelopeError(`clone_forks fanout for ${item.successor_id} must have between 2 and ${cloneCap} clones`);
+            }
+        }
+    }
+    for (const id of expectedIds) {
+        if (!seen.has(id)) {
+            throw new EnvelopeError(`clone_forks missing successor_id: ${id}`);
+        }
+    }
+}

package/dist/envelope/forkChoice.d.ts

@@ -0,0 +1,3 @@
+import type { ForkEmitContext } from "../types/forkChoice.js";
+export declare function assertForkEnvelope(params: unknown, forkEmitContext: ForkEmitContext): void;
+export declare function normalizeForkChoice(raw: string[] | undefined, mode: "emit" | "stored", forkEmitContext?: ForkEmitContext): Set<string>;

package/dist/envelope/forkChoice.js

@@ -0,0 +1,47 @@
+/**
+ * Emit mode rejects missing fork_choice on fork success; stored mode treats
+ * undefined as an empty choice set (scheduler defensive path).
+ */
+import { EnvelopeError } from "../types/envelope.js";
+function assertForkChoiceLegality(choices, forkEmitContext) {
+    const { immediateSuccessorIds, forkShape } = forkEmitContext;
+    for (const id of choices) {
+        if (!immediateSuccessorIds.includes(id)) {
+            throw new EnvelopeError(`fork_choice contains non-immediate successor: ${id}; clonable successors belong in clone_forks`);
+        }
+    }
+    if (choices.length === 0) {
+        if (forkShape === null || !forkShape.allowNone) {
+            throw new EnvelopeError("fork_choice must not be empty");
+        }
+    }
+    if (forkShape !== null && forkShape.cardinality === "one" && choices.length !== 1) {
+        throw new EnvelopeError("fork shape requires exactly one choice");
+    }
+}
+export function assertForkEnvelope(params, forkEmitContext) {
+    const record = params;
+    if (record.status === "failure")
+        return;
+    if (record.fork_choice === undefined) {
+        throw new EnvelopeError("fork stage must include fork_choice on success");
+    }
+    assertForkChoiceLegality(record.fork_choice, forkEmitContext);
+}
+export function normalizeForkChoice(raw, mode, forkEmitContext) {
+    if (mode === "stored") {
+        if (raw === undefined)
+            return new Set();
+        return new Set(raw);
+    }
+    if (forkEmitContext === undefined) {
+        if (raw === undefined)
+            return new Set();
+        return new Set(raw);
+    }
+    if (raw === undefined) {
+        throw new EnvelopeError("fork stage must include fork_choice on success");
+    }
+    assertForkChoiceLegality(raw, forkEmitContext);
+    return new Set(raw);
+}

package/dist/index.d.ts

@@ -1,3 +1,7 @@
+export { findProjectRoot, clearFindProjectRootCacheForTests, } from "./project/findProjectRoot.js";
+export { globalStageflowHome, ensureGlobalHome, } from "./project/globalHome.js";
+export { resolveProjectContext, legacyProjectContext, type ProjectContext, } from "./project/resolveProjectContext.js";
+export { resolveStageflowContext, projectContextFromStageflow, type StageflowContext, type CatalogManifestStatus, } from "./project/resolveStageflowContext.js";
 export { PACKAGE_NAME } from "./package-meta.js";
 export type { StageEnvelope } from "./types/envelope.js";
 export { assertRequiredEnvelope, isAdvancingEnvelope, } from "./envelope/check.js";
@@ -11,3 +15,5 @@ export type { RunStore, RunSummary, RunDetail, RunMeta, RunStatus, StageSnapshot
 export { deriveStatusFromStages } from "./runstore/port.js";
 export { RunManager } from "./runtime/runManager.js";
 export { startUiServer } from "./server/http.js";
+export { startMcpServer } from "./server/mcpHost.js";
+export { DEFAULT_PORT } from "./server/mcpHost.js";

package/dist/index.js

@@ -1,3 +1,7 @@
+export { findProjectRoot, clearFindProjectRootCacheForTests, } from "./project/findProjectRoot.js";
+export { globalStageflowHome, ensureGlobalHome, } from "./project/globalHome.js";
+export { resolveProjectContext, legacyProjectContext, } from "./project/resolveProjectContext.js";
+export { resolveStageflowContext, projectContextFromStageflow, } from "./project/resolveStageflowContext.js";
 export { PACKAGE_NAME } from "./package-meta.js";
 export { assertRequiredEnvelope, isAdvancingEnvelope, } from "./envelope/check.js";
 export { runPipeline, startPipeline } from "./runtime/pipelineRunner.js";
@@ -5,3 +9,5 @@ export { createRunStore } from "./runstore/createStore.js";
 export { deriveStatusFromStages } from "./runstore/port.js";
 export { RunManager } from "./runtime/runManager.js";
 export { startUiServer } from "./server/http.js";
+export { startMcpServer } from "./server/mcpHost.js";
+export { DEFAULT_PORT } from "./server/mcpHost.js";

package/dist/mcp/catalogTools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/server";
+import type { McpToolDeps } from "./deps.js";
+export declare function registerCatalogTools(server: McpServer, deps: McpToolDeps): void;