stageflow 0.27.0 → 0.30.0

package/dist/config/hostConfig.js

@@ -63,6 +63,8 @@ export const KNOWN_STAGEFLOW_ENV_KEYS = new Set([
     "STAGEFLOW_TOOLCHAIN_MANIFEST",
     "STAGEFLOW_SECRET_REGISTRY",
     "STAGEFLOW_BUILD_SHA",
+    "STAGEFLOW_TRIGGER_TICK_INTERVAL_MS",
+    "STAGEFLOW_GITHUB_POLL_INTERVAL_MS",
 ]);
 const KNOWN_ENV_PREFIXES = [
     "STAGEFLOW_PROVIDER_",
@@ -78,6 +80,7 @@ const FILE_KEY_TO_FIELD = {
     trust_workspace_config: "trustWorkspaceConfig",
     allow_unknown_config: "allowUnknownConfig",
     callers: "callers",
+    browser: "browser",
 };
 const DEFAULT_MAX_CONCURRENT = 3;
 const DEFAULT_MAX_QUEUED = 32;
@@ -299,6 +302,29 @@ export function loadHostConfig(options) {
     if (file.values.callers !== undefined) {
         callers = coerceCallers(file.values.callers, "callers");
     }
+    let browserBlockedSites = [];
+    if (file.values.browser !== undefined) {
+        const raw = file.values.browser;
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+            throw new HostConfigError(`Invalid value for browser`, "config_invalid", "browser");
+        }
+        for (const sub of Object.keys(raw)) {
+            if (sub !== "blocked_sites") {
+                throw new HostConfigError(`Unknown key "${sub}" under browser`, "config_unknown_key", `browser.${sub}`);
+            }
+        }
+        const sites = raw.blocked_sites;
+        if (sites !== undefined) {
+            browserBlockedSites = coerceFileStringList(sites, "browser.blocked_sites")
+                .map((s) => s.trim().toLowerCase().replace(/^\*\./, "").replace(/^\./, ""))
+                .filter((s) => s.length > 0);
+            for (const site of browserBlockedSites) {
+                if (!/^[a-z0-9]([a-z0-9.-]*[a-z0-9])?$/.test(site)) {
+                    throw new HostConfigError(`Invalid domain "${site}" in browser.blocked_sites`, "config_invalid", "browser.blocked_sites");
+                }
+            }
+        }
+    }
     return {
         maxConcurrentRuns,
         maxConcurrentRunsPerProject,
@@ -309,6 +335,7 @@ export function loadHostConfig(options) {
         controlToken,
         readToken,
         callers,
+        browserBlockedSites,
         configFilePath: configFilePath !== undefined && existsSync(configFilePath)
             ? configFilePath
             : undefined,

package/dist/config/listSkills.d.ts

@@ -1,6 +1,6 @@
 export type SkillScope = "user" | "project" | "temporary";
 /** Skill resolution origin — separate from ConfigOriginKind. */
-export type SkillOrigin = "run" | "checkout" | "host";
+export type SkillOrigin = "run" | "checkout" | "host" | "builtin";
 export type SkillListing = {
     name: string;
     description: string;
@@ -41,7 +41,7 @@ export type SkillOriginListing = {
     origin: SkillOrigin;
 };
 /**
- * Resolve a skill by name. Search order: run skills → checkout `.pi/skills` → host agentDir.
+ * Resolve a skill by name. Search order: run skills → checkout `.pi/skills` → host agentDir → package built-ins.
  */
 export declare function resolveSkillByName(name: string, options: ListSkillsOptions): Promise<ResolvedSkill | undefined>;
 export declare function listSkills(options: ListSkillsOptions): Promise<SkillCatalog>;

package/dist/config/listSkills.js

@@ -1,5 +1,6 @@
 import { access, readFile, readdir } from "node:fs/promises";
 import path from "node:path";
+import { resolveBuiltinSkillFile } from "./builtinSkills.js";
 import { DefaultResourceLoader, SettingsManager, } from "@earendil-works/pi-coding-agent";
 function toListing(skill, origin) {
     return {
@@ -102,8 +103,21 @@ function originForLoaderSkill(skill, options) {
     }
     return "host";
 }
+function resolveBuiltinResolved(name) {
+    const filePath = resolveBuiltinSkillFile(name);
+    if (filePath === undefined)
+        return undefined;
+    return {
+        name,
+        filePath,
+        baseDir: path.dirname(filePath),
+        scope: "user",
+        source: "builtin",
+        origin: "builtin",
+    };
+}
 /**
- * Resolve a skill by name. Search order: run skills → checkout `.pi/skills` → host agentDir.
+ * Resolve a skill by name. Search order: run skills → checkout `.pi/skills` → host agentDir → package built-ins.
  */
 export async function resolveSkillByName(name, options) {
     if (options.runSkillsDir !== undefined) {
@@ -119,12 +133,12 @@ export async function resolveSkillByName(name, options) {
     const loader = await openSkillCatalogLoader(options);
     const match = loader.getSkills().skills.find((skill) => skill.name === name);
     if (!match)
-        return undefined;
+        return resolveBuiltinResolved(name);
     try {
         await access(match.filePath);
     }
     catch {
-        return undefined;
+        return resolveBuiltinResolved(name);
     }
     if (options.checkoutRoot !== undefined &&
         isUnderRoot(match.filePath, path.join(options.checkoutRoot, ".pi", "skills"))) {

package/dist/config/loadOutcome.d.ts

@@ -1,5 +1,6 @@
 import type { ValidationFindingCode } from "./validateCatalog.js";
 export type TaskLoadCode = "task.invalid_shape" | "task.load_error" | "task.binding_conflict" | "task.repository_ref_required" | "task.ref_without_repository" | "task.repository_invalid";
+export type TriggerLoadCode = "trigger.invalid_shape" | "trigger.load_error" | "trigger.unknown_pipeline" | "trigger.unknown_task";
 export type LoadIssue = {
     code: ValidationFindingCode;
     message: string;
@@ -16,6 +17,11 @@ export type LoadIssue = {
     message: string;
     category: "task";
     taskId?: string;
+} | {
+    code: TriggerLoadCode;
+    message: string;
+    category: "trigger";
+    triggerId?: string;
 } | {
     code: ValidationFindingCode | string;
     message: string;

package/dist/config/loadPipeline.js

@@ -13,6 +13,7 @@ import { validateCompletionContractForStage } from "./validateCompletionContract
 import { applyCloneChains } from "./cloneChain.js";
 import { collectRouteIfSchemaIssues, collectRouteIfIllegalCombos, collectRouteAllGatedWarnings, } from "./routeIf.js";
 import { mergeToolRequires } from "./toolRequires.js";
+import { withBrowserRequires } from "./stageBrowser.js";
 function schemaCompileIssue(stageId, field, err, pipelineId) {
     const message = err instanceof Error ? err.message : String(err);
     if (err instanceof UnresolvedSchemaRefError) {
@@ -189,6 +190,15 @@ async function buildLoadedPipelineFromMerge(merge, options) {
                     return loadFailure(merged.issues);
                 stage = { ...stage, requires: merged.value };
             }
+            const inlineRequires = withBrowserRequires(stage, {
+                pipelineId,
+                stageId: entry.id,
+            });
+            if (!inlineRequires.ok)
+                return loadFailure(inlineRequires.issues);
+            if (inlineRequires.value !== undefined) {
+                stage = { ...stage, requires: inlineRequires.value };
+            }
             stages.push(stage);
             stageSources[stageId] = { kind: "inline" };
             continue;
@@ -244,8 +254,14 @@ async function buildLoadedPipelineFromMerge(merge, options) {
                 return loadFailure(merged.issues);
             stageRequires = merged.value;
         }
+        const browser = entry.browser ?? stageOutcome.value.browser;
+        const fileRequires = withBrowserRequires({ browser, requires: stageRequires }, { pipelineId, stageId: entry.id });
+        if (!fileRequires.ok)
+            return loadFailure(fileRequires.issues);
+        stageRequires = fileRequires.value;
         const stage = {
             ...stageOutcome.value,
+            ...(browser !== undefined ? { browser } : {}),
             ...(entry.skill !== undefined ? { skill: entry.skill } : {}),
             ...(entry.mcp !== undefined ? { mcp: entry.mcp } : {}),
             ...(entry.secrets !== undefined ? { secrets: entry.secrets } : {}),

package/dist/config/loadStage.js

@@ -9,6 +9,7 @@ import { parsePreEmitChecks } from "./parsePreEmitChecks.js";
 import { readYamlObject } from "./readYamlObject.js";
 import { parseStageSecrets } from "../runtime/stageSecretDecl.js";
 import { parseToolRequires } from "./toolRequires.js";
+import { parseStageBrowser } from "./stageBrowser.js";
 import { classifyYamlDocument, compileTargetContract, dialectFromKeys, mixedDialectIssue, STAGE_FILE_WIRING_KEYS, } from "./yamlDialect.js";
 const afterCompletionByStage = new WeakMap();
 /** After-phase IR from target `verify` (`when` includes after). Stamped onto DAG `completion`. */
@@ -366,6 +367,12 @@ function parseStageFields(raw, label, entryId, deferSchemaRefs, requireIo, compi
     if (requiresOutcome.value !== undefined) {
         stage.requires = requiresOutcome.value;
     }
+    const browserOutcome = parseStageBrowser(raw.browser, label, entryId);
+    if (!browserOutcome.ok)
+        return browserOutcome;
+    if (browserOutcome.value !== undefined) {
+        stage.browser = browserOutcome.value;
+    }
     const agentField = parseAgentField(raw.agent);
     if (!agentField.ok) {
         return loadFailure([

package/dist/config/loadStageflowManifest.js

@@ -6,6 +6,7 @@ import { loadFailure, loadSuccess } from "./loadOutcome.js";
 import { parseModelField } from "./modelField.js";
 const DEFAULT_PIPELINE_PATTERN = "*.pipeline.yaml";
 const DEFAULT_TASK_PATTERN = "*.task.yaml";
+const DEFAULT_TRIGGER_PATTERN = "*.trigger.yaml";
 export function manifestPathForProject(projectRoot) {
     return path.join(projectRoot, "stageflow.yaml");
 }
@@ -39,6 +40,7 @@ function parsePatterns(raw, issues) {
     const defaults = {
         pipeline: DEFAULT_PIPELINE_PATTERN,
         task: DEFAULT_TASK_PATTERN,
+        trigger: DEFAULT_TRIGGER_PATTERN,
     };
     if (raw === undefined || raw === null) {
         return defaults;
@@ -58,15 +60,24 @@ function parsePatterns(raw, issues) {
         : typeof record.task === "string" && record.task.trim().length > 0
             ? record.task.trim()
             : null;
+    const trigger = record.trigger === undefined
+        ? defaults.trigger
+        : typeof record.trigger === "string" && record.trigger.trim().length > 0
+            ? record.trigger.trim()
+            : null;
     if (pipeline === null) {
         issues.push(catalogIssue("catalog.manifest_invalid", "catalog.patterns.pipeline must be a string"));
     }
     if (task === null) {
         issues.push(catalogIssue("catalog.manifest_invalid", "catalog.patterns.task must be a string"));
     }
+    if (trigger === null) {
+        issues.push(catalogIssue("catalog.manifest_invalid", "catalog.patterns.trigger must be a string"));
+    }
     return {
         pipeline: pipeline ?? defaults.pipeline,
         task: task ?? defaults.task,
+        trigger: trigger ?? defaults.trigger,
     };
 }
 export function parseStageflowManifestOutcome(yamlText, manifestPath, projectRoot) {
@@ -109,6 +120,14 @@ export function parseStageflowManifestOutcome(yamlText, manifestPath, projectRoo
             exclude = parsed;
         }
     }
+    const triggersRaw = catalogRecord.triggers;
+    let triggers;
+    if (triggersRaw !== undefined) {
+        const parsed = parseStringArray(triggersRaw, "triggers", issues);
+        if (parsed !== null) {
+            triggers = parsed;
+        }
+    }
     const patterns = parsePatterns(catalogRecord.patterns, issues);
     let agent;
     const agentField = parseAgentField(record.agent);
@@ -136,6 +155,9 @@ export function parseStageflowManifestOutcome(yamlText, manifestPath, projectRoo
     if (exclude !== undefined) {
         catalog.exclude = exclude;
     }
+    if (triggers !== undefined) {
+        catalog.triggers = triggers;
+    }
     if (catalogRecord.patterns !== undefined) {
         catalog.patterns = {};
         if (typeof catalogRecord.patterns.pipeline === "string") {
@@ -144,6 +166,9 @@ export function parseStageflowManifestOutcome(yamlText, manifestPath, projectRoo
         if (typeof catalogRecord.patterns.task === "string") {
             catalog.patterns.task = patterns.task;
         }
+        if (typeof catalogRecord.patterns.trigger === "string") {
+            catalog.patterns.trigger = patterns.trigger;
+        }
     }
     const manifest = {
         version: 1,

package/dist/config/loadTrigger.d.ts

@@ -0,0 +1,9 @@
+import type { TriggerFile } from "../types/trigger.js";
+import { type LoadOutcome } from "./loadOutcome.js";
+/** Structural TriggerFile shape only. */
+export declare function coerceTriggerFile(raw: unknown): TriggerFile | undefined;
+export declare function parseTriggerFile(raw: unknown, source?: string): LoadOutcome<TriggerFile>;
+export declare function loadTriggerFromYamlOutcome(yamlText: string, source?: string): LoadOutcome<TriggerFile>;
+export declare function loadTriggerOutcome(filePath: string): Promise<LoadOutcome<TriggerFile>>;
+export declare function loadTriggerFromYaml(yamlText: string, source?: string): TriggerFile;
+export declare function loadTrigger(filePath: string): Promise<TriggerFile>;

package/dist/config/loadTrigger.js

@@ -0,0 +1,120 @@
+import { readFile } from "node:fs/promises";
+import { parse as parseYaml } from "yaml";
+import { loadFailure, loadSuccess } from "./loadOutcome.js";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseSchedule(raw) {
+    if (!isPlainObject(raw) || typeof raw.cron !== "string")
+        return undefined;
+    return {
+        cron: raw.cron,
+        ...(typeof raw.timezone === "string" ? { timezone: raw.timezone } : {}),
+    };
+}
+function parseEvent(raw) {
+    if (!isPlainObject(raw) || typeof raw.source !== "string")
+        return undefined;
+    return {
+        source: raw.source,
+        ...(isPlainObject(raw.match) ? { match: raw.match } : {}),
+        ...(isPlainObject(raw.config) ? { config: raw.config } : {}),
+    };
+}
+/** Structural TriggerFile shape only. */
+export function coerceTriggerFile(raw) {
+    const record = raw;
+    if (typeof record?.id !== "string" ||
+        typeof record?.pipeline !== "string" ||
+        typeof record?.enabled !== "boolean") {
+        return undefined;
+    }
+    if (record.task !== undefined && typeof record.task !== "string") {
+        return undefined;
+    }
+    if (record.kind !== "manual" && record.kind !== "schedule" && record.kind !== "event") {
+        return undefined;
+    }
+    let schedule;
+    if (record.schedule !== undefined) {
+        schedule = parseSchedule(record.schedule);
+        if (schedule === undefined)
+            return undefined;
+    }
+    let event;
+    if (record.event !== undefined) {
+        event = parseEvent(record.event);
+        if (event === undefined)
+            return undefined;
+    }
+    return {
+        id: record.id,
+        pipeline: record.pipeline,
+        kind: record.kind,
+        enabled: record.enabled,
+        ...(typeof record.task === "string" ? { task: record.task } : {}),
+        ...(schedule !== undefined ? { schedule } : {}),
+        ...(event !== undefined ? { event } : {}),
+    };
+}
+export function parseTriggerFile(raw, source = "trigger") {
+    const record = raw;
+    const trigger = coerceTriggerFile(raw);
+    if (trigger === undefined) {
+        return loadFailure([
+            {
+                code: "trigger.invalid_shape",
+                message: `Invalid ${source}: id, pipeline, kind, and enabled are required`,
+                category: "trigger",
+                triggerId: typeof record?.id === "string" ? record.id : undefined,
+            },
+        ]);
+    }
+    return loadSuccess(trigger);
+}
+export function loadTriggerFromYamlOutcome(yamlText, source = "trigger yaml") {
+    let raw;
+    try {
+        raw = parseYaml(yamlText);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return loadFailure([
+            {
+                code: "trigger.load_error",
+                message,
+                category: "trigger",
+            },
+        ]);
+    }
+    return parseTriggerFile(raw, source);
+}
+export async function loadTriggerOutcome(filePath) {
+    let yamlText;
+    try {
+        yamlText = await readFile(filePath, "utf8");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return loadFailure([
+            {
+                code: "trigger.load_error",
+                message,
+                category: "trigger",
+            },
+        ]);
+    }
+    return loadTriggerFromYamlOutcome(yamlText, `trigger file ${filePath}`);
+}
+export function loadTriggerFromYaml(yamlText, source = "trigger yaml") {
+    const outcome = loadTriggerFromYamlOutcome(yamlText, source);
+    if (!outcome.ok)
+        throw new Error(outcome.issues[0].message);
+    return outcome.value;
+}
+export async function loadTrigger(filePath) {
+    const outcome = await loadTriggerOutcome(filePath);
+    if (!outcome.ok)
+        throw new Error(outcome.issues[0].message);
+    return outcome.value;
+}

package/dist/config/multiProjectCatalog.d.ts

@@ -9,7 +9,9 @@ export type MultiProjectListResult<T> = {
     items: T[];
     root_errors: CatalogRootError[];
     roots: CatalogRoot[];
+    tip?: string;
 };
+export declare const EMPTY_CATALOG_LIST_TIP = "No catalog entries listed. Register a project root (POST /api/projects or local sf run / ensure), ensure stageflow.yaml exists at that root, then retry list_pipelines / list_tasks. Packaged examples use project_root \"examples\" when present. Git is not required for discovery.";
 export declare function listPipelinesMultiProject(options: ResolveCatalogRootsOptions & {
     projectRootFilter?: string;
 }): Promise<MultiProjectListResult<PipelineListing & {

package/dist/config/multiProjectCatalog.js

@@ -1,27 +1,31 @@
 import { listModelsForContext, listPipelinesForContext, listTasksForContext, } from "./browseCatalog.js";
 import { loadStageflowManifestOutcome, } from "./loadStageflowManifest.js";
 import { findCatalogRoot, isRootReadable, resolveCatalogRoots, } from "./resolveCatalogRoots.js";
-import { catalogContextFromStageflow } from "./resolveCatalogContext.js";
-import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+export const EMPTY_CATALOG_LIST_TIP = "No catalog entries listed. Register a project root (POST /api/projects or local sf run / ensure), ensure stageflow.yaml exists at that root, then retry list_pipelines / list_tasks. Packaged examples use project_root \"examples\" when present. Git is not required for discovery.";
+function listTip(itemsLength, root_errors) {
+    if (itemsLength > 0)
+        return undefined;
+    if (root_errors.some((e) => e.code === "unknown_project_root")) {
+        return undefined;
+    }
+    return EMPTY_CATALOG_LIST_TIP;
+}
 async function catalogContextForRoot(root) {
-    if (root.kind === "seeded") {
-        const outcome = await loadStageflowManifestOutcome(root.path);
-        if (!outcome.ok) {
-            return {
-                projectRoot: root.path,
-                manifest: null,
-                manifestStatus: "invalid",
-                issues: outcome.issues,
-            };
-        }
+    const outcome = await loadStageflowManifestOutcome(root.path);
+    if (!outcome.ok) {
         return {
             projectRoot: root.path,
-            manifest: outcome.value,
-            manifestStatus: "ok",
-            issues: [],
+            manifest: null,
+            manifestStatus: "invalid",
+            issues: outcome.issues,
         };
     }
-    return catalogContextFromStageflow(await resolveStageflowContext(root.path));
+    return {
+        projectRoot: root.path,
+        manifest: outcome.value,
+        manifestStatus: "ok",
+        issues: [],
+    };
 }
 async function selectRoots(options) {
     const roots = await resolveCatalogRoots(options);
@@ -70,6 +74,10 @@ async function selectRoots(options) {
     }
     return { roots, selected, root_errors };
 }
+function withListTip(result) {
+    const tip = listTip(result.items.length, result.root_errors);
+    return tip !== undefined ? { ...result, tip } : result;
+}
 export async function listPipelinesMultiProject(options) {
     const { roots, selected, root_errors } = await selectRoots(options);
     const items = [];
@@ -89,7 +97,7 @@ export async function listPipelinesMultiProject(options) {
             });
         }
     }
-    return { items, root_errors, roots };
+    return withListTip({ items, root_errors, roots });
 }
 export async function listTasksMultiProject(options) {
     const { roots, selected, root_errors } = await selectRoots(options);
@@ -110,7 +118,7 @@ export async function listTasksMultiProject(options) {
             });
         }
     }
-    return { items, root_errors, roots };
+    return withListTip({ items, root_errors, roots });
 }
 export async function listModelsMultiProject(options) {
     const { roots, selected, root_errors } = await selectRoots(options);

package/dist/config/normalizePipelineStageEntry.js

@@ -8,6 +8,7 @@ import path from "node:path";
 import { loadFailure, loadSuccess } from "./loadOutcome.js";
 import { parseStageMcp } from "./loadStage.js";
 import { parseStageSecrets } from "../runtime/stageSecretDecl.js";
+import { parseStageBrowser } from "./stageBrowser.js";
 import { parseToolRequires } from "./toolRequires.js";
 import { legacyAuthoringRejected, presentLegacyKeys } from "./legacyYaml.js";
 import { compileTargetContract, dialectFromKeys, mixedDialectIssue, } from "./yamlDialect.js";
@@ -45,7 +46,8 @@ function hasBodyKey(raw) {
         key !== "skill" &&
         key !== "mcp" &&
         key !== "secrets" &&
-        key !== "requires");
+        key !== "requires" &&
+        key !== "browser");
 }
 function readSkill(raw) {
     if (raw.skill === undefined)
@@ -129,6 +131,10 @@ export function normalizePipelineStageEntries(rawEntries, ctx) {
         if (!requiresOutcome.ok)
             return requiresOutcome;
         const requires = requiresOutcome.value;
+        const browserOutcome = parseStageBrowser(raw.browser, `entry at index ${index} in ${declaringPath}`, typeof raw.id === "string" ? raw.id : undefined);
+        if (!browserOutcome.ok)
+            return browserOutcome;
+        const browser = browserOutcome.value;
         if (uses && hasBody) {
             return loadFailure([
                 {
@@ -358,6 +364,7 @@ export function normalizePipelineStageEntries(rawEntries, ctx) {
             ...(mcp !== undefined ? { mcp } : {}),
             ...(secrets !== undefined ? { secrets } : {}),
             ...(requires !== undefined ? { requires } : {}),
+            ...(browser !== undefined ? { browser } : {}),
             ...(cloneCap !== undefined ? { clone_cap: cloneCap } : {}),
             ...(cloneMode !== undefined ? { clone_mode: cloneMode } : {}),
         };

package/dist/config/parseCompletionContract.js

@@ -124,6 +124,12 @@ function parseCheck(raw, stageId, index) {
             return failure(stageId, "completion", `checks[${index}]: unknown key "${unknown}"`);
         return loadSuccess({ id, type: "payload_schema" });
     }
+    if (raw.type === "browser_login") {
+        const unknown = hasOnlyKeys(raw, ["id", "type"]);
+        if (unknown)
+            return failure(stageId, "completion", `checks[${index}]: unknown key "${unknown}"`);
+        return loadSuccess({ id, type: "browser_login" });
+    }
     if (raw.type === "gate") {
         const unknown = hasOnlyKeys(raw, ["id", "type", "kind"]);
         if (unknown)

package/dist/config/pipelineStageKeys.js

@@ -39,6 +39,7 @@ export const BODY_KEYS = new Set([
     "mcp",
     "secrets",
     "requires",
+    "browser",
     "io",
     "verify",
 ]);

package/dist/config/publishDraftPackage.d.ts

@@ -0,0 +1,7 @@
+import { type CreateDraftPackageInput, type DraftPackageWriteResult } from "./draftPackage.js";
+export type PublishDraftPackageMode = "create" | "overwrite" | "auto";
+export type PublishDraftPackageResult = {
+    write: DraftPackageWriteResult;
+    catalogChanged: boolean;
+};
+export declare function publishDraftPackage(projectRoot: string, input: CreateDraftPackageInput, mode: PublishDraftPackageMode): Promise<PublishDraftPackageResult>;

package/dist/config/publishDraftPackage.js

@@ -0,0 +1,25 @@
+import { createDraftPackage, overwriteDraftPackage, } from "./draftPackage.js";
+import { ensureCatalogScanRoot } from "./ensureCatalogScanRoot.js";
+export async function publishDraftPackage(projectRoot, input, mode) {
+    let write;
+    if (mode === "create") {
+        write = await createDraftPackage(projectRoot, input);
+    }
+    else if (mode === "overwrite") {
+        write = await overwriteDraftPackage(projectRoot, input);
+    }
+    else {
+        const created = await createDraftPackage(projectRoot, input);
+        if (created.ok || created.status !== 409) {
+            write = created;
+        }
+        else {
+            write = await overwriteDraftPackage(projectRoot, input);
+        }
+    }
+    if (!write.ok) {
+        return { write, catalogChanged: false };
+    }
+    const catalogChanged = await ensureCatalogScanRoot(projectRoot, input.directory);
+    return { write, catalogChanged };
+}

package/dist/config/resolveCatalogContext.js

@@ -1,7 +1,7 @@
 import { resolveStageflowContext, } from "../project/resolveStageflowContext.js";
 export function catalogContextFromStageflow(ctx) {
     return {
-        projectRoot: ctx.isGitProject ? ctx.projectRoot : null,
+        projectRoot: ctx.manifestStatus === "not_git" ? null : ctx.projectRoot,
         manifest: ctx.manifest,
         manifestStatus: ctx.manifestStatus,
         issues: ctx.manifestIssues,

package/dist/config/resolvePipelineDag.js

@@ -18,7 +18,7 @@ function wrapRawStagesForNormalize(rawStages, ctx) {
         }
         const id = typeof raw.id === "string" && raw.id ? raw.id : undefined;
         const hasUses = typeof raw.uses === "string";
-        const hasBody = Object.keys(raw).some((key) => BODY_KEYS.has(key) && key !== "skill" && key !== "mcp");
+        const hasBody = Object.keys(raw).some((key) => BODY_KEYS.has(key) && key !== "skill" && key !== "mcp" && key !== "browser");
         if (hasUses || hasBody || !id) {
             return { raw, declaringPath: ctx.path };
         }

package/dist/config/scanCatalogPaths.d.ts

@@ -1,4 +1,4 @@
 import type { LoadedManifest } from "../types/stageflowManifest.js";
-export type CatalogPathKind = "pipeline" | "task";
+export type CatalogPathKind = "pipeline" | "task" | "trigger";
 export declare function isExcluded(repoRelPath: string, exclude: string[] | undefined): boolean;
 export declare function scanCatalogPaths(manifest: LoadedManifest, kind: CatalogPathKind): Promise<string[]>;

package/dist/config/scanCatalogPaths.js

@@ -60,8 +60,12 @@ async function expandCatalogEntry(projectRoot, entry, kind, pattern) {
 }
 export async function scanCatalogPaths(manifest, kind) {
     const { projectRoot, manifest: doc, patterns } = manifest;
-    const entries = kind === "pipeline" ? doc.catalog.pipelines : doc.catalog.tasks;
-    const pattern = kind === "pipeline" ? patterns.pipeline : patterns.task;
+    const entries = kind === "pipeline"
+        ? doc.catalog.pipelines
+        : kind === "task"
+            ? doc.catalog.tasks
+            : (doc.catalog.triggers ?? []);
+    const pattern = kind === "pipeline" ? patterns.pipeline : kind === "task" ? patterns.task : patterns.trigger;
     const exclude = doc.catalog.exclude;
     const seen = new Set();
     const resolved = [];

package/dist/config/stageBrowser.d.ts

@@ -0,0 +1,12 @@
+import type { StageBrowserConfig } from "../types/stage.js";
+import { type LoadOutcome } from "./loadOutcome.js";
+import { type ToolRequirement } from "./toolRequires.js";
+export declare const BROWSER_TOOL_NAME = "agent-browser";
+export declare function parseStageBrowser(raw: unknown, label: string, stageId?: string): LoadOutcome<StageBrowserConfig | undefined>;
+export declare function withBrowserRequires(stage: {
+    browser?: StageBrowserConfig;
+    requires?: ToolRequirement[];
+}, ctx: {
+    pipelineId: string;
+    stageId: string;
+}): LoadOutcome<ToolRequirement[] | undefined>;