stageflow 0.36.0 → 0.40.0

package/dist/channels/providers/agentmail.js

@@ -12,6 +12,7 @@ export const AGENTMAIL_META = {
         { key: "inbox", label: "Inbox address", hint: "An existing AgentMail inbox. Stageflow does not create one.", target: "config", input: "text", required: true, placeholder: "research@agentmail.to" },
         { key: "region", label: "Region", target: "config", input: "select", required: false, defaultValue: "us", options: [{ value: "us", label: "United States" }, { value: "eu", label: "Europe" }] },
         { key: "apiKey", label: "API key", hint: "Needs to read the inbox and send messages.", target: "secret", input: "password", required: true, placeholder: "am_..." },
+        { key: "inboundSecret", label: "Webhook secret (optional)", hint: "Lets agents receive mail for this inbox. Sign webhooks to /api/agent-inbound/<connection id> with this secret (HMAC-SHA256 of the body in the x-agentmail-signature header).", target: "secret", input: "password", required: false },
     ],
     recipient: { label: "To", placeholder: "oncall@acme.com, lead@acme.com", multiple: true, cc: true, template: false },
     envNames: ["AGENTMAIL_API_KEY"],
@@ -49,7 +50,7 @@ export function createAgentMailProvider(options = {}) {
         id: "agentmail",
         meta: AGENTMAIL_META,
         operations: ["send"],
-        secrets: { required: ["apiKey"] },
+        secrets: { required: ["apiKey"], optional: ["inboundSecret"] },
         validateConfig,
         validateTarget,
         describe: config => ({ identity: config.inbox }),
@@ -62,6 +63,18 @@ export function createAgentMailProvider(options = {}) {
                 return;
             throw result.status === 404 ? new ChannelError("CHANNEL_INVALID_INPUT") : statusFailure(result.status, "check", connection.id);
         }),
