stageflow 0.2.0 → 0.8.0

package/dist/agent/fakeAgent.js

@@ -2,9 +2,11 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "
 import path from "node:path";
 import { assertRequiredEnvelope, isAdvancingEnvelope, } from "../envelope/check.js";
 import { assertEnvelopePayload } from "../envelope/payloadSchema.js";
+import { assertCloneForks } from "../envelope/cloneForks.js";
+import { assertForkEnvelope } from "../envelope/forkChoice.js";
 import { assertAnswerMatchesPrompt, parseAskOperatorAnswer, } from "../tools/askOperator.js";
 import { tryParsePendingPrompt } from "../runtime/stageHitl.js";
-import { runStageViaOpen } from "./port.js";
+import { runtimeStageId, runStageViaOpen } from "./port.js";
 function opaqueEqual(a, b) {
     if (Object.is(a, b))
         return true;
@@ -82,7 +84,7 @@ export class FakeAgent {
             return answer;
         };
         if (behavior.type === "wait_then_emit") {
-            const loaded = loadFakeHitlResume(input.roots, input.stage.id);
+            const loaded = loadFakeHitlResume(input.roots, runtimeStageId(input));
             if (loaded === "corrupt") {
                 resumeCorrupt = true;
             }
@@ -115,7 +117,7 @@ export class FakeAgent {
             });
         };
         const finishEmit = () => {
-            clearFakeHitlResume(input.roots, input.stage.id);
+            clearFakeHitlResume(input.roots, runtimeStageId(input));
             if (behavior.type === "throw") {
                 input.onActivity?.({ event: "agent_end" });
                 return {
@@ -135,6 +137,12 @@ export class FakeAgent {
                 : undefined;
             try {
                 const envelope = assertRequiredEnvelope(envelopeValue);
+                if (input.forkEmitContext !== undefined) {
+                    assertForkEnvelope(envelope, input.forkEmitContext);
+                }
+                if (input.cloneEmitContext !== undefined) {
+                    assertCloneForks(envelope, input.cloneEmitContext);
+                }
                 assertEnvelopePayload(envelope, input.stage.payload_schema);
                 if (!isAdvancingEnvelope(envelope)) {
                     input.onActivity?.({ event: "agent_end" });
@@ -167,7 +175,7 @@ export class FakeAgent {
             }
         };
         return {
-            stageId: input.stage.id,
+            stageId: runtimeStageId(input),
             async next() {
                 if (closed) {
                     return {
@@ -206,7 +214,7 @@ export class FakeAgent {
                         }
                         catch (err) {
                             input.onActivity?.({ event: "agent_end" });
-                            clearFakeHitlResume(input.roots, input.stage.id);
+                            clearFakeHitlResume(input.roots, runtimeStageId(input));
                             return {
                                 status: "completed",
                                 result: {
@@ -223,7 +231,7 @@ export class FakeAgent {
                         answer !== undefined &&
                         !opaqueEqual(answer, expected)) {
                         input.onActivity?.({ event: "agent_end" });
-                        clearFakeHitlResume(input.roots, input.stage.id);
+                        clearFakeHitlResume(input.roots, runtimeStageId(input));
                         return {
                             status: "completed",
                             result: {
@@ -237,7 +245,7 @@ export class FakeAgent {
                     const request = behavior.waitRequests[waitIndex];
                     waitIndex += 1;
                     armWait();
-                    writeFakeHitlResume(input.roots, input.stage.id, {
+                    writeFakeHitlResume(input.roots, runtimeStageId(input), {
                         waitRequests: behavior.waitRequests,
                         expectedAnswers: behavior.expectedAnswers,
                         envelope: behavior.envelope,

package/dist/agent/piAdapter.d.ts

@@ -2,6 +2,7 @@ import { type AgentSession, DefaultResourceLoader, SessionManager, SettingsManag
 import type { StageRoots } from "../runtime/stageRoots.js";
 import { type AskOperatorPrompt, type AskOperatorWaitBridge } from "../tools/askOperator.js";
 import "./cursorProvider.js";
+import { type StageActivityObserver } from "./activityObserver.js";
 import type { AgentPort, OpaqueAnswer, StageHandle, StageHandleCloseOptions, StageRunInput, StageRunResult } from "./port.js";
 /**
  * Stage tool allowlist for sealed Pi sessions.
@@ -45,6 +46,21 @@ export type ConnectedAskWaitStageHandleOptions = {
  * runtime never imports the channel.
  */
 export declare function createConnectedAskWaitStageHandle(options: ConnectedAskWaitStageHandleOptions): StageHandle;
+/**
+ * Extract display text from a Pi tool_execution_update partialResult.
+ * Prefers content[].text blocks; otherwise JSON-stringifies.
+ */
+export declare function extractPartialResultText(partialResult: unknown): string;
+export type RouteSessionEventToProgressOptions = {
+    observer: StageActivityObserver;
+    verbose: boolean;
+};
+/**
+ * Adapter-edge routing: stream deltas to the observer, map milestones to
+ * StageActivityEvent. Verbose thinking / live tool partials go to observer
+ * hooks (stderr streams + coalesced/throttled persist via onActivity).
+ */
+export declare function routeSessionEventToProgress(event: Record<string, unknown>, options: RouteSessionEventToProgressOptions): void;
 export declare function composeStageUserPrompt(input: StageRunInput, emitToolName: string, emitHintOverride?: string, artifactToolName?: string): string;
 /**
  * DefaultResourceLoader with host/global discovery turned off.
@@ -68,6 +84,7 @@ export declare function createSealedResourceLoader(options: {
 }): DefaultResourceLoader;
 /** Stable Pi session JSONL path under the run workspace stage dir. */
 export declare function stageSessionFilePath(roots: Pick<StageRoots, "runWorkspaceDir" | "attempt">, stageId: string): string;
+export declare function resolveStageSessionFile(input: StageRunInput): string;
 export declare class StageSessionReconstructError extends Error {
     readonly stageId: string;
     readonly sessionFile: string;
@@ -81,7 +98,7 @@ export declare class StageSessionReconstructError extends Error {
  * Create or reopen the durable stage session file under the run workspace.
  * Touches an empty file first so Pi flushes the session header immediately.
  */
-export declare function createStageSessionManager(roots: StageRoots, stageId: string): Promise<SessionManager>;
+export declare function createStageSessionManager(roots: StageRoots, stageId: string, sessionFile?: string): Promise<SessionManager>;
 /**
  * Open an existing stage session for post-restart reconstruct.
  * Missing or corrupt files fail closed (KTD7) — never create a fresh session.

package/dist/agent/piAdapter.js

@@ -41,9 +41,9 @@ import { createAskOperatorTool, } from "../tools/askOperator.js";
 import { createWriteStageArtifactTool } from "../tools/writeStageArtifact.js";
 import "./cursorProvider.js";
 import { findProviderSupport } from "./providerSupport.js";
-import { mapSessionEventToActivity } from "./activity.js";
-import { createStageActivityObserver } from "./activityObserver.js";
-import { DEFAULT_STAGE_TIMEOUT_MS, runStageViaOpen } from "./port.js";
+import { mapSessionEventToActivity, readActivityVerbose } from "./activity.js";
+import { createStageActivityObserver, } from "./activityObserver.js";
+import { DEFAULT_STAGE_TIMEOUT_MS, runtimeStageId, runStageViaOpen } from "./port.js";
 /**
  * Stage tool allowlist for sealed Pi sessions.
  * Always includes `ask_operator` (R7); `write_stage_artifact` when registered
@@ -260,31 +260,98 @@ export function createConnectedAskWaitStageHandle(options) {
         },
     };
 }
+/**
+ * Extract display text from a Pi tool_execution_update partialResult.
+ * Prefers content[].text blocks; otherwise JSON-stringifies.
+ */
+export function extractPartialResultText(partialResult) {
+    if (partialResult === undefined || partialResult === null) {
+        return "";
+    }
+    if (typeof partialResult === "string") {
+        return partialResult;
+    }
+    if (typeof partialResult === "object") {
+        const content = partialResult.content;
+        if (Array.isArray(content)) {
+            const parts = [];
+            for (const block of content) {
+                if (!block || typeof block !== "object")
+                    continue;
+                const b = block;
+                if (b.type === "text" && typeof b.text === "string") {
+                    parts.push(b.text);
+                }
+            }
+            if (parts.length > 0) {
+                return parts.join("");
+            }
+        }
+        try {
+            return JSON.stringify(partialResult);
+        }
+        catch {
+            return String(partialResult);
+        }
+    }
+    return String(partialResult);
+}
+/**
+ * Adapter-edge routing: stream deltas to the observer, map milestones to
+ * StageActivityEvent. Verbose thinking / live tool partials go to observer
+ * hooks (stderr streams + coalesced/throttled persist via onActivity).
+ */
+export function routeSessionEventToProgress(event, options) {
+    const { observer, verbose } = options;
+    if (event.type === "message_update") {
+        const ame = event.assistantMessageEvent;
+        if (ame && typeof ame === "object") {
+            const update = ame;
+            if (update.type === "text_delta") {
+                observer.onAssistantTextDelta(update.delta ?? "");
+                return;
+            }
+            if (verbose && update.type === "thinking_delta") {
+                observer.onThinkingDelta(update.delta ?? "");
+                return;
+            }
+        }
+        return;
+    }
+    if (verbose &&
+        event.type === "tool_execution_update") {
+        const text = extractPartialResultText(event.partialResult);
+        if (text) {
+            observer.onToolPartialResult(text);
+        }
+        return;
+    }
+    if (event.type === "message_end" || event.type === "agent_end") {
+        observer.onStreamBoundary();
+    }
+    if (event.type === "agent_start" ||
+        event.type === "turn_start" ||
+        event.type === "tool_execution_start") {
+        observer.onStreamBoundary();
+    }
+    const activity = mapSessionEventToActivity(event);
+    if (!activity) {
+        return;
+    }
+    observer.onActivity(activity);
+}
 /**
  * Map Pi session events to StageActivityEvent at the adapter edge, then
  * forward to the activity observer (stderr + onActivity).
  */
 function attachStageProgress(session, onActivity) {
     const observer = createStageActivityObserver({ onActivity, writeStderr: true });
+    const verbose = readActivityVerbose();
     const unsubscribe = session.subscribe((event) => {
-        if (event.type === "message_update" &&
-            event.assistantMessageEvent.type === "text_delta") {
-            observer.onAssistantTextDelta(event.assistantMessageEvent.delta ?? "");
-            return;
-        }
-        if (event.type === "message_end" || event.type === "agent_end") {
-            observer.onStreamBoundary();
-        }
-        if (event.type === "agent_start" ||
-            event.type === "turn_start" ||
-            event.type === "tool_execution_start") {
-            observer.onStreamBoundary();
-        }
-        const activity = mapSessionEventToActivity(event);
-        if (!activity) {
-            return;
-        }
-        observer.onActivity(activity);
+        routeSessionEventToProgress(event, {
+            observer,
+            verbose,
+        });
     });
     return () => {
         unsubscribe();
@@ -298,7 +365,7 @@ function buildUserPrompt(input, emitToolName, emitHintOverride, artifactToolName
         emitHint += `\nOn status=success, payload is required and must match this JSON Schema:\n${JSON.stringify(input.stage.payload_schema, null, 2)}`;
     }
     const attempt = input.roots.attempt ?? 1;
-    const attemptArtifactsPath = `stages/${input.stage.id}/attempts/${attempt}/artifacts/`;
+    const attemptArtifactsPath = `stages/${runtimeStageId(input)}/attempts/${attempt}/artifacts/`;
     const skillBaseDir = input.stage.skill !== undefined && input.skillFilePath !== undefined
         ? path.dirname(input.skillFilePath)
         : undefined;
@@ -323,11 +390,11 @@ function buildUserPrompt(input, emitToolName, emitHintOverride, artifactToolName
             : `Create factory stage artifacts under ${attemptArtifactsPath} relative to the run folder.`;
     return [
         `Task id: ${input.task.id}`,
-        `Stage id: ${input.stage.id}`,
+        `Stage id: ${runtimeStageId(input)}`,
         `Goal: ${input.task.goal}`,
         input.task.context ? `Context: ${input.task.context}` : "",
         input.task.constraints ? `Constraints: ${input.task.constraints}` : "",
-        formatPriorEnvelope(input.priorEnvelope),
+        formatPriorEnvelope(input.priorEnvelope, input.priorEnvelopes),
         "",
         artifactGuidance,
         emitHint,
@@ -423,6 +490,10 @@ export function stageSessionFilePath(roots, stageId) {
         : noAttemptContext();
     return ctx.sessionPath(roots.runWorkspaceDir, stageId);
 }
+export function resolveStageSessionFile(input) {
+    return (input.resumeToken ??
+        stageSessionFilePath(input.roots, runtimeStageId(input)));
+}
 export class StageSessionReconstructError extends Error {
     stageId;
     sessionFile;
@@ -437,8 +508,7 @@ export class StageSessionReconstructError extends Error {
  * Create or reopen the durable stage session file under the run workspace.
  * Touches an empty file first so Pi flushes the session header immediately.
  */
-export async function createStageSessionManager(roots, stageId) {
-    const sessionFile = stageSessionFilePath(roots, stageId);
+export async function createStageSessionManager(roots, stageId, sessionFile = stageSessionFilePath(roots, stageId)) {
     await mkdir(path.dirname(sessionFile), { recursive: true });
     if (!(await fileExists(sessionFile))) {
         await writeFile(sessionFile, "");
@@ -616,7 +686,7 @@ async function prepareStageSessionWiring(input, sessionManager, existingAskWaitC
     const provider = findProviderSupport(input.stage.model);
     const capture = {};
     const askWaitChannel = existingAskWaitChannel ?? new AskOperatorWaitChannel();
-    const emitDef = createEmitStageEnvelopeTool(capture, input.stage.payload_schema);
+    const emitDef = createEmitStageEnvelopeTool(capture, input.stage.payload_schema, input.forkEmitContext, input.cloneEmitContext);
     const emitTool = defineTool(emitDef);
     const askDef = createAskOperatorTool({
         requestWait: (prompt) => askWaitChannel.requestWait(prompt),
@@ -624,7 +694,7 @@ async function prepareStageSessionWiring(input, sessionManager, existingAskWaitC
     const askTool = defineTool(askDef);
     const artifactDef = createWriteStageArtifactTool({
         runWorkspaceDir: roots.runWorkspaceDir,
-        stageId: input.stage.id,
+        stageId: runtimeStageId(input),
         attempt: roots.attempt ?? 1,
     });
     const artifactTool = defineTool(artifactDef);
@@ -721,18 +791,18 @@ function isStageRunResult(value) {
  * Does not auto-continue the model turn — U4 owns the yield loop.
  */
 export async function reconstructStageSessionForAnswer(input, answer) {
-    const sessionManager = await openStageSessionManager(input.roots, input.stage.id);
-    const sessionFile = ensureStageSessionFlushed(sessionManager, input.stage.id);
+    const sessionManager = await openStageSessionManager(input.roots, runtimeStageId(input));
+    const sessionFile = ensureStageSessionFlushed(sessionManager, runtimeStageId(input));
     let injection;
     try {
         injection = injectOpaqueAnswerIntoSession(sessionManager, answer);
     }
     catch (err) {
-        throw new StageSessionReconstructError(`failed to inject answer into stage session: ${sessionFile}`, { stageId: input.stage.id, sessionFile, cause: err });
+        throw new StageSessionReconstructError(`failed to inject answer into stage session: ${sessionFile}`, { stageId: runtimeStageId(input), sessionFile, cause: err });
     }
     const wiring = await prepareStageSessionWiring(input, sessionManager);
     if (isStageRunResult(wiring)) {
-        throw new StageSessionReconstructError(wiring.ok === false ? wiring.reason : "stage session reconstruct failed", { stageId: input.stage.id, sessionFile });
+        throw new StageSessionReconstructError(wiring.ok === false ? wiring.reason : "stage session reconstruct failed", { stageId: runtimeStageId(input), sessionFile });
     }
     let session;
     try {
@@ -753,7 +823,7 @@ export async function reconstructStageSessionForAnswer(input, answer) {
             modelRuntime: wiring.modelRuntime,
         });
         if (resolved.error || !resolved.model) {
-            throw new StageSessionReconstructError(resolved.error ?? `Model not found: ${input.stage.model}`, { stageId: input.stage.id, sessionFile });
+            throw new StageSessionReconstructError(resolved.error ?? `Model not found: ${input.stage.model}`, { stageId: runtimeStageId(input), sessionFile });
         }
         await session.setModel(resolved.model);
         if (resolved.thinkingLevel) {
@@ -779,7 +849,7 @@ export async function reconstructStageSessionForAnswer(input, answer) {
         wiring.restoreProvider?.();
         if (err instanceof StageSessionReconstructError)
             throw err;
-        throw new StageSessionReconstructError(`failed to reconstruct stage session: ${err instanceof Error ? err.message : String(err)}`, { stageId: input.stage.id, sessionFile, cause: err });
+        throw new StageSessionReconstructError(`failed to reconstruct stage session: ${err instanceof Error ? err.message : String(err)}`, { stageId: runtimeStageId(input), sessionFile, cause: err });
     }
 }
 async function bindStageSession(input, sessionManager, wiring) {
@@ -795,7 +865,7 @@ async function bindStageSession(input, sessionManager, wiring) {
         settingsManager: wiring.settingsManager,
     });
     const session = created.session;
-    ensureStageSessionFlushed(sessionManager, input.stage.id);
+    ensureStageSessionFlushed(sessionManager, runtimeStageId(input));
     await session.bindExtensions({});
     const resolved = resolveCliModel({
         cliModel: input.stage.model,
@@ -830,7 +900,7 @@ export class PiAgentAdapter {
     openStage(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_STAGE_TIMEOUT_MS;
         const askWaitChannel = new AskOperatorWaitChannel();
-        const sessionFile = input.resumeToken ?? stageSessionFilePath(input.roots, input.stage.id);
+        const sessionFile = resolveStageSessionFile(input);
         let sessionManager;
         let resumeWaiting = false;
         if (existsSync(sessionFile)) {
@@ -839,14 +909,14 @@ export class PiAgentAdapter {
             }
             catch (err) {
                 throw new StageSessionReconstructError(`stage session file corrupt or unreadable for resume: ${sessionFile}`, {
-                    stageId: input.stage.id,
+                    stageId: runtimeStageId(input),
                     sessionFile,
                     cause: err,
                 });
             }
-            ensureStageSessionFlushed(sessionManager, input.stage.id);
+            ensureStageSessionFlushed(sessionManager, runtimeStageId(input));
             if (!findOpenToolCall(sessionManager)) {
-                throw new StageSessionReconstructError(`stage session has no open tool call for resume: ${sessionFile}`, { stageId: input.stage.id, sessionFile });
+                throw new StageSessionReconstructError(`stage session has no open tool call for resume: ${sessionFile}`, { stageId: runtimeStageId(input), sessionFile });
             }
             resumeWaiting = true;
         }
@@ -856,7 +926,7 @@ export class PiAgentAdapter {
         let prepareError;
         const preparePromise = (async () => {
             if (!sessionManager) {
-                sessionManager = await createStageSessionManager(input.roots, input.stage.id);
+                sessionManager = await createStageSessionManager(input.roots, runtimeStageId(input), sessionFile);
             }
             const prepared = await prepareStageSessionWiring(input, sessionManager, askWaitChannel);
             if (isStageRunResult(prepared)) {
@@ -908,11 +978,11 @@ export class PiAgentAdapter {
             }
         };
         return createConnectedAskWaitStageHandle({
-            stageId: input.stage.id,
+            stageId: runtimeStageId(input),
             askWaitChannel,
             onBeforeWaitYield: () => {
                 if (sessionManager) {
-                    ensureStageSessionFlushed(sessionManager, input.stage.id);
+                    ensureStageSessionFlushed(sessionManager, runtimeStageId(input));
                 }
             },
             run: async () => {
@@ -925,7 +995,7 @@ export class PiAgentAdapter {
                 ? {
                     onDeliver: (answer) => {
                         if (!sessionManager) {
-                            throw new StageSessionReconstructError("stage session missing during resume deliver", { stageId: input.stage.id, sessionFile });
+                            throw new StageSessionReconstructError("stage session missing during resume deliver", { stageId: runtimeStageId(input), sessionFile });
                         }
                         injectOpaqueAnswerIntoSession(sessionManager, answer);
                         if (session) {
@@ -935,7 +1005,7 @@ export class PiAgentAdapter {
                     continueRun: async () => {
                         return runWithTimeout(async () => {
                             if (!session || !sessionManager) {
-                                throw new StageSessionReconstructError("stage session missing during resume continue", { stageId: input.stage.id, sessionFile });
+                                throw new StageSessionReconstructError("stage session missing during resume continue", { stageId: runtimeStageId(input), sessionFile });
                             }
                             syncAgentMessagesFromSession(session, sessionManager);
                             await session.agent.continue();
@@ -947,7 +1017,7 @@ export class PiAgentAdapter {
                 await preparePromise.catch(() => undefined);
                 if (closeOptions?.park) {
                     if (sessionManager) {
-                        ensureStageSessionFlushed(sessionManager, input.stage.id);
+                        ensureStageSessionFlushed(sessionManager, runtimeStageId(input));
                         if (askWaitChannel.hasPending) {
                             await repairPrematureAskOperatorClosure(sessionFile);
                         }

package/dist/agent/port.d.ts

@@ -1,4 +1,5 @@
 import type { StageEnvelope } from "../types/envelope.js";
+import type { CloneEmitContext, ForkEmitContext } from "../types/forkChoice.js";
 import type { StageConfig } from "../types/stage.js";
 import type { TaskFile } from "../types/task.js";
 import type { StageActivityEvent } from "./activity.js";
@@ -8,14 +9,20 @@ export type StageResumeToken = string;
 export type StageRunInput = {
     roots: StageRoots;
     stage: StageConfig;
+    /** Runtime instance id (`work~2`). Defaults to `stage.id` when omitted. */
+    stageId?: string;
     task: TaskFile;
     priorEnvelope: StageEnvelope | null;
+    priorEnvelopes?: StageEnvelope[];
     timeoutMs?: number;
     resumeToken?: StageResumeToken;
     /** Optional observe hook; HITL wait/answer uses openStage beside this. */
     onActivity?: (event: StageActivityEvent) => void;
     skillFilePath?: string;
+    forkEmitContext?: ForkEmitContext;
+    cloneEmitContext?: CloneEmitContext;
 };
+export declare function runtimeStageId(input: Pick<StageRunInput, "stage" | "stageId">): string;
 export type StageRunResult = {
     ok: true;
     envelope: StageEnvelope;

package/dist/agent/port.js

@@ -1,3 +1,6 @@
+export function runtimeStageId(input) {
+    return input.stageId ?? input.stage.id;
+}
 /** Thin non-HITL wrapper: open → next; unexpected wait fails closed. */
 export async function runStageViaOpen(port, input) {
     const handle = port.openStage(input);

package/dist/agent/providerAuth.js

@@ -1,5 +1,7 @@
 import { CredentialSynchronizationError, ModelRuntime, } from "@earendil-works/pi-coding-agent";
-import { isUsableAuthFile, parseCredentialSource, piHomeAuthPath, readCredentialSourceFromFile, resolveCredentialBinding, writeCredentialSourceToFile, } from "../runtime/credentialBinding.js";
+import { isUsableAuthFile, parseCredentialSource, piHomeAuthPath, resolveCredentialBinding, writeCredentialSourceToContext, } from "../runtime/credentialBinding.js";
+import { readPersistedCredentialSourceFromContext, } from "../runtime/settingsFile.js";
+import { resolveProjectContext } from "../project/resolveProjectContext.js";
 export function makeMutationLock() {
     let tail = Promise.resolve();
     return {
@@ -245,8 +247,9 @@ export async function logoutProvider(cwd, providerId, ctx = defaultContext) {
     });
 }
 export function detectPiHome(cwd) {
-    const binding = resolveCredentialBinding(cwd);
-    const persisted = readCredentialSourceFromFile(cwd);
+    const projectCtx = resolveProjectContext(cwd);
+    const binding = resolveCredentialBinding(projectCtx);
+    const persisted = readPersistedCredentialSourceFromContext(projectCtx);
     return {
         piHomeUsable: isUsableAuthFile(piHomeAuthPath()),
         ...(persisted !== undefined ? { credentialSource: persisted } : {}),
@@ -255,8 +258,9 @@ export function detectPiHome(cwd) {
     };
 }
 export function getCredentialSourceSettings(cwd) {
-    const persisted = readCredentialSourceFromFile(cwd);
-    const binding = resolveCredentialBinding(cwd);
+    const projectCtx = resolveProjectContext(cwd);
+    const persisted = readPersistedCredentialSourceFromContext(projectCtx);
+    const binding = resolveCredentialBinding(projectCtx);
     return {
         ...(persisted !== undefined ? { credentialSource: persisted } : {}),
         binding: {
@@ -270,8 +274,9 @@ export function setCredentialSource(cwd, credentialSource) {
     if (parsed === undefined) {
         throw new ProviderAuthError('credentialSource must be "pi_home" or "sf_owned"', 400);
     }
-    writeCredentialSourceToFile(cwd, parsed);
-    const binding = resolveCredentialBinding(cwd);
+    const projectCtx = resolveProjectContext(cwd);
+    writeCredentialSourceToContext(projectCtx, parsed);
+    const binding = resolveCredentialBinding(projectCtx);
     return {
         credentialSource: parsed,
         binding: {

package/dist/catalog/displayCatalogPath.d.ts

@@ -0,0 +1,12 @@
+export declare function displayCatalogPath(absPath: string, projectRoot?: string): string;
+export declare function normalizeCatalogSlashes(pathValue: string): string;
+export type PipelinePathMatchInput = {
+    pipeline_id: string;
+    pipeline_path?: string;
+    project_root?: string;
+};
+export type PipelineListingPath = {
+    id: string;
+    path: string;
+};
+export declare function matchPipelineRun(run: PipelinePathMatchInput, pipeline: PipelineListingPath): boolean;

package/dist/catalog/displayCatalogPath.js

@@ -0,0 +1,28 @@
+export function displayCatalogPath(absPath, projectRoot) {
+    if (projectRoot) {
+        const root = projectRoot.replace(/\\/g, "/").replace(/\/$/, "");
+        const normalized = absPath.replace(/\\/g, "/");
+        if (normalized === root)
+            return ".";
+        const prefix = `${root}/`;
+        if (normalized.startsWith(prefix)) {
+            return normalized.slice(prefix.length);
+        }
+    }
+    const parts = absPath.replace(/\\/g, "/").split("/");
+    return parts[parts.length - 1] ?? absPath;
+}
+export function normalizeCatalogSlashes(pathValue) {
+    return pathValue.replace(/\\/g, "/");
+}
+export function matchPipelineRun(run, pipeline) {
+    if (run.pipeline_id === pipeline.id)
+        return true;
+    if (run.pipeline_path && run.project_root) {
+        const rel = displayCatalogPath(run.pipeline_path, run.project_root);
+        if (normalizeCatalogSlashes(rel) === normalizeCatalogSlashes(pipeline.path)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/cli/artifactCommand.d.ts

@@ -0,0 +1,10 @@
+export declare const ARTIFACT_USAGE = "Usage:\n  sf artifact read --run <runId> --path <relPath> [--out <file>]";
+export type ArtifactCommandIo = {
+    log: (line: string) => void;
+    error: (line: string) => void;
+};
+export declare function runArtifactCommand(args: string[], options?: {
+    cwd?: string;
+    projectRoot?: string;
+    io?: Partial<ArtifactCommandIo>;
+}): Promise<number>;