stageflow 0.25.0 → 0.30.0

package/dist/cli/exportAllCommand.js

@@ -0,0 +1,218 @@
+import { createWriteStream } from "node:fs";
+import path from "node:path";
+import { projectRun } from "../projection/projectRun.js";
+import { PACKAGE_VERSION } from "../package-meta.js";
+import { globalStageflowHome } from "../project/globalHome.js";
+import { createRunStoreAfterHostEnsure, } from "../runstore/createStore.js";
+import { isInsideDir } from "../runstore/workspaceLayout.js";
+import { ensureGlobalService } from "../server/ensureGlobalService.js";
+export const EXPORT_ALL_USAGE = `Usage:
+  sf export --all [--status <status>] [--since <iso>] [--pipeline <id-or-path>] [--out <file>]
+
+Streams whole-instance NDJSON (header + one projectRun line per run, including
+non-terminal). Not a backup — restore does not accept export streams.`;
+const defaultIo = {
+    log: (line) => console.log(line),
+    error: (line) => console.error(line),
+};
+export function buildExportHeader(filter, now = new Date()) {
+    return {
+        type: "stageflow_export",
+        version: 1,
+        stageflow_version: PACKAGE_VERSION,
+        created_at: now.toISOString(),
+        ...(filter !== undefined ? { filter } : {}),
+    };
+}
+export function resolveExportPipelineSource(options) {
+    if (options.pipelineSource === "inline") {
+        if (options.pipelineBody != null && options.pipelineBody !== "") {
+            try {
+                return {
+                    kind: "inline",
+                    pipeline: JSON.parse(options.pipelineBody),
+                };
+            }
+            catch {
+                return {
+                    kind: "unavailable",
+                    pipeline: null,
+                    note: "pipeline_body is not valid JSON",
+                };
+            }
+        }
+        return {
+            kind: "unavailable",
+            pipeline: null,
+            note: "inline pipeline body missing",
+        };
+    }
+    if (options.pipelineSource === "path" || options.pipelinePath) {
+        return {
+            kind: "path",
+            path: options.pipelinePath ?? "",
+            pipeline: null,
+        };
+    }
+    return {
+        kind: "unavailable",
+        pipeline: null,
+        note: "pipeline source not recorded",
+    };
+}
+export function projectRunForExport(detail, pipelineBody) {
+    return {
+        ...projectRun(detail),
+        pipeline_source: resolveExportPipelineSource({
+            pipelineSource: detail.pipeline_source,
+            pipelinePath: detail.pipeline_path,
+            pipelineBody,
+        }),
+    };
+}
+export function assertExportOutPathAllowed(outPath, homeDir = globalStageflowHome(), cwd = process.cwd()) {
+    const segments = outPath.split(/[/\\]/);
+    if (segments.some((segment) => segment === "..")) {
+        throw new Error("path must not contain .. segments");
+    }
+    const resolved = path.isAbsolute(outPath)
+        ? path.resolve(outPath)
+        : path.resolve(cwd, outPath);
+    const worktrees = path.resolve(homeDir, "worktrees");
+    const runs = path.resolve(homeDir, "runs");
+    if (isInsideDir(resolved, worktrees) || isInsideDir(resolved, runs)) {
+        throw new Error("output path must not be under worktrees/ or runs/");
+    }
+    return resolved;
+}
+function parseExportArgs(args) {
+    let help = false;
+    let all = false;
+    let status;
+    let since;
+    let pipeline;
+    let outPath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            help = true;
+        }
+        else if (arg === "--all") {
+            all = true;
+        }
+        else if (arg === "--status") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error("Missing value for --status");
+            status = value;
+        }
+        else if (arg === "--since") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error("Missing value for --since");
+            since = value;
+        }
+        else if (arg === "--pipeline") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error("Missing value for --pipeline");
+            pipeline = value;
+        }
+        else if (arg === "--out") {
+            const value = args[++i];
+            if (value === undefined)
+                throw new Error("Missing value for --out");
+            outPath = value;
+        }
+        else if (arg?.startsWith("-")) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+        else {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+    }
+    return { help, all, status, since, pipeline, outPath };
+}
+export async function* iterateExportNdjson(options) {
+    yield `${JSON.stringify(buildExportHeader(options.filter, options.now ?? new Date()))}\n`;
+    const runs = await options.store.listRuns(options.filter);
+    for (const summary of runs) {
+        const detail = await options.store.readRun(summary.run_id);
+        const pipelineBody = await options.store.readPipelineBody(summary.run_id);
+        const line = {
+            type: "projectRun",
+            run: projectRunForExport(detail, pipelineBody),
+        };
+        yield `${JSON.stringify(line)}\n`;
+    }
+}
+export async function runExportAllCommand(args, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const out = { ...defaultIo, ...options.io };
+    let parsed;
+    try {
+        parsed = parseExportArgs(args);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        out.error(message);
+        out.error(EXPORT_ALL_USAGE);
+        return 1;
+    }
+    if (parsed.help) {
+        out.error(EXPORT_ALL_USAGE);
+        return 0;
+    }
+    if (!parsed.all) {
+        out.error("sf export requires --all (whole-instance NDJSON)");
+        out.error(EXPORT_ALL_USAGE);
+        return 1;
+    }
+    const filter = {};
+    if (parsed.status !== undefined)
+        filter.status = parsed.status;
+    if (parsed.since !== undefined)
+        filter.since = parsed.since;
+    if (parsed.pipeline !== undefined)
+        filter.pipeline = parsed.pipeline;
+    const opened = await createRunStoreAfterHostEnsure({ rootDir: globalStageflowHome() }, () => ensureGlobalService());
+    if (!opened.ok) {
+        out.error(opened.message);
+        return 1;
+    }
+    const store = opened.store;
+    try {
+        let sink = (line) => out.log(line.replace(/\n$/, ""));
+        let close;
+        if (parsed.outPath !== undefined) {
+            const target = assertExportOutPathAllowed(parsed.outPath, globalStageflowHome(), cwd);
+            const stream = createWriteStream(target);
+            sink = (line) => {
+                stream.write(line);
+            };
+            close = () => new Promise((resolve, reject) => {
+                stream.end(() => resolve());
+                stream.on("error", reject);
+            });
+        }
+        for await (const line of iterateExportNdjson({
+            store,
+            filter: Object.keys(filter).length > 0 ? filter : undefined,
+        })) {
+            sink(line);
+        }
+        await close?.();
+        if (parsed.outPath !== undefined) {
+            out.error(`Wrote ${assertExportOutPathAllowed(parsed.outPath, globalStageflowHome(), cwd)}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        out.error(message);
+        return 1;
+    }
+    finally {
+        await store.close();
+    }
+}

package/dist/cli/exportRunCommand.js

@@ -1,9 +1,10 @@
 import { readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { projectRun } from "../projection/projectRun.js";
 import { globalStageflowHome } from "../project/globalHome.js";
-import { createRunStore } from "../runstore/createStore.js";
-import { isInsideDir } from "../runstore/workspaceLayout.js";
+import { createRunStoreAfterHostEnsure, } from "../runstore/createStore.js";
+import { ensureGlobalService, } from "../server/ensureGlobalService.js";
+import { buildRunExportPayload } from "../runstore/exportRunPayload.js";
+import { resolveSafeOutPath } from "./resolveSafeOutPath.js";
 export const EXPORT_RUN_USAGE = `Usage:
   sf export-run --run <runId> [--from <sf-run.json>] [--out <file>]`;
 const defaultIo = {
@@ -75,23 +76,19 @@ function resolveRunIdFromFile(fromPath, cwd) {
     }
     return runId;
 }
-function resolveSafeOutPath(outPath, cwd) {
-    const segments = outPath.split(/[/\\]/);
-    if (segments.some((segment) => segment === "..")) {
-        throw new Error("path must not contain .. segments");
-    }
-    const resolved = path.resolve(cwd, outPath);
-    const cwdResolved = path.resolve(cwd);
-    if (!isInsideDir(resolved, cwdResolved)) {
-        throw new Error("output path must resolve under the current working directory");
-    }
-    return resolved;
-}
-function assertRunComplete(status, runId) {
-    if (status === "succeeded" || status === "failed") {
+const EXPORTABLE_STATUSES = new Set([
+    "running",
+    "succeeded",
+    "failed",
+    "cancelled",
+    "queued",
+    "created",
+]);
+function assertRunExportable(status, runId) {
+    if (EXPORTABLE_STATUSES.has(status)) {
         return;
     }
-    throw new Error(`run is not complete: ${runId} (status: ${status})`);
+    throw new Error(`run cannot be exported: ${runId} (status: ${status})`);
 }
 export async function runExportRunCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
@@ -126,11 +123,16 @@ export async function runExportRunCommand(args, options = {}) {
         out.error(EXPORT_RUN_USAGE);
         return 1;
     }
-    const store = createRunStore({ rootDir: globalStageflowHome() });
+    const opened = await createRunStoreAfterHostEnsure({ rootDir: globalStageflowHome() }, () => ensureGlobalService());
+    if (!opened.ok) {
+        out.error(opened.message);
+        return 1;
+    }
+    const store = opened.store;
     try {
         const detail = await store.readRun(runId);
-        assertRunComplete(detail.status, runId);
-        const projection = projectRun(detail);
+        assertRunExportable(detail.status, runId);
+        const projection = buildRunExportPayload(detail);
         const json = JSON.stringify(projection, null, 2);
         if (parsed.outPath !== undefined) {
             const target = resolveSafeOutPath(parsed.outPath, cwd);

package/dist/cli/hostClient.d.ts

@@ -1,8 +1,10 @@
 import type { PipelineRunResult } from "../runtime/pipelineRunner.js";
-import type { AbandonStageResult, DecideFeedbackLoopResult, StartRunResult, StopManualRecoveryResult } from "../runtime/runManager.js";
+import type { AbandonStageResult, CancelRunResult, DecideFeedbackLoopResult, DeleteRunResult, GcRunsResult, StartRunResult, StopManualRecoveryResult } from "../runtime/runManager.js";
 import type { DeliverAnswerResult } from "../runtime/stageHitl.js";
 import type { RetryStageResult } from "../runtime/runRetryCoordinator.js";
 import type { RunDetail, RunStore } from "../runstore/port.js";
+import type { TriggerListItem } from "../server/triggerRoutes.js";
+import type { TaskFile } from "../types/task.js";
 export declare function computeRunDir(runId: string): string;
 export declare function httpReadRun(base: string, runId: string): Promise<RunDetail>;
 /** Thin RunStore-shaped reader backed by the global service, for the CLI output helpers that only need `readRun`. */
@@ -13,7 +15,8 @@ export declare function pollRunUntilTerminal(base: string, runId: string, option
 export declare function runDetailToPipelineRunResult(detail: RunDetail): PipelineRunResult;
 export type HttpStartRunInput = {
     pipeline: string;
-    task: string;
+    task: string | TaskFile;
+    project_root?: string;
     checkoutOverride?: string;
     skipGates?: boolean;
     gitSha?: string;
@@ -21,7 +24,16 @@ export type HttpStartRunInput = {
     ciJobUrl?: string;
 };
 export declare function httpStartRun(base: string, input: HttpStartRunInput): Promise<StartRunResult>;
-export declare function httpRerun(base: string, runId: string): Promise<StartRunResult>;
+export type HttpEnsureProjectResult = {
+    ok: true;
+    project_root: string;
+} | Extract<StartRunResult, {
+    ok: false;
+}>;
+export declare function httpEnsureProject(base: string, projectRoot: string): Promise<HttpEnsureProjectResult>;
+export declare function httpRerun(base: string, runId: string, options?: {
+    pinned?: boolean;
+}): Promise<StartRunResult>;
 export declare function httpDeliverAnswer(base: string, runId: string, stageId: string, answer: unknown): Promise<DeliverAnswerResult>;
 export declare function httpDecideFeedbackLoop(base: string, runId: string, stageId: string, input: {
     decision: "extend" | "continue" | "abandon";
@@ -39,5 +51,31 @@ export declare function httpResumeTimedOutStage(base: string, runId: string, sta
 export declare function httpRecoverManualStageUntilStop(base: string, runId: string, stageId: string, guidance?: string): Promise<RetryOrchestrationResult>;
 export declare function httpStopManualRecovery(base: string, runId: string, stageId: string): Promise<StopManualRecoveryResult>;
 export declare function httpAbandonStage(base: string, runId: string, stageId: string): Promise<AbandonStageResult>;
+export declare function httpCancelRun(base: string, runId: string, reason: string): Promise<CancelRunResult>;
+export declare function httpDeleteRun(base: string, runId: string, options?: {
+    force?: boolean;
+}): Promise<DeleteRunResult>;
+export declare function httpGcRuns(base: string, options?: {
+    execute?: boolean;
+}): Promise<GcRunsResult>;
+export type HttpTriggerLookupResult = {
+    ok: true;
+    trigger: TriggerListItem;
+} | {
+    ok: false;
+    reason: string;
+    status?: number;
+};
+export type HttpListTriggersResult = {
+    ok: true;
+    triggers: TriggerListItem[];
+} | {
+    ok: false;
+    reason: string;
+    status?: number;
+};
+export declare function httpFireTrigger(base: string, triggerId: string, task?: Record<string, unknown>): Promise<StartRunResult>;
+export declare function httpListTriggers(base: string): Promise<HttpListTriggersResult>;
+export declare function httpGetTrigger(base: string, triggerId: string): Promise<HttpTriggerLookupResult>;
 export declare function resolveAbsolute(cwd: string, maybeRelative: string): string;
 export {};

package/dist/cli/hostClient.js

@@ -1,17 +1,23 @@
 import path from "node:path";
 import { globalStageflowHome } from "../project/globalHome.js";
 import { PipelineValidationError } from "../runtime/pipelineValidationError.js";
-import { runWorkspaceDir, storeRootFor } from "../runstore/paths.js";
+import { resolveStoreRoot, runWorkspaceDir } from "../runstore/paths.js";
+import { clientAuthorizationHeaders } from "../server/controlToken.js";
 async function postJson(base, urlPath, body) {
     const res = await fetch(`${base}${urlPath}`, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+            "Content-Type": "application/json",
+            ...clientAuthorizationHeaders("POST"),
+        },
         body: JSON.stringify(body ?? {}),
     });
     return { status: res.status, body: await parseJsonBody(res) };
 }
 async function getJson(base, urlPath) {
-    const res = await fetch(`${base}${urlPath}`);
+    const res = await fetch(`${base}${urlPath}`, {
+        headers: { ...clientAuthorizationHeaders("GET") },
+    });
     return { status: res.status, body: await parseJsonBody(res) };
 }
 async function parseJsonBody(res) {
@@ -35,7 +41,7 @@ function enc(value) {
     return encodeURIComponent(value);
 }
 export function computeRunDir(runId) {
-    return runWorkspaceDir(storeRootFor(globalStageflowHome()), runId);
+    return runWorkspaceDir(resolveStoreRoot(globalStageflowHome()), runId);
 }
 export async function httpReadRun(base, runId) {
     const { status, body } = await getJson(base, `/api/runs/${enc(runId)}`);
@@ -51,6 +57,7 @@ export function httpStoreReader(base) {
 function isRunTerminal(detail) {
     return (detail.status === "succeeded" ||
         detail.status === "failed" ||
+        detail.status === "cancelled" ||
         (detail.status === "running" && detail.waiting_stage_id !== undefined));
 }
 function sleep(ms) {
@@ -70,15 +77,20 @@ export function runDetailToPipelineRunResult(detail) {
         ? "succeeded"
         : detail.status === "failed"
             ? "failed"
-            : "waiting";
+            : detail.status === "cancelled"
+                ? "cancelled"
+                : "waiting";
+    const reason = outcome === "cancelled"
+        ? (detail.cancel_reason ?? detail.failed_reason)
+        : outcome === "failed"
+            ? detail.failed_reason
+            : undefined;
     return {
         ok: outcome === "succeeded",
         outcome,
         runId: detail.run_id,
         runDir: computeRunDir(detail.run_id),
-        ...(outcome === "failed" && detail.failed_reason !== undefined
-            ? { reason: detail.failed_reason }
-            : {}),
+        ...(reason !== undefined ? { reason } : {}),
     };
 }
 function toStartFailure(status, body) {
@@ -107,15 +119,36 @@ export async function httpStartRun(base, input) {
     }
     if (status !== 202)
         return toStartFailure(status, body);
-    const runId = body.runId;
+    const parsed = body;
+    const runId = parsed.runId;
     return {
         ok: true,
         runId,
+        ...(parsed.queued === true
+            ? { queued: true, queuePosition: parsed.queuePosition }
+            : {}),
         done: pollRunUntilTerminal(base, runId).then(runDetailToPipelineRunResult),
     };
 }
-export async function httpRerun(base, runId) {
-    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/rerun`, {});
+export async function httpEnsureProject(base, projectRoot) {
+    const { status, body } = await postJson(base, "/api/projects", {
+        project_root: projectRoot,
+    });
+    if (status === 200) {
+        const parsed = body;
+        if (typeof parsed.project_root === "string" && parsed.project_root.length > 0) {
+            return { ok: true, project_root: parsed.project_root };
+        }
+        return {
+            ok: false,
+            reason: "ensure_project response missing project_root",
+            status,
+        };
+    }
+    return toStartFailure(status, body);
+}
+export async function httpRerun(base, runId, options) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/rerun`, options?.pinned !== undefined ? { pinned: options.pinned } : {});
     if (status !== 202)
         return toStartFailure(status, body);
     const newRunId = body.runId;
@@ -127,8 +160,12 @@ export async function httpRerun(base, runId) {
 }
 export async function httpDeliverAnswer(base, runId, stageId, answer) {
     const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/answer`, answer);
-    if (status === 202)
-        return { ok: true };
+    if (status === 202) {
+        const verification = body?.verification;
+        return verification === "failed_retrying"
+            ? { ok: true, verification }
+            : { ok: true };
+    }
     return { ok: false, reason: extractError(body, status), status: status };
 }
 export async function httpDecideFeedbackLoop(base, runId, stageId, input) {
@@ -142,7 +179,15 @@ export async function httpDecideFeedbackLoop(base, runId, stageId, input) {
 export async function httpRetryStageUntilStop(base, runId, stageId) {
     const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/stages/${enc(stageId)}/retry`, {});
     if (status !== 202) {
-        return { ok: false, reason: extractError(body, status), status };
+        const code = body && typeof body === "object" && typeof body.code === "string"
+            ? body.code
+            : undefined;
+        return {
+            ok: false,
+            reason: extractError(body, status),
+            status,
+            ...(code !== undefined ? { code } : {}),
+        };
     }
     const detail = await pollRunUntilTerminal(base, runId);
     return { ok: true, pipeline: runDetailToPipelineRunResult(detail) };
@@ -177,6 +222,76 @@ export async function httpAbandonStage(base, runId, stageId) {
     }
     return { ok: false, reason: extractError(body, status), status };
 }
+export async function httpCancelRun(base, runId, reason) {
+    const { status, body } = await postJson(base, `/api/runs/${enc(runId)}/cancel`, { reason });
+    if (status === 202) {
+        const parsed = body;
+        return { ok: true, runId: parsed.runId };
+    }
+    return { ok: false, reason: extractError(body, status), status };
+}
+export async function httpDeleteRun(base, runId, options) {
+    const forceQs = options?.force ? "?force=true" : "";
+    const res = await fetch(`${base}/api/runs/${enc(runId)}${forceQs}`, {
+        method: "DELETE",
+        headers: { ...clientAuthorizationHeaders("DELETE") },
+    });
+    const body = await parseJsonBody(res);
+    if (res.status === 200) {
+        const parsed = body;
+        return { ok: true, runId: parsed.runId };
+    }
+    return {
+        ok: false,
+        reason: extractError(body, res.status),
+        status: res.status,
+    };
+}
+export async function httpGcRuns(base, options) {
+    const { status, body } = await postJson(base, "/api/runs/gc", {
+        execute: options?.execute === true,
+    });
+    if (status === 200) {
+        const parsed = body;
+        return {
+            ok: true,
+            slimmed: parsed.slimmed ?? [],
+            purged: parsed.purged ?? [],
+            bareCachesEvicted: parsed.bareCachesEvicted ?? [],
+        };
+    }
+    return { ok: false, reason: extractError(body, status), status };
+}
+export async function httpFireTrigger(base, triggerId, task) {
+    const { status, body } = await postJson(base, `/api/triggers/${enc(triggerId)}/fire`, task !== undefined ? { task } : {});
+    if (status !== 202)
+        return toStartFailure(status, body);
+    const parsed = body;
+    const runId = parsed.runId;
+    return {
+        ok: true,
+        runId,
+        ...(parsed.queued === true
+            ? { queued: true, queuePosition: parsed.queuePosition }
+            : {}),
+        done: pollRunUntilTerminal(base, runId).then(runDetailToPipelineRunResult),
+    };
+}
+export async function httpListTriggers(base) {
+    const { status, body } = await getJson(base, "/api/triggers");
+    if (status !== 200) {
+        return { ok: false, reason: extractError(body, status), status };
+    }
+    const parsed = body;
+    return { ok: true, triggers: parsed.triggers };
+}
+export async function httpGetTrigger(base, triggerId) {
+    const { status, body } = await getJson(base, `/api/triggers/${enc(triggerId)}`);
+    if (status !== 200) {
+        return { ok: false, reason: extractError(body, status), status };
+    }
+    return { ok: true, trigger: body };
+}
 export function resolveAbsolute(cwd, maybeRelative) {
     return path.resolve(cwd, maybeRelative);
 }

package/dist/cli/initCommand.d.ts

@@ -6,4 +6,5 @@ export type InitCommandIo = {
 export declare function runInitCommand(args: string[], options?: {
     cwd?: string;
     io?: Partial<InitCommandIo>;
+    resolveConfiguredProviderIds?: (cwd: string) => Promise<string[]>;
 }): Promise<number>;

package/dist/cli/initCommand.js

@@ -1,19 +1,15 @@
 import { access, mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { getAuthStatus } from "../agent/providerAuth.js";
 import { findProjectRoot } from "../project/findProjectRoot.js";
 import { ensureGlobalHome } from "../project/globalHome.js";
-import { HELLO_PIPELINE_YAML, HELLO_TASK_YAML, STAGEFLOW_YAML, } from "./initTemplates.js";
+import { HELLO_TASK_YAML, STAGEFLOW_YAML, helloPipelineYaml, resolveInitDefaultModel, } from "./initTemplates.js";
 export const INIT_USAGE = `Usage:
   sf init`;
 const defaultIo = {
     log: (line) => console.log(line),
     error: (line) => console.error(line),
 };
-const INIT_TARGETS = [
-    { relPath: "stageflow.yaml", content: STAGEFLOW_YAML },
-    { relPath: "pipelines/hello.pipeline.yaml", content: HELLO_PIPELINE_YAML },
-    { relPath: "tasks/hello.task.yaml", content: HELLO_TASK_YAML },
-];
 async function fileExists(absPath) {
     try {
         await access(absPath);
@@ -35,6 +31,16 @@ function parseInitArgs(args) {
     }
     throw new Error(`Unexpected argument: ${args[0]}`);
 }
+async function defaultConfiguredProviderIds(cwd) {
+    try {
+        const status = await getAuthStatus(cwd);
+        const rows = Array.isArray(status) ? status : [status];
+        return rows.filter((r) => r.configured).map((r) => r.providerId);
+    }
+    catch {
+        return [];
+    }
+}
 export async function runInitCommand(args, options = {}) {
     const cwd = options.cwd ?? process.cwd();
     const out = { ...defaultIo, ...options.io };
@@ -46,7 +52,17 @@ export async function runInitCommand(args, options = {}) {
         }
         const initRoot = findProjectRoot(cwd) ?? path.resolve(cwd);
         ensureGlobalHome();
-        for (const target of INIT_TARGETS) {
+        const configuredIds = await (options.resolveConfiguredProviderIds ?? defaultConfiguredProviderIds)(cwd);
+        const model = resolveInitDefaultModel(configuredIds);
+        const targets = [
+            { relPath: "stageflow.yaml", content: STAGEFLOW_YAML },
+            {
+                relPath: "pipelines/hello.pipeline.yaml",
+                content: helloPipelineYaml(model),
+            },
+            { relPath: "tasks/hello.task.yaml", content: HELLO_TASK_YAML },
+        ];
+        for (const target of targets) {
             const absPath = path.join(initRoot, target.relPath);
             if (await fileExists(absPath)) {
                 out.log(`Skipped ${target.relPath} (exists)`);

package/dist/cli/initTemplates.d.ts

@@ -1,3 +1,6 @@
-export declare const STAGEFLOW_YAML = "version: 1\ncatalog:\n  pipelines:\n    - pipelines\n  tasks:\n    - tasks\n  patterns:\n    pipeline: \"*.pipeline.yaml\"\n    task: \"*.task.yaml\"\n";
-export declare const HELLO_PIPELINE_YAML = "id: hello\nmodel: anthropic/claude-sonnet-4-5\nstages:\n  - id: hello\n    system_prompt: Say hello and emit a success envelope.\n";
+export declare const STAGEFLOW_YAML = "version: 1\ncatalog:\n  pipelines:\n    - pipelines\n    - workshop\n  tasks:\n    - tasks\n    - workshop\n  patterns:\n    pipeline: \"*.pipeline.yaml\"\n    task: \"*.task.yaml\"\n";
+export declare const LOUD_MODEL_PLACEHOLDER = "CHANGE_ME/<provider-model>";
+export declare function resolveInitDefaultModel(configuredProviderIds: readonly string[]): string;
+export declare function helloPipelineYaml(model: string): string;
+export declare const HELLO_PIPELINE_YAML: string;
 export declare const HELLO_TASK_YAML = "id: hello\ngoal: Run the hello pipeline scaffold.\n";