stageflow 0.33.0 → 0.36.0

package/dist/config/triggerCatalog.d.ts

@@ -1,10 +1,49 @@
+import { type ResolveCatalogRootsOptions } from "./resolveCatalogRoots.js";
 import type { RunStore } from "../runstore/port.js";
 import type { TriggerFile } from "../types/trigger.js";
+import type { TriggerRecord } from "../runstore/port.js";
 export type TriggerListItem = TriggerFile & {
     definition_ref: string;
+    project_root: string;
     last_fired_at?: string;
     last_run_id?: string;
     next_run_at?: string;
 };
-/** Catalog-authoritative trigger list, overlaid with each trigger's store-recorded fire state (if any). */
-export declare function loadCatalogTriggers(cwd: string, store: RunStore): Promise<TriggerListItem[] | undefined>;
+export type CatalogTriggerMatch = {
+    definition: TriggerFile;
+    path: string;
+    project_root: string;
+    rootPath: string;
+    definition_ref: string;
+};
+/** Store row id namespaced by catalog wire root so two roots can share a trigger id. */
+export declare function triggerStoreId(wireProjectRoot: string, catalogId: string): string;
+export declare function readTriggerStoreRecord(store: RunStore, wireProjectRoot: string, catalogId: string): Promise<TriggerRecord | null>;
+export declare function listCatalogTriggerMatches(options: ResolveCatalogRootsOptions & {
+    sourceRootsOnly?: boolean;
+}): Promise<CatalogTriggerMatch[]>;
+export type FindCatalogTriggerResult = {
+    ok: true;
+    match: CatalogTriggerMatch;
+} | {
+    ok: false;
+    status: 404;
+    reason: string;
+} | {
+    ok: false;
+    status: 409;
+    reason: string;
+    code: "ambiguous_trigger";
+    project_roots: string[];
+} | {
+    ok: false;
+    status: 400;
+    reason: string;
+    code: "unknown_project_root";
+};
+export declare function findCatalogTrigger(options: ResolveCatalogRootsOptions & {
+    triggerId: string;
+    projectRootFilter?: string;
+}): Promise<FindCatalogTriggerResult>;
+/** Catalog-authoritative trigger list across all roots, overlaid with store fire state. */
+export declare function loadCatalogTriggers(options: ResolveCatalogRootsOptions): Promise<TriggerListItem[]>;

package/dist/config/triggerCatalog.js

@@ -1,27 +1,114 @@
 import path from "node:path";
-import { catalogContextFromStageflow } from "./resolveCatalogContext.js";
 import { getCatalogScanPaths } from "./browseCatalog.js";
-import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { loadStageflowManifestOutcome } from "./loadStageflowManifest.js";
 import { loadTriggerOutcome } from "./loadTrigger.js";
