stageflow 0.2.0 → 0.3.0

package/dist/runtime/reloadRunCatalog.js

@@ -0,0 +1,44 @@
+import { access } from "node:fs/promises";
+import { loadPipeline } from "../config/loadPipeline.js";
+import { loadTask } from "../config/loadTask.js";
+import { normalizeCatalogPath } from "../runstore/normalizeCatalogPath.js";
+function missingLocator(field, runId) {
+    throw new Error(`Run ${runId} is missing ${field}; reload requires stored catalog locators.`);
+}
+function requireProjectRoot(meta) {
+    if (!meta.project_root) {
+        missingLocator("project_root", meta.run_id);
+    }
+    return normalizeCatalogPath(meta.project_root);
+}
+function requirePipelinePath(meta) {
+    if (!meta.pipeline_path) {
+        missingLocator("pipeline_path", meta.run_id);
+    }
+    return normalizeCatalogPath(meta.pipeline_path);
+}
+function requireTaskPath(meta) {
+    if (!meta.task_path) {
+        missingLocator("task_path", meta.run_id);
+    }
+    return normalizeCatalogPath(meta.task_path);
+}
+async function assertCatalogFileExists(filePath, label) {
+    try {
+        await access(filePath);
+    }
+    catch {
+        throw new Error(`${label} not found at stored path: ${filePath}`);
+    }
+}
+export async function reloadPipelineForRun(meta) {
+    const projectRoot = requireProjectRoot(meta);
+    const pipelinePath = requirePipelinePath(meta);
+    await assertCatalogFileExists(pipelinePath, "Pipeline");
+    return loadPipeline(pipelinePath, { cwd: projectRoot });
+}
+export async function reloadTaskForRun(meta) {
+    const taskPath = requireTaskPath(meta);
+    await assertCatalogFileExists(taskPath, "Task");
+    return loadTask(taskPath);
+}

package/dist/runtime/resumeReconstruct.d.ts

@@ -16,6 +16,7 @@ export type PreparedResumeContext = {
     executionMode: StageExecutionMode;
     stageProcessLauncher?: StageProcessLauncher;
     cwd: string;
+    factoryCwd?: string;
     maxActiveStagesPerRun: number;
     operatorCatalog?: OperatorCatalog;
 };

package/dist/runtime/resumeReconstruct.js

@@ -1,7 +1,9 @@
 import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { fakeHitlResumePath } from "../agent/fakeAgent.js";
-import { loadPipeline } from "../config/loadPipeline.js";
 import { loadTaskFromYaml } from "../config/loadTask.js";
+import { normalizeCatalogPath } from "../runstore/normalizeCatalogPath.js";
+import { reloadPipelineForRun, reloadTaskForRun, } from "./reloadRunCatalog.js";
 import { WAIT_WITHOUT_WORKER_DISPATCH } from "./answerResume.js";
 import { resumeRun } from "./pipelineScheduler.js";
 import { buildStageRoots, withResolvedAuthPath } from "./stageRoots.js";