+        async reply(connection, replyTo, message, _context) {
+            const result = await httpCall({
+                fetch: doFetch, url: `${inboxUrl(connection)}/messages/${encodeURIComponent(replyTo)}/reply`, method: "POST", headers: auth(connection),
+                body: { text: message.text },
+                timeoutMs: options.sendTimeoutMs ?? 30000, mode: "send", connectionId: connection.id,
+            });
+            if (result.status < 200 || result.status >= 300) {
+                throw result.status === 404 ? new ChannelError("CHANNEL_INVALID_INPUT", false, { connectionId: connection.id }) : statusFailure(result.status, "send", connection.id);
+            }
+            const body = parseJson(result.text);
+            return receiptFor(typeof body?.message_id === "string" ? body.message_id : undefined);
+        },
         async send(connection, target, message, _context) {
             const result = await httpCall({
                 fetch: doFetch, url: `${inboxUrl(connection)}/messages/send`, method: "POST", headers: auth(connection),

package/dist/channels/providers/photonImessage.js

@@ -137,6 +137,42 @@ export function createPhotonImessageProvider(options = {}) {
                     throw new ChannelError("CHANNEL_RECIPIENT_REJECTED", false, { connectionId: connection.id });
             }
         }),
+        async contact(connection, signal) {
+            try {
+                const credentials = credentialsOf(connection);
+                const project = encodeURIComponent(credentials.projectId);
+                const call = (url, init) => httpCall({
+                    fetch: doFetch, url, method: init.method, headers: photonHeaders(credentials), ...(init.body !== undefined ? { body: init.body } : {}),
+                    timeoutMs: options.checkTimeoutMs ?? 10000, ...(signal ? { signal } : {}), mode: "check", connectionId: connection.id,
+                });
+                const tokens = await call(`${base}/projects/${project}/imessage/tokens`, { method: "POST", body: {} });
+                if (tokens.status < 200 || tokens.status >= 300)
+                    return { ok: false, error: `Photon answered ${tokens.status}` };
+                const data = photonData(parseJson(tokens.text));
+                if (data?.type === "dedicated") {
+                    const numbers = Object.values((data.numbers ?? {})).filter((value) => typeof value === "string");
+                    return { ok: true, kind: "dedicated", numbers: [...new Set(numbers)] };
+                }
+                const users = await call(`${base}/projects/${project}/users/?type=shared&limit=500`, { method: "GET" });
+                if (users.status < 200 || users.status >= 300)
+                    return { ok: false, error: `Photon answered ${users.status}` };
+                const list = (photonData(parseJson(users.text))?.users ?? []);
+                return {
+                    ok: true,
+                    kind: "shared",
+                    users: list
+                        .filter((user) => typeof user.phoneNumber === "string")
+                        .map((user) => ({
+                        phone: user.phoneNumber,
+                        assignedNumber: typeof user.assignedPhoneNumber === "string" ? user.assignedPhoneNumber : null,
+                        name: [user.firstName, user.lastName].filter((part) => typeof part === "string" && part.length > 0).join(" ") || null,
+                    })),
+                };
+            }
+            catch {
+                return { ok: false, error: "Could not reach Photon" };
+            }
+        },
         async send(connection, target, message, _context) {
             const credentials = credentialsOf(connection);
             const text = message.subject ? `${message.subject}\n\n${message.text}` : message.text;

package/dist/channels/providers/slack.js

@@ -10,6 +10,7 @@ export const SLACK_META = {
     fields: [
         { key: "botToken", label: "Bot token", hint: "xoxb-… from your Slack app (OAuth & Permissions). Needs chat:write.", target: "secret", input: "password", required: true, placeholder: "xoxb-..." },
         { key: "teamId", label: "Workspace ID (optional)", hint: "Pins the connection to one workspace, such as T0123ABCD.", target: "config", input: "text", required: false, placeholder: "T0123ABCD" },
+        { key: "inboundSecret", label: "Signing secret (optional)", hint: "Lets agents receive messages from this workspace. From your Slack app (Basic Information). Point Event Subscriptions at /api/agent-inbound/<connection id>.", target: "secret", input: "password", required: false },
     ],
     recipient: { label: "Channel id", placeholder: "C0123ABCD (channel, group, DM or user id)", multiple: false, cc: false, template: false },
     envNames: ["SLACK_BOT_TOKEN"],
@@ -63,7 +64,7 @@ export function createSlackProvider(options = {}) {
         id: "slack",
         meta: SLACK_META,
         operations: ["send"],
-        secrets: { required: ["botToken"] },
+        secrets: { required: ["botToken"], optional: ["inboundSecret"] },
         validateConfig,
         validateTarget,
         describe: config => (config.teamId ? { identity: config.teamId } : {}),

package/dist/channels/providers/telegram.js

@@ -11,6 +11,7 @@ export const TELEGRAM_META = {
     fields: [
         { key: "botToken", label: "Bot token", hint: "From @BotFather. People must start the bot before it can message them.", target: "secret", input: "password", required: true, placeholder: "123456:ABC..." },
         { key: "botUsername", label: "Bot username (optional)", hint: "Fails the check if the token belongs to another bot.", target: "config", input: "text", required: false, placeholder: "acme_alerts_bot" },
+        { key: "inboundSecret", label: "Webhook secret (optional)", hint: "Lets agents receive messages from this bot. Use it as secret_token in setWebhook with the URL /api/agent-inbound/<connection id>.", target: "secret", input: "password", required: false },
     ],
     recipient: { label: "Chat id", placeholder: "123456789 or @channelname", multiple: false, cc: false, template: false },
     envNames: ["TELEGRAM_BOT_TOKEN"],
@@ -60,7 +61,7 @@ export function createTelegramProvider(options = {}) {
         id: "telegram",
         meta: TELEGRAM_META,
         operations: ["send"],
-        secrets: { required: ["botToken"] },
+        secrets: { required: ["botToken"], optional: ["inboundSecret"] },
         validateConfig,
         validateTarget,
         describe: config => (config.botUsername ? { identity: `@${config.botUsername}` } : {}),

package/dist/channels/types.d.ts

@@ -107,6 +107,23 @@ export type ProviderMeta = {
     /** The `to:` lines (and template, if any) of a stage `channels:` entry for this provider. */
     stageExample: string;
 };
+/** Where to text or write to reach an agent on a connection. */
+export type ContactInfo = {
+    ok: true;
+    kind: "dedicated";
+    numbers: string[];
+} | {
+    ok: true;
+    kind: "shared";
+    users: Array<{
+        phone: string;
+        assignedNumber: string | null;
+        name: string | null;
+    }>;
+} | {
+    ok: false;
+    error: string;
+};
 export interface ChannelProvider<C = unknown, T = unknown> {
     readonly id: string;
     readonly meta: ProviderMeta;
@@ -127,6 +144,16 @@ export interface ChannelProvider<C = unknown, T = unknown> {
      */
     checkTargets?(connection: ResolvedConnection<C>, targets: T[], signal?: AbortSignal): Promise<ConnectionHealth>;
     send(connection: ResolvedConnection<C>, target: T, message: OutboundMessage, context: SendContext): Promise<SendReceipt>;
+    /**
+     * How people reach this connection: the number or address to text or write, when the provider can tell.
+     * Read-only and best-effort; failures are returned, not thrown.
+     */
+    contact?(connection: ResolvedConnection<C>, signal?: AbortSignal): Promise<ContactInfo>;
+    /**
+     * Answers a message the provider delivered, inside its conversation (an email reply keeps the thread and
+     * subject). `replyTo` is the opaque handle the inbound message carried. Providers without it fall back to `send`.
+     */
+    reply?(connection: ResolvedConnection<C>, replyTo: string, message: OutboundMessage, context: SendContext): Promise<SendReceipt>;
 }
 export type AnyChannelProvider = ChannelProvider<any, any>;
 export type ConnectionSummary = {

package/dist/cli/agentsCommand.d.ts

@@ -0,0 +1,14 @@
+import { type EnsureGlobalServiceResult } from "../server/ensureGlobalService.js";
+export declare const AGENTS_USAGE = "Usage:\n  sf agents list [--json]\n  sf agents get <id> [--json]\n  sf agents validate <file.agent.yaml> [--json]\n  sf agents enable <id> [--json]\n  sf agents disable <id> [--json]\n  sf agents history <id> [--json]\n  sf agents restore <id> <revision> --base <current revision> [--json]\n  sf agents sessions <id> [--status <status>] [--json]\n  sf agents session <id> <sessionId> [--json]\n  sf agents chat <id> --message <text> [--session <sessionId>] [--json]\n  sf agents approve <id> <sessionId> [--json]\n  sf agents deny <id> <sessionId> [--json]\n\nrestore needs --base: the revision you looked at. If the agent has moved on since, the restore is refused instead of\noverwriting a newer edit. Run it without --base to see the current revision.\n\nTalks to the running Stageflow Host for the project in the current directory.";
+export type AgentsCommandIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+    write: (chunk: string) => void;
+};
+export declare function runAgentsCommand(args: string[], options?: {
+    io?: Partial<AgentsCommandIo>;
+    cwd?: string;
+    projectRoot?: string;
+    hostBaseUrl?: string;
+    ensureService?: () => Promise<EnsureGlobalServiceResult>;
+}): Promise<number>;

package/dist/cli/agentsCommand.js

@@ -0,0 +1,291 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { clientAuthorizationHeaders } from "../server/controlToken.js";
+import { ensureGlobalService, hostBaseUrl } from "../server/ensureGlobalService.js";
+export const AGENTS_USAGE = `Usage:
+  sf agents list [--json]
+  sf agents get <id> [--json]
+  sf agents validate <file.agent.yaml> [--json]
+  sf agents enable <id> [--json]
+  sf agents disable <id> [--json]
+  sf agents history <id> [--json]
+  sf agents restore <id> <revision> --base <current revision> [--json]
+  sf agents sessions <id> [--status <status>] [--json]
+  sf agents session <id> <sessionId> [--json]
+  sf agents chat <id> --message <text> [--session <sessionId>] [--json]
+  sf agents approve <id> <sessionId> [--json]
+  sf agents deny <id> <sessionId> [--json]
+
+restore needs --base: the revision you looked at. If the agent has moved on since, the restore is refused instead of
+overwriting a newer edit. Run it without --base to see the current revision.
+
+Talks to the running Stageflow Host for the project in the current directory.`;
+const defaultIo = {
+    log: (line) => console.log(line),
+    error: (line) => console.error(line),
+    write: (chunk) => process.stdout.write(chunk),
+};
+const FLAGS_WITH_VALUE = new Set(["--message", "--session", "--status", "--base"]);
+function parseArgs(args) {
+    const parsed = { help: false, json: false, positional: [] };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--help" || arg === "-h")
+            parsed.help = true;
+        else if (arg === "--json")
+            parsed.json = true;
+        else if (FLAGS_WITH_VALUE.has(arg)) {
+            const value = args[++index];
+            if (value === undefined || value.length === 0)
+                throw new Error(`Missing value for ${arg}`);
+            if (arg === "--message")
+                parsed.message = value;
+            else if (arg === "--session")
+                parsed.session = value;
+            else if (arg === "--base")
+                parsed.base = value;
+            else
+                parsed.status = value;
+        }
+        else if (arg.startsWith("-"))
+            throw new Error(`Unknown flag: ${arg}`);
+        else if (parsed.subcommand === undefined)
+            parsed.subcommand = arg;
+        else
+            parsed.positional.push(arg);
+    }
+    return parsed;
+}
+class HostError extends Error {
+    code;
+    issues;
+    constructor(code, message, issues = []) {
+        super(message);
+        this.code = code;
+        this.issues = issues;
+    }
+}
+function hostClient(base, projectRoot) {
+    const withRoot = (urlPath) => {
+        const url = new URL(urlPath, base);
+        url.searchParams.set("project_root", projectRoot);
+        return url;
+    };
+    const fail = async (res) => {
+        const body = (await res.json().catch(() => ({})));
+        throw new HostError(body.code ?? `http_${res.status}`, body.message ?? body.code ?? `Host returned ${res.status}`, body.issues);
+    };
+    return {
+        async get(urlPath) {
+            const res = await fetch(withRoot(urlPath), { headers: clientAuthorizationHeaders("GET") });
+            if (!res.ok)
+                await fail(res);
+            return res.json();
+        },
+        async post(urlPath, body) {
+            const res = await fetch(withRoot(urlPath), {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...clientAuthorizationHeaders("POST") },
+                body: JSON.stringify(body ?? {}),
+            });
+            if (!res.ok)
+                await fail(res);
+            return res.json();
+        },
+        async stream(urlPath, body, onFrame) {
+            const res = await fetch(withRoot(urlPath), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/x-ndjson",
+                    ...clientAuthorizationHeaders("POST"),
+                },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok || !res.body)
+                await fail(res);
+            const decoder = new TextDecoder();
+            let buffered = "";
+            for await (const chunk of res.body) {
+                buffered += decoder.decode(chunk, { stream: true });
+                let newline = buffered.indexOf("\n");
+                while (newline >= 0) {
+                    const line = buffered.slice(0, newline).trim();
+                    buffered = buffered.slice(newline + 1);
+                    if (line)
+                        onFrame(JSON.parse(line));
+                    newline = buffered.indexOf("\n");
+                }
+            }
+        },
+    };
+}
+export async function runAgentsCommand(args, options = {}) {
+    const io = { ...defaultIo, ...options.io };
+    let parsed;
+    try {
+        parsed = parseArgs(args);
+    }
+    catch (error) {
+        io.error(error instanceof Error ? error.message : String(error));
+        io.error(AGENTS_USAGE);
+        return 1;
+    }
+    if (parsed.help || !parsed.subcommand) {
+        io.error(AGENTS_USAGE);
+        return parsed.help ? 0 : 1;
+    }
+    const need = (count, what) => {
+        if (parsed.positional.length !== count)
+            throw new HostError("usage", `${parsed.subcommand} needs ${what}`);
+        return parsed.positional;
+    };
+    const print = (value, human) => (parsed.json ? io.log(JSON.stringify(value, null, 2)) : human());
+    try {
+        const cwd = options.cwd ?? process.cwd();
+        const projectRoot = options.projectRoot ?? (await resolveStageflowContext(cwd)).projectRoot;
+        const ensured = await (options.ensureService ?? (() => ensureGlobalService()))();
+        if (!ensured.ok)
+            throw new HostError("host.unavailable", ensured.message);
+        const client = hostClient(options.hostBaseUrl ?? hostBaseUrl(), projectRoot);
+        const agentPath = (id, tail = "") => `/api/agents/${encodeURIComponent(id)}${tail}`;
+        switch (parsed.subcommand) {
+            case "list": {
+                need(0, "no arguments");
+                const { agents } = await client.get("/api/agents");
+                print({ agents }, () => {
+                    for (const agent of agents) {
+                        const state = agent.issues.length > 0 ? "invalid" : agent.enabled ? "enabled" : "disabled";
+                        io.log(`${agent.id}\tv${agent.revision}\t${state}\t${agent.name}`);
+                    }
+                });
+                return 0;
+            }
+            case "get": {
+                const [id] = need(1, "<id>");
+                const detail = await client.get(agentPath(id));
+                print(detail, () => io.log(detail.yaml ?? "(no valid revision)"));
+                return 0;
+            }
+            case "validate": {
+                const [file] = need(1, "<file.agent.yaml>");
+                const definition = parseYaml(await readFile(path.resolve(cwd, file), "utf8"));
+                const result = await client.post("/api/agents/validate", { definition });
+                print(result, () => {
+                    for (const issue of result.issues)
+                        io.error(`error   ${issue.path || "(file)"}: ${issue.message}`);
+                    for (const warning of result.warnings)
+                        io.error(`warning ${warning.path}: ${warning.message}`);
+                    if (result.issues.length === 0)
+                        io.log("valid");
+                });
+                return result.issues.length === 0 ? 0 : 1;
+            }
+            case "enable":
+            case "disable": {
+                const [id] = need(1, "<id>");
+                const detail = await client.post(agentPath(id, `/${parsed.subcommand}`));
+                print(detail, () => io.log(`${id} ${parsed.subcommand}d (v${detail.agent.revision})`));
+                return 0;
+            }
+            case "history": {
+                const [id] = need(1, "<id>");
+                const { revisions } = await client.get(agentPath(id, "/revisions"));
+                print({ revisions }, () => {
+                    for (const row of revisions)
+                        io.log(`v${row.revision}\t${row.createdAt}\t${row.source}\t${row.summary ?? ""}`);
+                });
+                return 0;
+            }
+            case "restore": {
+                const [id, raw] = need(2, "<id> <revision>");
+                const revision = Number(raw);
+                if (!Number.isInteger(revision) || revision < 1)
+                    throw new HostError("usage", "revision must be a positive integer");
+                if (parsed.base === undefined) {
+                    // The lock only means something if the caller names the revision they saw; reading it here and echoing it back would not.
+                    const current = await client.get(agentPath(id));
+                    throw new HostError("usage", `restore needs --base: ${id} is at v${current.agent.revision}. Pass --base ${current.agent.revision} to restore v${revision} over it`);
+                }
+                const baseRevision = Number(parsed.base);
+                if (!Number.isInteger(baseRevision) || baseRevision < 1)
+                    throw new HostError("usage", "--base must be a positive integer");
+                const detail = await client.post(agentPath(id, `/revisions/${revision}/restore`), { baseRevision });
+                print(detail, () => io.log(`${id} restored v${revision} as v${detail.agent.revision}`));
+                return 0;
+            }
+            case "sessions": {
+                const [id] = need(1, "<id>");
+                const query = parsed.status ? `?status=${encodeURIComponent(parsed.status)}` : "";
+                const page = await client.get(agentPath(id, `/sessions${query}`));
+                print(page, () => {
+                    for (const row of page.sessions)
+                        io.log(`${row.id}\t${row.status}\t${row.source}\t${row.updatedAt}\t${row.title ?? ""}`);
+                });
+                return 0;
+            }
+            case "session": {
+                const [id, sessionId] = need(2, "<id> <sessionId>");
+                const detail = await client.get(agentPath(id, `/sessions/${encodeURIComponent(sessionId)}`));
+                print(detail, () => {
+                    for (const message of detail.messages)
+                        io.log(`${message.author ?? message.role}: ${message.text}\n`);
+                });
+                return 0;
+            }
+            case "chat": {
+                const [id] = need(1, "<id>");
+                if (!parsed.message)
+                    throw new HostError("usage", "chat needs --message");
+                let failure;
+                let done;
+                await client.stream(agentPath(id, "/chat"), { message: parsed.message, ...(parsed.session ? { sessionId: parsed.session } : {}) }, (frame) => {
+                    if (frame.type === "delta" && !parsed.json)
+                        io.write(String(frame.text));
+                    else if (frame.type === "session" && !parsed.json)
+                        io.error(`session ${String(frame.sessionId)}`);
+                    else if (frame.type === "done")
+                        done = frame.session;
+                    else if (frame.type === "error")
+                        failure = new HostError(String(frame.code), String(frame.message ?? frame.code));
+                });
+                if (failure)
+                    throw failure;
+                // A stream that ends with neither a result nor an error was cut off: not a success.
+                if (done === undefined)
+                    throw new HostError("agent.stream_closed", "The Host closed the connection before the reply finished");
+                if (parsed.json)
+                    io.log(JSON.stringify(done, null, 2));
+                else
+                    io.write("\n");
+                return 0;
+            }
+            case "approve":
+            case "deny": {
+                const [id, sessionId] = need(2, "<id> <sessionId>");
+                const result = await client.post(agentPath(id, `/sessions/${encodeURIComponent(sessionId)}/approval/${parsed.subcommand}`));
+                print(result, () => io.log(`${parsed.subcommand === "approve" ? "Approved" : "Denied"} ${result.approval.tool}`));
+                return 0;
+            }
+            default:
+                throw new HostError("usage", `Unknown subcommand: ${parsed.subcommand}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof HostError) {
+            if (parsed.json)
+                io.log(JSON.stringify({ code: error.code, message: error.message, issues: error.issues }, null, 2));
+            else {
+                io.error(error.message);
+                for (const issue of error.issues)
+                    io.error(`  ${issue.path || "(file)"}: ${issue.message}`);
+            }
+            if (error.code === "usage")
+                io.error(AGENTS_USAGE);
+            return 1;
+        }
+        throw error;
+    }
+}

package/dist/cli.js

@@ -18,6 +18,7 @@ import { PROVIDERS_USAGE, runProvidersCommand } from "./cli/providersCommand.js"
 import { RUN_USAGE, runRunCommand } from "./cli/runCommand.js";
 import { RUN_STAGE_USAGE, runRunStageCommand } from "./cli/runStageCommand.js";
 import { RUNS_USAGE, runRunsCommand } from "./cli/runsCommand.js";
+import { AGENTS_USAGE, runAgentsCommand } from "./cli/agentsCommand.js";
 import { TRIGGER_USAGE, runTriggerCommand } from "./cli/triggerCommand.js";
 import { resolveOperatorCatalog } from "./cli/operatorCatalog.js";
 import { SKILLS_USAGE, runSkillsCommand } from "./cli/skillsCommand.js";
@@ -124,6 +125,8 @@ ${RUNS_USAGE}
 
 ${TRIGGER_USAGE}
 
+${AGENTS_USAGE}
+
 ${PROVIDERS_USAGE}
 
 ${SKILLS_USAGE}
@@ -165,6 +168,7 @@ function parseArgs(argv) {
         command === "export" ||
         command === "runs" ||
         command === "trigger" ||
+        command === "agents" ||
         command === "skills" ||
         command === "browser") {
         return { help: false, command };
@@ -491,6 +495,11 @@ async function main(argv) {
                 cwd: ctx.invocationCwd,
             });
         }
+        if (parsed.command === "agents") {
+            return runAgentsCommand(argv.slice(3), {
+                cwd: ctx.invocationCwd,
+            });
+        }
         if (parsed.command === "providers") {
             return runProvidersCommand(argv.slice(3), ctx.invocationCwd);
         }

package/dist/config/browseCatalog.js

@@ -3,11 +3,6 @@ import { loadPipeline } from "./loadPipeline.js";
 import { loadTask } from "./loadTask.js";
 import { resolveStageflowContext, } from "../project/resolveStageflowContext.js";
 import { scanCatalogPaths } from "./scanCatalogPaths.js";
-const BAKED_MODEL_IDS = [
-    "anthropic/claude-sonnet-4-5",
-    "cursor/auto",
-    "cursor/composer-2-5",
-];
 function repoRelPath(projectRoot, absPath) {
     return path.relative(projectRoot, absPath).replace(/\\/g, "/");
 }
@@ -30,9 +25,6 @@ function mapStageListing(stage, source, projectRoot) {
     }
     return listing;
 }
-function bakedModels() {
-    return [...BAKED_MODEL_IDS].sort((a, b) => a.localeCompare(b));
-}
 function catalogReadyFromStageflow(ctx) {
     return ctx.manifestStatus === "ok" && ctx.manifest !== null;
 }
@@ -106,8 +98,9 @@ async function listPipelinesFromManifest(projectRoot, manifest, warnings) {
     });
     return listings;
 }
+/** Model ids the project's pipelines already use. The provider catalog (src/models) owns the choosable list. */
 async function listModelsFromManifest(projectRoot, manifest) {
-    const models = new Set(BAKED_MODEL_IDS);
+    const models = new Set();
     const filePaths = await scanCatalogPaths(manifest, "pipeline");
     for (const filePath of filePaths) {
         try {
@@ -139,7 +132,7 @@ export async function browseCatalog(invocationCwd) {
             ...base,
             pipelines: [],
             tasks: [],
-            models: bakedModels(),
+            models: [],
             warnings: [],
         };
     }
@@ -171,7 +164,7 @@ export async function listTasksForContext(ctx) {
 }
 export async function listModelsForContext(ctx) {
     if (!catalogReady(ctx)) {
-        return bakedModels();
+        return [];
     }
     return listModelsFromManifest(ctx.projectRoot, ctx.manifest);
 }

package/dist/config/draftPackage.d.ts

@@ -13,6 +13,7 @@ export type DraftPackage = {
         schemas?: unknown;
         requires?: unknown;
         channels?: unknown;
+        memories?: unknown;
     };
     stages?: DraftStageArtifact[];
     task?: {

package/dist/config/draftPackage.js

@@ -79,6 +79,8 @@ function pipelineDocument(pipeline) {
         doc.requires = pipeline.requires;
     if (pipeline.channels !== undefined)
         doc.channels = pipeline.channels;
+    if (pipeline.memories !== undefined)
+        doc.memories = pipeline.memories;
     return doc;
 }
 function resolveDirectory(projectRoot, directory) {
@@ -167,6 +169,7 @@ export async function validateDraftPackage(draft, options = {}) {
                 ? { requires: draft.pipeline.requires }
                 : {}),
             ...(draft.pipeline.channels !== undefined ? { channels: draft.pipeline.channels } : {}),
+            ...(draft.pipeline.memories !== undefined ? { memories: draft.pipeline.memories } : {}),
         };
         const result = await loadPipelineValidated(inline, {
             cwd,
@@ -720,6 +723,7 @@ export async function loadDraftPackage(projectRoot, pipelineRelPath, options = {
             ...(raw.schemas !== undefined ? { schemas: raw.schemas } : {}),
             ...(raw.requires !== undefined ? { requires: raw.requires } : {}),
             ...(raw.channels !== undefined ? { channels: raw.channels } : {}),
+            ...(raw.memories !== undefined ? { memories: raw.memories } : {}),
         },
         ...(stageArtifacts.length > 0 ? { stages: stageArtifacts } : {}),
     };

package/dist/config/hostConfig.js

@@ -56,6 +56,8 @@ export const KNOWN_STAGEFLOW_ENV_KEYS = new Set([
     "STAGEFLOW_MAX_ACTIVE_STAGES_PER_RUN",
     "STAGEFLOW_MAX_ACTIVE_STAGE_PROCESSES",
     "STAGEFLOW_STAGE_EXECUTION",
+    "STAGEFLOW_STAGE_CONTAINER_IMAGE",
+    "STAGEFLOW_STAGE_CONTAINER_DOCKER_BIN",
     "STAGEFLOW_STAGE_ENV_ALLOW",
     "STAGEFLOW_STAGE_ENV_PASSTHROUGH",
     "STAGEFLOW_GC_INTERVAL_MS",
@@ -69,6 +71,13 @@ export const KNOWN_STAGEFLOW_ENV_KEYS = new Set([
     "STAGEFLOW_SECRET_REGISTRY",
     "STAGEFLOW_BUILD_SHA",
     "STAGEFLOW_TRIGGER_TICK_INTERVAL_MS",
+    "STAGEFLOW_AGENT_SCHEDULE_TICK_INTERVAL_MS",
+    "STAGEFLOW_AGENT_SESSION_IDLE_MINUTES",
+    "STAGEFLOW_AGENT_STALL_SECONDS",
+    "STAGEFLOW_AGENT_CHANNEL_LISTENERS",
+    "STAGEFLOW_AGENTS_ALLOW_CURSOR_NATIVE_TOOLS",
+    "STAGEFLOW_PUBLIC_CHAT_ORIGINS",
+    "STAGEFLOW_MCP_ENV_ALLOW",
     "STAGEFLOW_GITHUB_POLL_INTERVAL_MS",
 ]);
 const KNOWN_ENV_PREFIXES = [