-/** Catalog-authoritative trigger list, overlaid with each trigger's store-recorded fire state (if any). */
-export async function loadCatalogTriggers(cwd, store) {
-    const ctx = catalogContextFromStageflow(await resolveStageflowContext(cwd));
+import { isRootReadable, resolveCatalogRoots, findCatalogRoot, } from "./resolveCatalogRoots.js";
+const TRIGGER_STORE_SEP = "::";
+/** Store row id namespaced by catalog wire root so two roots can share a trigger id. */
+export function triggerStoreId(wireProjectRoot, catalogId) {
+    return `${wireProjectRoot}${TRIGGER_STORE_SEP}${catalogId}`;
+}
+export async function readTriggerStoreRecord(store, wireProjectRoot, catalogId) {
+    const namespaced = await store.getTrigger(triggerStoreId(wireProjectRoot, catalogId));
+    if (namespaced)
+        return namespaced;
+    return store.getTrigger(catalogId);
+}
+async function catalogContextForRoot(root) {
+    const outcome = await loadStageflowManifestOutcome(root.path);
+    if (!outcome.ok)
+        return null;
+    return {
+        projectRoot: root.path,
+        manifest: outcome.value,
+        manifestStatus: "ok",
+        issues: [],
+    };
+}
+async function triggersInRoot(root) {
+    if (root.available === false)
+        return [];
+    if (!(await isRootReadable(root.path)))
+        return [];
+    const ctx = await catalogContextForRoot(root);
+    if (!ctx)
+        return [];
     const scanPaths = await getCatalogScanPaths(ctx);
     if (!scanPaths)
-        return undefined;
-    const projectRoot = ctx.projectRoot ?? undefined;
-    const items = [];
+        return [];
+    const matches = [];
     for (const filePath of scanPaths.triggerPaths) {
         const outcome = await loadTriggerOutcome(filePath);
         if (!outcome.ok)
             continue;
-        const definitionRef = projectRoot !== undefined
-            ? path.relative(projectRoot, filePath).replace(/\\/g, "/")
-            : filePath;
-        const record = await store.getTrigger(outcome.value.id);
+        matches.push({
+            definition: outcome.value,
+            path: filePath,
+            project_root: root.project_root,
+            rootPath: root.path,
+            definition_ref: path.relative(root.path, filePath).replace(/\\/g, "/"),
+        });
+    }
+    return matches;
+}
+export async function listCatalogTriggerMatches(options) {
+    const roots = await resolveCatalogRoots(options);
+    const selected = options.sourceRootsOnly
+        ? roots.filter((r) => r.kind !== "seeded")
+        : roots;
+    const matches = [];
+    for (const root of selected) {
+        matches.push(...(await triggersInRoot(root)));
+    }
+    return matches;
+}
+export async function findCatalogTrigger(options) {
+    const roots = await resolveCatalogRoots(options);
+    if (options.projectRootFilter !== undefined) {
+        const match = findCatalogRoot(roots, options.projectRootFilter);
+        if (match === undefined) {
+            return {
+                ok: false,
+                status: 400,
+                reason: `Unknown project_root: ${options.projectRootFilter}`,
+                code: "unknown_project_root",
+            };
+        }
+        const inRoot = await triggersInRoot(match);
+        const found = inRoot.find((t) => t.definition.id === options.triggerId);
+        if (!found) {
+            return { ok: false, status: 404, reason: `Trigger not found: ${options.triggerId}` };
+        }
+        return { ok: true, match: found };
+    }
+    const all = await listCatalogTriggerMatches(options);
+    const matches = all.filter((m) => m.definition.id === options.triggerId);
+    if (matches.length === 0) {
+        return { ok: false, status: 404, reason: `Trigger not found: ${options.triggerId}` };
+    }
+    const projectRoots = [...new Set(matches.map((m) => m.project_root))];
+    if (projectRoots.length > 1) {
+        return {
+            ok: false,
+            status: 409,
+            reason: `Trigger id is ambiguous across catalog roots: ${options.triggerId}`,
+            code: "ambiguous_trigger",
+            project_roots: projectRoots.sort((a, b) => a.localeCompare(b)),
+        };
+    }
+    return { ok: true, match: matches[0] };
+}
+/** Catalog-authoritative trigger list across all roots, overlaid with store fire state. */
+export async function loadCatalogTriggers(options) {
+    const matches = await listCatalogTriggerMatches(options);
+    const store = options.store;
+    const items = [];
+    for (const match of matches) {
+        const record = await readTriggerStoreRecord(store, match.project_root, match.definition.id);
         items.push({
-            ...outcome.value,
-            definition_ref: definitionRef,
+            ...match.definition,
+            project_root: match.project_root,
+            definition_ref: match.definition_ref,
             ...(record?.last_fired_at !== undefined
                 ? { last_fired_at: record.last_fired_at }
                 : {}),
@@ -33,5 +120,10 @@ export async function loadCatalogTriggers(cwd, store) {
                 : {}),
         });
     }
-    return items.sort((a, b) => a.id.localeCompare(b.id));
+    return items.sort((a, b) => {
+        const rootCmp = a.project_root.localeCompare(b.project_root);
+        if (rootCmp !== 0)
+            return rootCmp;
+        return a.id.localeCompare(b.id);
+    });
 }

package/dist/config/updateTask.d.ts

@@ -0,0 +1,30 @@
+import { type TaskDetailWithRoot } from "./findTaskInCatalog.js";
+import { type ResolveCatalogRootsOptions } from "./resolveCatalogRoots.js";
+declare const OPTIONAL_KEYS: readonly ["context", "constraints", "checkout", "repository", "ref"];
+type OptionalKey = (typeof OPTIONAL_KEYS)[number];
+export type UpdateTaskInput = {
+    goal: string;
+    optional: Partial<Record<OptionalKey, string | null>>;
+};
+export type UpdateTaskParseError = {
+    ok: false;
+    status: 400;
+    error: string;
+};
+export type UpdateTaskResult = {
+    ok: true;
+    task: TaskDetailWithRoot;
+} | {
+    ok: false;
+    status: 400 | 404 | 409 | 500;
+    error: string;
+    code?: "unknown_project_root" | "ambiguous_task";
+    project_roots?: string[];
+};
+export declare function parseUpdateTaskBody(body: unknown): UpdateTaskInput | UpdateTaskParseError;
+export declare function updateTask(options: ResolveCatalogRootsOptions & {
+    taskId: string;
+    input: UpdateTaskInput;
+    projectRootFilter?: string;
+}): Promise<UpdateTaskResult>;
+export {};

package/dist/config/updateTask.js

@@ -0,0 +1,119 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseDocument } from "yaml";
+import { findTaskInCatalogMulti, findTaskInProjectRoot, } from "./findTaskInCatalog.js";
+import { loadTaskOutcome } from "./loadTask.js";
+import { findCatalogRoot, resolveCatalogRoots, } from "./resolveCatalogRoots.js";
+const OPTIONAL_KEYS = ["context", "constraints", "checkout", "repository", "ref"];
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function parseUpdateTaskBody(body) {
+    if (!isPlainObject(body)) {
+        return { ok: false, status: 400, error: "Request body must be an object" };
+    }
+    if (typeof body.goal !== "string" || body.goal.length === 0) {
+        return { ok: false, status: 400, error: "goal is required" };
+    }
+    const optional = {};
+    for (const key of OPTIONAL_KEYS) {
+        if (!Object.hasOwn(body, key))
+            continue;
+        const value = body[key];
+        if (value === null || value === "") {
+            optional[key] = null;
+            continue;
+        }
+        if (typeof value !== "string") {
+            return { ok: false, status: 400, error: `${key} must be a string` };
+        }
+        optional[key] = value;
+    }
+    return { goal: body.goal, optional };
+}
+export async function updateTask(options) {
+    const lookup = await findTaskInCatalogMulti({
+        ...options,
+        projectRootFilter: options.projectRootFilter,
+    });
+    if (!lookup.ok) {
+        if (lookup.status === 409) {
+            return {
+                ok: false,
+                status: 409,
+                error: lookup.error,
+                code: lookup.code,
+                project_roots: lookup.project_roots,
+            };
+        }
+        if (lookup.status === 400) {
+            return {
+                ok: false,
+                status: 400,
+                error: lookup.error,
+                code: lookup.code,
+            };
+        }
+        return { ok: false, status: 404, error: lookup.error };
+    }
+    const roots = await resolveCatalogRoots(options);
+    const catalogRoot = findCatalogRoot(roots, lookup.task.project_root);
+    if (catalogRoot === undefined) {
+        return { ok: false, status: 404, error: `Task not found: ${options.taskId}` };
+    }
+    const filePath = path.resolve(catalogRoot.path, lookup.task.path);
+    let original;
+    try {
+        original = await readFile(filePath, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, status: 500, error: message };
+    }
+    const doc = parseDocument(original);
+    if (!doc.contents || typeof doc.contents !== "object") {
+        return { ok: false, status: 500, error: "Task YAML must be an object" };
+    }
+    doc.set("goal", options.input.goal);
+    for (const key of OPTIONAL_KEYS) {
+        if (!Object.hasOwn(options.input.optional, key))
+            continue;
+        const value = options.input.optional[key];
+        if (value === null || value === "")
+            doc.delete(key);
+        else
+            doc.set(key, value);
+    }
+    const patched = doc.toString();
+    const text = patched.endsWith("\n") ? patched : `${patched}\n`;
+    try {
+        await writeFile(filePath, text, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { ok: false, status: 500, error: message };
+    }
+    const outcome = await loadTaskOutcome(filePath);
+    if (!outcome.ok) {
+        try {
+            await writeFile(filePath, original, "utf8");
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { ok: false, status: 500, error: message };
+        }
+        return {
+            ok: false,
+            status: 400,
+            error: outcome.issues[0]?.message ?? "Invalid task",
+        };
+    }
+    const task = await findTaskInProjectRoot(catalogRoot.path, options.taskId);
+    if (!task) {
+        return { ok: false, status: 500, error: "Task updated but not found" };
+    }
+    return {
+        ok: true,
+        task: { ...task, project_root: lookup.task.project_root },
+    };
+}

package/dist/config/updateTrigger.d.ts

@@ -0,0 +1,38 @@
+import type { RunStore } from "../runstore/port.js";
+import type { TriggerEvent, TriggerSchedule } from "../types/trigger.js";
+import { type TriggerListItem } from "./triggerCatalog.js";
+export type PatchTriggerInput = {
+    enabled: boolean;
+};
+export type PatchTriggerParseError = {
+    ok: false;
+    status: 400;
+    error: string;
+};
+export declare function parsePatchTriggerBody(body: unknown): PatchTriggerInput | PatchTriggerParseError;
+export type PutTriggerInput = {
+    pipeline: string;
+    task?: string;
+    kind: "manual" | "schedule" | "event";
+    schedule?: TriggerSchedule;
+    event?: TriggerEvent;
+    enabled: boolean;
+};
+export declare function parsePutTriggerBody(body: unknown, triggerId: string): PutTriggerInput | PatchTriggerParseError;
+export type UpdateTriggerResult = {
+    ok: true;
+    trigger: TriggerListItem;
+} | {
+    ok: false;
+    status: 403 | 404 | 409 | 400 | 422 | 500;
+    error: string;
+    project_roots?: string[];
+};
+declare function projectRootFilterFromBody(body: unknown): string | undefined;
+export declare function updateTriggerEnabled(cwd: string, store: RunStore, triggerId: string, enabled: boolean, options?: {
+    projectRootFilter?: string;
+}): Promise<UpdateTriggerResult>;
+export declare function updateTriggerDefinition(cwd: string, store: RunStore, triggerId: string, input: PutTriggerInput, options?: {
+    projectRootFilter?: string;
+}): Promise<UpdateTriggerResult>;
+export { projectRootFilterFromBody };

package/dist/config/updateTrigger.js

@@ -0,0 +1,220 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { parseDocument } from "yaml";
+import { findCatalogTrigger, loadCatalogTriggers, triggerStoreId, } from "./triggerCatalog.js";
+import { resolveCatalogRoots, findCatalogRoot } from "./resolveCatalogRoots.js";
+import { loadTriggerFromYamlOutcome } from "./loadTrigger.js";
+import { catalogContextFromStageflow } from "./resolveCatalogContext.js";
+import { getCatalogScanPaths } from "./browseCatalog.js";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { parseEventField, parseScheduleField, scheduleCronError, triggerReferenceError, } from "./createTrigger.js";
+export function parsePatchTriggerBody(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+        return { ok: false, status: 400, error: "Request body must be an object" };
+    }
+    const record = body;
+    const keys = Object.keys(record);
+    if (keys.length !== 1 || keys[0] !== "enabled") {
+        return {
+            ok: false,
+            status: 400,
+            error: "Only enabled is allowed in the request body",
+        };
+    }
+    if (typeof record.enabled !== "boolean") {
+        return { ok: false, status: 400, error: "enabled must be a boolean" };
+    }
+    return { enabled: record.enabled };
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function parsePutTriggerBody(body, triggerId) {
+    if (!isPlainObject(body)) {
+        return { ok: false, status: 400, error: "Request body must be an object" };
+    }
+    if ("id" in body && body.id !== triggerId) {
+        return { ok: false, status: 400, error: "id cannot be changed" };
+    }
+    if (typeof body.pipeline !== "string" || !body.pipeline.trim()) {
+        return { ok: false, status: 400, error: "pipeline is required" };
+    }
+    if (body.task !== undefined &&
+        body.task !== null &&
+        (typeof body.task !== "string" || !body.task.trim())) {
+        return { ok: false, status: 400, error: "task must be a non-empty string" };
+    }
+    if (body.kind !== "manual" && body.kind !== "schedule" && body.kind !== "event") {
+        return {
+            ok: false,
+            status: 400,
+            error: "kind must be one of: manual, schedule, event",
+        };
+    }
+    const scheduleRaw = body.kind === "schedule" ? (body.schedule === null ? undefined : body.schedule) : undefined;
+    const eventRaw = body.kind === "event" ? (body.event === null ? undefined : body.event) : undefined;
+    const schedule = parseScheduleField(scheduleRaw);
+    if (!schedule.ok) {
+        return { ok: false, status: 400, error: schedule.message };
+    }
+    const event = parseEventField(eventRaw);
+    if (!event.ok) {
+        return { ok: false, status: 400, error: event.message };
+    }
+    if (body.kind === "schedule" && schedule.value === undefined) {
+        return { ok: false, status: 400, error: "schedule.cron is required for kind=schedule" };
+    }
+    if (body.kind === "event" && event.value === undefined) {
+        return { ok: false, status: 400, error: "event.source is required for kind=event" };
+    }
+    if (typeof body.enabled !== "boolean") {
+        return { ok: false, status: 400, error: "enabled must be a boolean" };
+    }
+    return {
+        pipeline: body.pipeline,
+        ...(typeof body.task === "string" ? { task: body.task } : {}),
+        kind: body.kind,
+        ...(schedule.value !== undefined ? { schedule: schedule.value } : {}),
+        ...(event.value !== undefined ? { event: event.value } : {}),
+        enabled: body.enabled,
+    };
+}
+function projectRootFilterFromBody(body) {
+    if (!body || typeof body !== "object" || Array.isArray(body))
+        return undefined;
+    const wire = body.project_root;
+    return typeof wire === "string" && wire.trim().length > 0 ? wire.trim() : undefined;
+}
+async function locateWritableTrigger(cwd, store, triggerId, projectRootFilter) {
+    const located = await findCatalogTrigger({
+        store,
+        bootCwd: cwd,
+        triggerId,
+        projectRootFilter,
+    });
+    if (!located.ok) {
+        return {
+            ok: false,
+            status: located.status,
+            error: located.reason,
+            ...(located.status === 409 ? { project_roots: located.project_roots } : {}),
+        };
+    }
+    const roots = await resolveCatalogRoots({ store, bootCwd: cwd });
+    const root = findCatalogRoot(roots, located.match.project_root);
+    if (root?.read_only) {
+        return { ok: false, status: 403, error: "catalog_root_read_only" };
+    }
+    return { ok: true, match: located.match };
+}
+export async function updateTriggerEnabled(cwd, store, triggerId, enabled, options = {}) {
+    const located = await locateWritableTrigger(cwd, store, triggerId, options.projectRootFilter);
+    if (!located.ok) {
+        return located;
+    }
+    const { match } = located;
+    const yamlText = await readFile(match.path, "utf8");
+    const doc = parseDocument(yamlText);
+    if (!doc.contents || typeof doc.contents !== "object") {
+        return { ok: false, status: 500, error: "Trigger YAML must be an object" };
+    }
+    doc.set("enabled", enabled);
+    const patched = doc.toString();
+    const loadOutcome = loadTriggerFromYamlOutcome(patched, match.path);
+    if (!loadOutcome.ok) {
+        return {
+            ok: false,
+            status: 400,
+            error: loadOutcome.issues[0]?.message ?? "Invalid trigger after patch",
+        };
+    }
+    await writeFile(match.path, patched, "utf8");
+    await store.upsertTrigger({
+        id: triggerStoreId(match.project_root, loadOutcome.value.id),
+        definitionRef: match.definition_ref,
+        enabled: loadOutcome.value.enabled,
+    });
+    const items = await loadCatalogTriggers({ store, bootCwd: cwd });
+    const item = items.find((row) => row.id === triggerId && row.project_root === match.project_root);
+    if (!item) {
+        return { ok: false, status: 500, error: "Trigger updated but not listed" };
+    }
+    return { ok: true, trigger: item };
+}
+export async function updateTriggerDefinition(cwd, store, triggerId, input, options = {}) {
+    const located = await locateWritableTrigger(cwd, store, triggerId, options.projectRootFilter);
+    if (!located.ok) {
+        return located;
+    }
+    const { match } = located;
+    const ctx = catalogContextFromStageflow(await resolveStageflowContext(match.rootPath));
+    const scanPaths = await getCatalogScanPaths(ctx);
+    if (!scanPaths) {
+        return { ok: false, status: 404, error: "No Stageflow catalog found" };
+    }
+    const refError = await triggerReferenceError(scanPaths, input.pipeline, input.task);
+    if (refError) {
+        return { ok: false, status: 422, error: refError };
+    }
+    if (input.kind === "schedule") {
+        if (!input.schedule) {
+            return { ok: false, status: 422, error: "schedule.cron is required for kind=schedule" };
+        }
+        const cronError = scheduleCronError(input.schedule);
+        if (cronError) {
+            return { ok: false, status: 422, error: cronError };
+        }
+    }
+    const yamlText = await readFile(match.path, "utf8");
+    const doc = parseDocument(yamlText);
+    if (!doc.contents || typeof doc.contents !== "object") {
+        return { ok: false, status: 500, error: "Trigger YAML must be an object" };
+    }
+    doc.set("pipeline", input.pipeline);
+    if (input.task !== undefined)
+        doc.set("task", input.task);
+    else
+        doc.delete("task");
+    doc.set("kind", input.kind);
+    if (input.kind === "schedule" && input.schedule) {
+        doc.delete("event");
+        doc.set("schedule", {
+            cron: input.schedule.cron,
+            ...(input.schedule.timezone !== undefined ? { timezone: input.schedule.timezone } : {}),
+        });
+    }
+    else if (input.kind === "event" && input.event) {
+        doc.delete("schedule");
+        doc.set("event", {
+            source: input.event.source,
+            ...(input.event.match !== undefined ? { match: input.event.match } : {}),
+            ...(input.event.config !== undefined ? { config: input.event.config } : {}),
+        });
+    }
+    else {
+        doc.delete("schedule");
+        doc.delete("event");
+    }
+    doc.set("enabled", input.enabled);
+    const patched = doc.toString();
+    const loadOutcome = loadTriggerFromYamlOutcome(patched, match.path);
+    if (!loadOutcome.ok) {
+        return {
+            ok: false,
+            status: 400,
+            error: loadOutcome.issues[0]?.message ?? "Invalid trigger after update",
+        };
+    }
+    await writeFile(match.path, patched, "utf8");
+    await store.upsertTrigger({
+        id: triggerStoreId(match.project_root, loadOutcome.value.id),
+        definitionRef: match.definition_ref,
+        enabled: loadOutcome.value.enabled,
+    });
+    const items = await loadCatalogTriggers({ store, bootCwd: cwd });
+    const item = items.find((row) => row.id === triggerId && row.project_root === match.project_root);
+    if (!item) {
+        return { ok: false, status: 500, error: "Trigger updated but not listed" };
+    }
+    return { ok: true, trigger: item };
+}
+export { projectRootFilterFromBody };

package/dist/config/validateCatalog.d.ts

@@ -1,9 +1,10 @@
 import type { InlinePipelineDefinition, LoadedPipeline } from "../types/pipeline.js";
 import type { TriggerFile } from "../types/trigger.js";
 import type { LoadIssue } from "./loadOutcome.js";
+import type { AnyChannelProvider } from "../channels/types.js";
 export type ValidationSeverity = "error" | "warning";
 export type ValidationCategory = "pipeline" | "stage" | "catalog" | "task" | "trigger";
-export type ValidationFindingCode = "pipeline.invalid_shape" | "pipeline.dag_error" | "pipeline.missing_stage" | "pipeline.load_error" | "pipeline.string_stage_ref" | "pipeline.stage_uses_inline_conflict" | "pipeline.stage_missing_body" | "pipeline.stage_id_mismatch" | "pipeline.invalid_completion" | "catalog.path_case_mismatch" | "pipeline.invalid_recovery" | "pipeline.include_cycle" | "pipeline.include_invalid" | "pipeline.include_duplicate_stage" | "pipeline.invalid_agent" | "pipeline.invalid_model" | "pipeline.invalid_verify" | "pipeline.io_incompatible" | "pipeline.model_applies" | "pipeline.route_if_invalid" | "pipeline.route_all_gated" | "pipeline.invalid_requires" | "pipeline.requires_conflict" | "stage.invalid_shape" | "stage.invalid_model" | "stage.missing_model" | "stage.invalid_payload_schema" | "stage.invalid_clone_input_schema" | "stage.unresolved_schema_ref" | "stage.invalid_clone_actions" | "stage.invalid_gate_kinds" | "stage.invalid_pre_emit_checks" | "stage.invalid_timeout_ms" | "stage.invalid_skill" | "stage.invalid_mcp" | "stage.invalid_browser" | "stage.invalid_secrets" | "stage.unknown_secret" | "stage.denied_secret" | "stage.invalid_requires" | "stage.invalid_agent" | "stage.invalid_io" | "stage.load_error" | "stage.id_filename_mismatch" | "task.invalid_shape" | "task.load_error" | "task.entry_input_unmet" | "task.binding_conflict" | "task.repository_ref_required" | "task.ref_without_repository" | "task.repository_invalid" | "trigger.invalid_shape" | "trigger.load_error" | "trigger.unknown_pipeline" | "trigger.unknown_task" | "catalog.duplicate_pipeline_id" | "catalog.manifest_missing" | "catalog.manifest_invalid" | "catalog.empty_catalog" | "catalog.manifest_load_error" | "catalog.invalid_mcp" | "catalog.mcp_command_missing" | "catalog.mixed_yaml_dialect" | "catalog.legacy_yaml" | "catalog.stageflow_home_absolute_path";
+export type ValidationFindingCode = "pipeline.invalid_shape" | "pipeline.dag_error" | "pipeline.missing_stage" | "pipeline.load_error" | "pipeline.string_stage_ref" | "pipeline.stage_uses_inline_conflict" | "pipeline.stage_missing_body" | "pipeline.stage_id_mismatch" | "pipeline.stage_wrapper_skill_rejected" | "pipeline.invalid_completion" | "catalog.path_case_mismatch" | "pipeline.invalid_recovery" | "pipeline.include_cycle" | "pipeline.include_invalid" | "pipeline.include_duplicate_stage" | "pipeline.invalid_agent" | "pipeline.invalid_model" | "pipeline.invalid_verify" | "pipeline.io_incompatible" | "pipeline.model_applies" | "pipeline.route_if_invalid" | "pipeline.route_all_gated" | "pipeline.invalid_requires" | "pipeline.requires_conflict" | "pipeline.invalid_channels" | "stage.invalid_shape" | "stage.invalid_model" | "stage.missing_model" | "stage.invalid_payload_schema" | "stage.invalid_clone_input_schema" | "stage.unresolved_schema_ref" | "stage.invalid_clone_actions" | "stage.invalid_gate_kinds" | "stage.invalid_pre_emit_checks" | "stage.invalid_timeout_ms" | "stage.invalid_skill" | "stage.invalid_mcp" | "stage.invalid_channels" | "stage.channel_unavailable" | "stage.invalid_browser" | "stage.invalid_secrets" | "stage.unknown_secret" | "stage.denied_secret" | "stage.invalid_requires" | "stage.invalid_agent" | "stage.invalid_io" | "stage.load_error" | "stage.id_filename_mismatch" | "task.invalid_shape" | "task.load_error" | "task.entry_input_unmet" | "task.binding_conflict" | "task.repository_ref_required" | "task.ref_without_repository" | "task.repository_invalid" | "trigger.invalid_shape" | "trigger.load_error" | "trigger.unknown_pipeline" | "trigger.unknown_task" | "catalog.duplicate_pipeline_id" | "catalog.manifest_missing" | "catalog.manifest_invalid" | "catalog.empty_catalog" | "catalog.manifest_load_error" | "catalog.invalid_mcp" | "catalog.mcp_command_missing" | "catalog.mixed_yaml_dialect" | "catalog.legacy_yaml" | "catalog.stageflow_home_absolute_path";
 export type ValidationFinding = {
     severity: ValidationSeverity;
     code: ValidationFindingCode | string;
@@ -12,8 +13,10 @@ export type ValidationFinding = {
     category: ValidationCategory;
     pipelineId?: string;
     stageId?: string;
+    line?: number;
+    column?: number;
 };
-export type ValidationScope = "full" | "pipeline" | "task" | "trigger";
+export type ValidationScope = "full" | "pipeline" | "task" | "trigger" | "stage";
 export type ValidateCatalogOptions = {
     cwd?: string;
     projectRoot?: string;
@@ -21,6 +24,8 @@ export type ValidateCatalogOptions = {
     pipeline?: string;
     task?: string;
     trigger?: string;
+    stage?: string;
+    stageContent?: string;
     strict?: boolean;
 };
 export type ValidationResult = {
@@ -46,6 +51,7 @@ export type ValidatePipelineOptions = {
     projectRoot?: string;
     validateStages?: boolean;
     strict?: boolean;
+    channelProviders?: readonly AnyChannelProvider[];
 };
 export declare function validatePipeline(nameOrPath: string, options?: ValidatePipelineOptions): Promise<ValidationResult>;
 export type LoadPipelineValidatedResult = {
@@ -60,6 +66,7 @@ export declare function loadPipelineValidated(nameOrPath: string | InlinePipelin
     cwd?: string;
     projectRoot?: string;
     validateStages?: boolean;
+    channelProviders?: readonly AnyChannelProvider[];
 }): Promise<LoadPipelineValidatedResult>;
 export declare function collectPipelineIdsFromPaths(pipelinePaths: string[]): Promise<Map<string, string[]>>;
 export declare function collectTaskIdsFromPaths(taskPaths: string[]): Promise<Set<string>>;