@@ -10,14 +12,27 @@ import { attemptContext } from "./stageAttemptContext.js";
 import { openStageAttempt, } from "./stageAttemptBootstrap.js";
 export async function loadRunContext(store, runId, cwd) {
     const meta = await store.readRunMeta(runId);
-    const taskYaml = await store.readTaskYaml(runId);
-    const task = loadTaskFromYaml(taskYaml, `run ${runId} task`);
-    const loaded = await loadPipeline(meta.pipeline_id, { cwd });
+    const reloadMeta = {
+        ...meta,
+        project_root: meta.project_root ?? normalizeCatalogPath(cwd),
+    };
+    const loaded = await reloadPipelineForRun(reloadMeta);
+    let taskYaml;
+    let task;
+    if (meta.task_path) {
+        task = await reloadTaskForRun(meta);
+        taskYaml = await readFile(normalizeCatalogPath(meta.task_path), "utf8");
+    }
+    else {
+        taskYaml = await store.readTaskYaml(runId);
+        task = loadTaskFromYaml(taskYaml, `run ${runId} task`);
+    }
     const workspaceDir = store.getWorkspaceDir(runId);
     return { meta, taskYaml, task, loaded, workspaceDir };
 }
 export async function reconstructAndContinue(ctx) {
     const { runId, stageId, opaqueAnswer, agent, store, cwd } = ctx;
+    const factoryCwd = ctx.factoryCwd ?? cwd;
     try {
         const latestExecution = await store.getLatestStageExecution(runId, stageId);
         const attemptCtx = attemptContext(latestExecution?.attempt ?? 1);
@@ -36,7 +51,7 @@ export async function reconstructAndContinue(ctx) {
         const stage = loaded.stages[stageIndex];
         const workspaceDir = store.getWorkspaceDir(runId);
         const checkoutRoot = meta.checkout_root;
-        const roots = withResolvedAuthPath(buildStageRoots(workspaceDir, stageId, checkoutRoot, attemptCtx), cwd);
+        const roots = withResolvedAuthPath(buildStageRoots(workspaceDir, stageId, checkoutRoot, attemptCtx), factoryCwd);
         const fakeResume = fakeHitlResumePath(roots, stageId);
         const piSession = attemptCtx.sessionPath(workspaceDir, stageId);
         if (!existsSync(fakeResume) && !existsSync(piSession)) {
@@ -57,7 +72,7 @@ export async function reconstructAndContinue(ctx) {
             dag: loaded.dag,
             checkoutRoot,
             workspaceDir,
-            factoryCwd: cwd,
+            factoryCwd,
             attemptCtx,
             operatorCatalog: ctx.operatorCatalog,
             onActivity: (event) => {
@@ -86,7 +101,7 @@ export async function reconstructAndContinue(ctx) {
             skipStarted: true,
             existingHandle: opened.handle,
             attemptCtx,
-            factoryCwd: cwd,
+            factoryCwd,
             operatorCatalog: ctx.operatorCatalog,
         });
         if (isRunStageWaiting(result)) {
@@ -108,6 +123,7 @@ export async function reconstructAndContinue(ctx) {
                 agent,
                 store,
                 cwd,
+                projectRoot: factoryCwd,
                 checkoutRoot,
                 hitl: ctx.hitl,
                 operatorCatalog: ctx.operatorCatalog,

package/dist/runtime/runManager.d.ts

@@ -61,10 +61,14 @@ export declare class RunManager {
     private readonly retryCoordinator;
     private readonly retryTracking;
     private readonly cwd;
+    private readonly projectRoot;
+    private readonly isGitProject;
     constructor(options: {
         agent: AgentPort;
         store: RunStore;
         cwd?: string;
+        projectRoot?: string;
+        isGitProject?: boolean;
         operatorCatalog?: OperatorCatalog;
         seams?: HitlSeams;
         maxConcurrent?: number;

package/dist/runtime/runManager.js

@@ -1,14 +1,15 @@
 import { randomUUID } from "node:crypto";
 import { readFile, realpath } from "node:fs/promises";
 import path from "node:path";
-import { loadPipeline } from "../config/loadPipeline.js";
+import { normalizeCatalogPath } from "../runstore/normalizeCatalogPath.js";
+import { loadRunContext } from "./resumeReconstruct.js";
 import { loadTaskFromYaml } from "../config/loadTask.js";
 import { PipelineValidationError, startPipeline, } from "./pipelineRunner.js";
 import { resumeRun } from "./pipelineScheduler.js";
 import { RunRetryCoordinator, } from "./runRetryCoordinator.js";
 import { readMaxActiveStageProcesses, readMaxActiveStagesPerRun, readStageExecutionMode, } from "./stageConcurrency.js";
 import { StageProcessLauncher } from "./stageProcessLauncher.js";
-import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, readMaxConcurrentFromFile, writeMaxConcurrentToFile, } from "./settingsFile.js";
+import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, projectSettingsContext, readMaxConcurrentFromContext, writeMaxConcurrentToContext, } from "./settingsFile.js";
 import { StageHitlController, waitKey, } from "./stageHitl.js";
 import { resolveAndValidateCheckout, } from "./stageRoots.js";
 import { orchestrateAnswerResume } from "./answerResume.js";
@@ -79,12 +80,17 @@ export class RunManager {
         },
     };
     cwd;
+    projectRoot;
+    isGitProject;
     constructor(options) {
         this.options = options;
         this.cwd = options.cwd ?? process.cwd();
+        this.projectRoot = options.projectRoot ?? this.cwd;
+        this.isGitProject = options.isGitProject ?? false;
+        const settingsCtx = projectSettingsContext(this.cwd, this.projectRoot, this.isGitProject);
         this.maxConcurrent =
             options.maxConcurrent ??
-                readMaxConcurrentFromFile(this.cwd) ??
+                readMaxConcurrentFromContext(settingsCtx) ??
                 parseMaxConcurrent(process.env.STAGEFLOW_MAX_CONCURRENT_RUNS);
         this.maxActiveStagesPerRun = readMaxActiveStagesPerRun(process.env, options.maxActiveStagesPerRun);
         this.executionMode = readStageExecutionMode(process.env, options.executionMode);
@@ -106,7 +112,7 @@ export class RunManager {
             throw new Error(INVALID_SLOT_COUNT_MESSAGE);
         }
         this.maxConcurrent = parsed;
-        writeMaxConcurrentToFile(this.cwd, parsed);
+        writeMaxConcurrentToContext(projectSettingsContext(this.cwd, this.projectRoot, this.isGitProject), parsed);
         return this.getHealth();
     }
     getActiveCount() {
@@ -355,17 +361,32 @@ export class RunManager {
     }
     async rerun(runId) {
         const cwd = this.options.cwd ?? process.cwd();
-        let pipelineId;
+        let pipeline;
         let taskYaml;
+        let rerunCwd = cwd;
+        let rerunProjectRoot;
         try {
             const meta = await this.options.store.readRunMeta(runId);
-            pipelineId = meta.pipeline_id;
+            if (!meta.pipeline_path) {
+                return {
+                    ok: false,
+                    reason: `Run ${runId} is missing pipeline_path; re-run requires stored catalog locators.`,
+                    status: 400,
+                };
+            }
+            pipeline = normalizeCatalogPath(meta.pipeline_path);
+            rerunCwd = meta.project_root
+                ? normalizeCatalogPath(meta.project_root)
+                : cwd;
+            rerunProjectRoot = meta.project_root
+                ? normalizeCatalogPath(meta.project_root)
+                : undefined;
             taskYaml = await this.options.store.readTaskYaml(runId);
         }
         catch {
             return { ok: false, reason: `Run not found: ${runId}`, status: 404 };
         }
-        return this.reserveAndStartPipeline(taskYaml, pipelineId, `run ${runId} task`, cwd);
+        return this.reserveAndStartPipeline(taskYaml, pipeline, `run ${runId} task`, rerunCwd, undefined, undefined, undefined, rerunProjectRoot);
     }
     async retryStage(runId, stageId) {
         const retryKey = waitKey(runId, stageId);
@@ -489,7 +510,6 @@ export class RunManager {
         }
     }
     async resumeViaSubprocess(runId, stageId, opaqueAnswer) {
-        const cwd = this.options.cwd ?? process.cwd();
         const store = this.options.store;
         const launcher = this.stageProcessLauncher;
         if (!launcher) {
@@ -504,7 +524,7 @@ export class RunManager {
             const launchResult = await launcher.launch({
                 runId,
                 stageId,
-                rootDir: cwd,
+                rootDir: this.projectRoot,
                 mode: "resume",
                 resumeAnswer: opaqueAnswer,
                 attempt,
@@ -531,10 +551,7 @@ export class RunManager {
             catch {
                 // downstream resume may read envelope from store
             }
-            const meta = await store.readRunMeta(runId);
-            const taskYaml = await store.readTaskYaml(runId);
-            const task = loadTaskFromYaml(taskYaml, `run ${runId} task`);
-            const loaded = await loadPipeline(meta.pipeline_id, { cwd });
+            const { meta, task, loaded } = await loadRunContext(store, runId, this.cwd);
             const rest = await resumeRun({
                 prepared: {
                     task,
@@ -542,7 +559,8 @@ export class RunManager {
                     run: { runId, workspaceDir: store.getWorkspaceDir(runId) },
                     agent: this.options.agent,
                     store,
-                    cwd,
+                    cwd: this.cwd,
+                    projectRoot: this.projectRoot,
                     checkoutRoot: meta.checkout_root,
                     hitl: this.hitl,
                     operatorCatalog: this.options.operatorCatalog,
@@ -590,6 +608,7 @@ export class RunManager {
                 executionMode: this.executionMode,
                 stageProcessLauncher: this.stageProcessLauncher,
                 cwd: this.cwd,
+                factoryCwd: this.projectRoot,
                 maxActiveStagesPerRun: this.maxActiveStagesPerRun,
                 operatorCatalog: this.options.operatorCatalog,
             });
@@ -598,7 +617,7 @@ export class RunManager {
             this.attachedWaiting.delete(`${runId}\0${stageId}`);
         }
     }
-    async reserveAndStartPipeline(taskYaml, pipelineId, taskLabel, cwd, checkoutOverride, skipGates, ciIdentity) {
+    async reserveAndStartPipeline(taskYaml, pipeline, taskLabel, cwd, checkoutOverride, skipGates, ciIdentity, projectRoot) {
         let checkoutKey;
         try {
             const task = loadTaskFromYaml(taskYaml, taskLabel);
@@ -623,8 +642,9 @@ export class RunManager {
                 agent: this.options.agent,
                 store: this.options.store,
                 taskYaml,
-                pipeline: pipelineId,
+                pipeline,
                 cwd,
+                projectRoot: projectRoot ?? this.projectRoot,
                 checkoutOverride,
                 gitSha: ciIdentity?.gitSha,
                 ciPrUrl: ciIdentity?.ciPrUrl,

package/dist/runtime/settingsFile.d.ts

@@ -1,3 +1,5 @@
+import type { ProjectContext } from "../project/resolveProjectContext.js";
+import type { StageflowContext } from "../project/resolveStageflowContext.js";
 export declare const SETTINGS_FILE_NAME = "settings.json";
 export declare const INVALID_SLOT_COUNT_MESSAGE = "maxConcurrent must be an integer >= 1";
 export declare const INVALID_CREDENTIAL_SOURCE_MESSAGE = "credentialSource must be \"pi_home\" or \"sf_owned\"";
@@ -6,12 +8,22 @@ export type FactorySettings = {
     maxConcurrent?: number;
     credentialSource?: CredentialSource;
 };
+export declare function globalSettingsFilePath(): string;
+export declare function settingsFilePathForContext(ctx: ProjectContext | StageflowContext): string;
 export declare function settingsFilePath(cwd: string): string;
 export declare function parseSlotCount(value: unknown): number | undefined;
 export declare function parseCredentialSource(value: unknown): CredentialSource | undefined;
+export declare function readCredentialSourceFromContext(ctx: ProjectContext): CredentialSource | undefined;
+export declare function readPersistedCredentialSourceFromContext(ctx: ProjectContext): CredentialSource | undefined;
+export declare function readFactorySettingsForContext(ctx: ProjectContext): FactorySettings;
 export declare function readFactorySettings(cwd: string): FactorySettings;
+export declare function writeFactorySettingsForContext(ctx: ProjectContext, patch: FactorySettings): void;
 export declare function writeFactorySettings(cwd: string, patch: FactorySettings): void;
+export declare function readMaxConcurrentFromContext(ctx: ProjectContext): number | undefined;
 export declare function readMaxConcurrentFromFile(cwd: string): number | undefined;
+export declare function writeMaxConcurrentToContext(ctx: ProjectContext, maxConcurrent: number): void;
 export declare function writeMaxConcurrentToFile(cwd: string, maxConcurrent: number): void;
 export declare function readCredentialSourceFromFile(cwd: string): CredentialSource | undefined;
+export declare function writeCredentialSourceToContext(ctx: ProjectContext, credentialSource: CredentialSource): void;
 export declare function writeCredentialSourceToFile(cwd: string, credentialSource: CredentialSource): void;
+export declare function projectSettingsContext(cwd: string, projectRoot: string, isGitProject: boolean): ProjectContext;

package/dist/runtime/settingsFile.js

@@ -1,11 +1,25 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
 import path from "node:path";
+import { globalStageflowHome } from "../project/globalHome.js";
 import { storeRootFor } from "../runstore/paths.js";
 export const SETTINGS_FILE_NAME = "settings.json";
 export const INVALID_SLOT_COUNT_MESSAGE = "maxConcurrent must be an integer >= 1";
 export const INVALID_CREDENTIAL_SOURCE_MESSAGE = 'credentialSource must be "pi_home" or "sf_owned"';
+export function globalSettingsFilePath() {
+    return path.join(globalStageflowHome(), SETTINGS_FILE_NAME);
+}
+export function settingsFilePathForContext(ctx) {
+    if (ctx.isGitProject) {
+        return path.join(storeRootFor(ctx.projectRoot), SETTINGS_FILE_NAME);
+    }
+    if (path.resolve(ctx.projectRoot) === path.resolve(os.homedir())) {
+        return path.join(ctx.globalHome, SETTINGS_FILE_NAME);
+    }
+    return path.join(storeRootFor(ctx.projectRoot), SETTINGS_FILE_NAME);
+}
 export function settingsFilePath(cwd) {
-    return path.join(storeRootFor(cwd), SETTINGS_FILE_NAME);
+    return path.join(storeRootFor(path.resolve(cwd)), SETTINGS_FILE_NAME);
 }
 export function parseSlotCount(value) {
     if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
@@ -19,8 +33,7 @@ export function parseCredentialSource(value) {
     }
     return undefined;
 }
-function readRawSettings(cwd) {
-    const filePath = settingsFilePath(cwd);
+function readRawSettingsFromFile(filePath) {
     if (!existsSync(filePath))
         return {};
     try {
@@ -34,8 +47,10 @@ function readRawSettings(cwd) {
         return {};
     }
 }
-export function readFactorySettings(cwd) {
-    const raw = readRawSettings(cwd);
+function readRawSettings(ctx) {
+    return readRawSettingsFromFile(settingsFilePathForContext(ctx));
+}
+function parseFactorySettingsFromRaw(raw) {
     const settings = {};
     const maxConcurrent = parseSlotCount(raw.maxConcurrent);
     if (maxConcurrent !== undefined) {
@@ -47,6 +62,54 @@ export function readFactorySettings(cwd) {
     }
     return settings;
 }
+export function readCredentialSourceFromContext(ctx) {
+    if (ctx.isGitProject) {
+        const fromProject = parseCredentialSource(readRawSettingsFromFile(settingsFilePathForContext(ctx)).credentialSource);
+        if (fromProject !== undefined) {
+            return fromProject;
+        }
+    }
+    return parseCredentialSource(readRawSettingsFromFile(globalSettingsFilePath()).credentialSource);
+}
+export function readPersistedCredentialSourceFromContext(ctx) {
+    return parseCredentialSource(readRawSettingsFromFile(settingsFilePathForContext(ctx)).credentialSource);
+}
+export function readFactorySettingsForContext(ctx) {
+    return parseFactorySettingsFromRaw(readRawSettings(ctx));
+}
+export function readFactorySettings(cwd) {
+    return parseFactorySettingsFromRaw(readRawSettingsFromFile(settingsFilePath(cwd)));
+}
+function ensureSettingsDirForContext(ctx) {
+    mkdirSync(path.dirname(settingsFilePathForContext(ctx)), { recursive: true });
+}
+export function writeFactorySettingsForContext(ctx, patch) {
+    if (patch.credentialSource !== undefined &&
+        parseCredentialSource(patch.credentialSource) === undefined) {
+        throw new Error(INVALID_CREDENTIAL_SOURCE_MESSAGE);
+    }
+    if (patch.maxConcurrent !== undefined &&
+        parseSlotCount(patch.maxConcurrent) === undefined) {
+        throw new Error(INVALID_SLOT_COUNT_MESSAGE);
+    }
+    const current = readFactorySettingsForContext(ctx);
+    const next = { ...current };
+    if (patch.maxConcurrent !== undefined) {
+        next.maxConcurrent = patch.maxConcurrent;
+    }
+    if (patch.credentialSource !== undefined) {
+        next.credentialSource = patch.credentialSource;
+    }
+    const out = {};
+    if (next.maxConcurrent !== undefined) {
+        out.maxConcurrent = next.maxConcurrent;
+    }
+    if (next.credentialSource !== undefined) {
+        out.credentialSource = next.credentialSource;
+    }
+    ensureSettingsDirForContext(ctx);
+    writeFileSync(settingsFilePathForContext(ctx), `${JSON.stringify(out, null, 2)}\n`, "utf8");
+}
 export function writeFactorySettings(cwd, patch) {
     if (patch.credentialSource !== undefined &&
         parseCredentialSource(patch.credentialSource) === undefined) {
@@ -71,18 +134,36 @@ export function writeFactorySettings(cwd, patch) {
     if (next.credentialSource !== undefined) {
         out.credentialSource = next.credentialSource;
     }
-    mkdirSync(storeRootFor(cwd), { recursive: true });
+    const root = path.resolve(cwd);
+    mkdirSync(storeRootFor(root), { recursive: true });
     writeFileSync(settingsFilePath(cwd), `${JSON.stringify(out, null, 2)}\n`, "utf8");
 }
+export function readMaxConcurrentFromContext(ctx) {
+    return readFactorySettingsForContext(ctx).maxConcurrent;
+}
 export function readMaxConcurrentFromFile(cwd) {
     return readFactorySettings(cwd).maxConcurrent;
 }
+export function writeMaxConcurrentToContext(ctx, maxConcurrent) {
+    writeFactorySettingsForContext(ctx, { maxConcurrent });
+}
 export function writeMaxConcurrentToFile(cwd, maxConcurrent) {
     writeFactorySettings(cwd, { maxConcurrent });
 }
 export function readCredentialSourceFromFile(cwd) {
     return readFactorySettings(cwd).credentialSource;
 }
+export function writeCredentialSourceToContext(ctx, credentialSource) {
+    writeFactorySettingsForContext(ctx, { credentialSource });
+}
 export function writeCredentialSourceToFile(cwd, credentialSource) {
     writeFactorySettings(cwd, { credentialSource });
 }
+export function projectSettingsContext(cwd, projectRoot, isGitProject) {
+    return {
+        invocationCwd: path.resolve(cwd),
+        projectRoot: path.resolve(projectRoot),
+        globalHome: globalStageflowHome(),
+        isGitProject,
+    };
+}

package/dist/runtime/stageAttemptBootstrap.js

@@ -1,4 +1,5 @@
 import { resolveSkillByName } from "../config/listSkills.js";
+import { resolveForkEmitContext } from "../config/resolveForkEmitContext.js";
 import { buildCompletedEnvelopesFromRun, resolvePriorEnvelope, } from "./envelopeRouting.js";
 import { resumeSessionFilePath } from "./stageAttemptContext.js";
 import { buildStageRoots, rootsForStageWorker, withResolvedAuthPath, } from "./stageRoots.js";
@@ -63,6 +64,7 @@ export async function openStageAttempt(input) {
     const attempt = input.attemptCtx?.attempt ?? 1;
     const resumeToken = input.resumeToken ??
         resumeSessionFilePath(input.workspaceDir, input.stage.id, attempt);
+    const forkEmitContext = resolveForkEmitContext(input.dag, input.stage.id);
     const opened = await openStageWithOperatorCatalog(input.agent, {
         roots,
         stage: input.stage,
@@ -70,6 +72,7 @@ export async function openStageAttempt(input) {
         priorEnvelope: priorResult.prior,
         resumeToken,
         onActivity: input.onActivity,
+        forkEmitContext,
     }, input.operatorCatalog);
     if (!opened.ok)
         return opened;

package/dist/runtime/stageProcessLauncher.js

@@ -132,6 +132,9 @@ export class StageProcessLauncher {
         if (input.sessionFilePath !== undefined) {
             args.push("--session-file", input.sessionFilePath);
         }
+        if (input.operatorCatalog?.cwd !== undefined) {
+            args.push("--operator-cwd", input.operatorCatalog.cwd);
+        }
         if (input.operatorCatalog?.agentDir !== undefined) {
             args.push("--operator-agent-dir", input.operatorCatalog.agentDir);
         }

package/dist/runtime/stageRecovery.js

@@ -34,9 +34,11 @@ export async function failStageAsInterrupted(options) {
     }
 }
 export async function syncRunStatusFromStages(store, runId) {
+    const meta = await store.readRunMeta(runId);
+    if (meta.status === "succeeded")
+        return;
     const run = await store.readRun(runId);
     const derived = deriveStatusFromStages(run.stages);
-    const meta = await store.readRunMeta(runId);
     if ((meta.status ?? "created") !== derived) {
         await store.updateRunStatus(runId, derived);
     }

package/dist/runtime/stageWorker.js

@@ -1,7 +1,6 @@
 import { PiAgentAdapter } from "../agent/piAdapter.js";
-import { loadPipeline } from "../config/loadPipeline.js";
-import { loadTaskFromYaml } from "../config/loadTask.js";
 import { createRunStore } from "../runstore/createStore.js";
+import { loadRunContext } from "./resumeReconstruct.js";
 import { bindPiAgentDirEnv, rootsForStageWorker, withResolvedAuthPath, } from "./stageRoots.js";
 import { runStage, isRunStageWaiting, } from "./stageRunner.js";
 import { openStageAttempt } from "./stageAttemptBootstrap.js";
@@ -9,10 +8,7 @@ import { attemptContext } from "./stageAttemptContext.js";
 import { outcomeToWorkerResult, STAGE_WORKER_EXIT, } from "./stageWorkerProtocol.js";
 export async function runStageWorker(input) {
     const store = createRunStore({ rootDir: input.rootDir });
-    const meta = await store.readRunMeta(input.runId);
-    const taskYaml = await store.readTaskYaml(input.runId);
-    const task = loadTaskFromYaml(taskYaml, `run ${input.runId} task`);
-    const loaded = await loadPipeline(meta.pipeline_id, { cwd: input.rootDir });
+    const { meta, task, loaded } = await loadRunContext(store, input.runId, input.rootDir);
     const stage = loaded.stages.find((s) => s.id === input.stageId);
     if (!stage) {
         return {

package/dist/server/http.js

@@ -8,12 +8,14 @@ import { getCredentialSourceSettings, setCredentialSource, } from "../agent/prov
 import { handleProviderRoutes, providerAuthErrorBody, } from "./providerRoutes.js";
 import { createPipeline, parseCreatePipelineBody } from "../config/createPipeline.js";
 import { createStage, parseCreateStageBody } from "../config/createStage.js";
-import { listModels, listPipelines, listStages, listTasks, } from "../config/listConfig.js";
+import { browseCatalog } from "../config/browseCatalog.js";
 import { listExtensions } from "../config/listExtensions.js";
 import { listSkills } from "../config/listSkills.js";
 import { readRunArtifact } from "../mcp/readArtifact.js";
 import { handleMcpHttpRequest } from "../mcp/server.js";
 import { createRunStore } from "../runstore/createStore.js";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
+import { findProjectRoot } from "../project/findProjectRoot.js";
 import { RunManager, } from "../runtime/runManager.js";
 import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, } from "../runtime/settingsFile.js";
 import { isTaskFile } from "../runtime/taskInput.js";
@@ -202,9 +204,14 @@ export function defaultUiDistDir() {
     return path.resolve(here, "../ui");
 }
 export async function startUiServer(options) {
-    const cwd = options.cwd ?? process.cwd();
+    const invocationCwd = options.cwd ?? process.cwd();
+    const ctx = await resolveStageflowContext(invocationCwd);
+    const cwd = ctx.invocationCwd;
     const agentDir = options.agentDir ?? getAgentDir();
-    const rootDir = options.rootDir ?? cwd;
+    const rootDir = options.rootDir ?? ctx.projectRoot;
+    const isGitProject = options.rootDir !== undefined
+        ? findProjectRoot(rootDir) !== null
+        : ctx.isGitProject;
     const host = options.host ?? "127.0.0.1";
     const port = options.port ?? DEFAULT_PORT;
     const providerAuthContext = options.providerAuthContext;
@@ -214,6 +221,8 @@ export async function startUiServer(options) {
     const manager = new RunManager({
         agent: options.agent,
         cwd,
+        projectRoot: rootDir,
+        isGitProject,
         store,
         maxConcurrent: options.maxConcurrent,
         operatorCatalog: { cwd, agentDir },
@@ -388,15 +397,19 @@ export async function startUiServer(options) {
                 return;
             }
             if (method === "GET" && pathname === "/api/tasks") {
-                json(res, 200, { tasks: await listTasks(cwd) });
+                const catalog = await browseCatalog(cwd);
+                json(res, 200, { tasks: catalog.tasks });
                 return;
             }
             if (method === "GET" && pathname === "/api/pipelines") {
-                json(res, 200, { pipelines: await listPipelines(cwd) });
+                const catalog = await browseCatalog(cwd);
+                json(res, 200, { pipelines: catalog.pipelines });
                 return;
             }
             if (method === "GET" && pathname === "/api/stages") {
-                json(res, 200, { stages: await listStages(cwd) });
+                json(res, 404, {
+                    error: "Global stage library removed; stages are pipeline-scoped",
+                });
                 return;
             }
             if (method === "POST" && pathname === "/api/stages") {
@@ -413,7 +426,12 @@ export async function startUiServer(options) {
                     json(res, parsed.status, { error: parsed.error });
                     return;
                 }
-                const result = await createStage(cwd, parsed);
+                const ctx = await resolveStageflowContext(cwd);
+                if (!ctx.isGitProject) {
+                    json(res, 400, { error: "Project root not found; initialize stageflow.yaml in a git repo" });
+                    return;
+                }
+                const result = await createStage(ctx.projectRoot, parsed);
                 if (!result.ok) {
                     json(res, result.status, { error: result.error });
                     return;
@@ -435,7 +453,12 @@ export async function startUiServer(options) {
                     json(res, parsed.status, { error: parsed.error });
                     return;
                 }
-                const result = await createPipeline(cwd, parsed);
+                const ctx = await resolveStageflowContext(cwd);
+                if (!ctx.isGitProject) {
+                    json(res, 400, { error: "Project root not found; initialize stageflow.yaml in a git repo" });
+                    return;
+                }
+                const result = await createPipeline(ctx.projectRoot, parsed);
                 if (!result.ok) {
                     json(res, result.status, { error: result.error });
                     return;
@@ -444,7 +467,8 @@ export async function startUiServer(options) {
                 return;
             }
             if (method === "GET" && pathname === "/api/models") {
-                json(res, 200, { models: await listModels(cwd) });
+                const catalog = await browseCatalog(cwd);
+                json(res, 200, { models: catalog.models });
                 return;
             }
             if (await handleProviderRoutes(req, res, {

package/dist/tools/emitStageEnvelope.d.ts

@@ -11,11 +11,12 @@
  */
 import { Type } from "typebox";
 import type { StageEnvelope } from "../types/envelope.js";
+import type { ForkEmitContext } from "../types/forkChoice.js";
 export type EmitCapture = {
     envelope?: StageEnvelope;
     error?: string;
 };
-export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloadSchema?: unknown): {
+export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloadSchema?: unknown, forkEmitContext?: ForkEmitContext): {
     name: string;
     label: string;
     description: string;
@@ -24,6 +25,7 @@ export declare function createEmitStageEnvelopeTool(capture: EmitCapture, payloa
         summary: Type.TString;
         artifacts: Type.TArray<Type.TString>;
         payload: Type.TSchema;
+        fork_choice: Type.TArray<Type.TString>;
         stage_id: Type.TOptional<Type.TString>;
         notes: Type.TOptional<Type.TString>;
     }>;