stageflow 0.32.0 → 0.35.0

package/dist/operatorAgent/profiles/workshopAuthorTools.js

@@ -1,6 +1,9 @@
+import path from "node:path";
 import { parse as parseYaml } from "yaml";
+import { CatalogPathError, resolveDefaultWriteRoot, } from "../../config/catalogRelativePath.js";
 import { defaultWorkshopPackageDirectory } from "../../config/ensureCatalogScanRoot.js";
 import { publishDraftPackage } from "../../config/publishDraftPackage.js";
+import { globalStageflowHome } from "../../project/globalHome.js";
 import { emptyDraftPackage, isWorkshopDraftContext, readDraftFromContext, withDraft, } from "../draftContext.js";
 import { focusUnboundWorkshopBuild, getWorkshopBuild, listWorkshopPickerRows, resolvePickerCatalogPipelines, } from "../../workshop/buildStore.js";
 import { focusWorkshopBuildPointer, pinWorkshopBuildOnCreate, recordPinnedWorkshopSave, resolveLiveWorkshopBinding, resolvePinnedSaveDestination, } from "../../workshop/workshopPin.js";
@@ -99,10 +102,10 @@ function readWorkshopContext(ctx) {
         return raw;
     return { draft: readDraftFromContext(raw) };
 }
-function resolveDestination(ctx, args) {
+function resolveDestination(ctx, args, catalogRootKind) {
     const directory = stringArg(args, "directory") ??
         readWorkshopContext(ctx).destination?.directory ??
-        defaultWorkshopPackageDirectory(readDraftFromContext(ctx.getContext()).pipeline.id);
+        defaultWorkshopPackageDirectory(readDraftFromContext(ctx.getContext()).pipeline.id, catalogRootKind);
     const pipelineFilename = stringArg(args, "pipelineFilename") ??
         stringArg(args, "pipeline_filename") ??
         readWorkshopContext(ctx).destination?.pipelineFilename;
@@ -113,6 +116,64 @@ function resolveProjectRoot(ctx, defaultProjectRoot) {
     // (or the profile/host default passed into createSaveTool).
     return readWorkshopContext(ctx).projectRoot ?? defaultProjectRoot ?? null;
 }
+async function resolveSaveWriteTarget(ctx, options) {
+    const bound = resolveProjectRoot(ctx, options.projectRoot);
+    const live = liveWorkshopBinding(ctx);
+    const storeRoot = live?.storeRoot ?? globalStageflowHome();
+    const { createRunStore } = await import("../../runstore/createStore.js");
+    const store = createRunStore({ rootDir: storeRoot });
+    try {
+        if (bound) {
+            try {
+                const { wireRoot } = await resolveDefaultWriteRoot({ store }, bound);
+                return {
+                    ok: true,
+                    target: {
+                        fsRoot: wireRoot.path,
+                        wireProjectRoot: wireRoot.project_root,
+                        catalogRootKind: wireRoot.kind,
+                    },
+                };
+            }
+            catch (err) {
+                if (err instanceof CatalogPathError &&
+                    err.code === "unknown_project_root") {
+                    const abs = path.resolve(bound);
+                    return {
+                        ok: true,
+                        target: {
+                            fsRoot: abs,
+                            wireProjectRoot: abs,
+                            catalogRootKind: "registered",
+                        },
+                    };
+                }
+                if (err instanceof CatalogPathError) {
+                    return { ok: false, error: err.message };
+                }
+                throw err;
+            }
+        }
+        const { wireRoot } = await resolveDefaultWriteRoot({ store }, undefined);
+        return {
+            ok: true,
+            target: {
+                fsRoot: wireRoot.path,
+                wireProjectRoot: wireRoot.project_root,
+                catalogRootKind: wireRoot.kind,
+            },
+        };
+    }
+    catch (err) {
+        if (err instanceof CatalogPathError) {
+            return { ok: false, error: err.message };
+        }
+        throw err;
+    }
+    finally {
+        await store.close();
+    }
+}
 export function buildCreateStageDraft(draft, args) {
     const existingIds = new Set(draft.pipeline.stages.map((s) => (typeof s.id === "string" ? s.id : "")));
     let stageId = stringArg(args, "id") ??
@@ -366,7 +427,7 @@ async function listPickerCatalog(storeRoot) {
 export function createWorkshopBuildTools() {
     const listBuildsTool = {
         name: "list_builds",
-        description: "List the same workshop rows as the studio picker (open builds and unbound disk pipelines). Does not create a build. Works when no build is focused.",
+        description: "List the same workshop rows as the studio picker (open builds and unbound disk pipelines). Each row includes catalogListed (whether Tasks/Pipelines would list that pipeline path). Does not create a build. Works when no build is focused.",
         async handler(_args, ctx) {
             const live = liveWorkshopBinding(ctx);
             if (!live) {
@@ -374,7 +435,16 @@ export function createWorkshopBuildTools() {
             }
             try {
                 const catalog = await listPickerCatalog(live.storeRoot);
-                const rows = listWorkshopPickerRows(live.storeRoot, catalog.pipelines, catalog.roots);
+                const rows = listWorkshopPickerRows(live.storeRoot, catalog.pipelines, catalog.roots).map((row) => {
+                    if (!row.projectRoot || !row.relativePath) {
+                        return { ...row, catalogListed: false };
+                    }
+                    const relPath = row.relativePath;
+                    const normalize = (value) => value.replace(/\\/g, "/").replace(/^\.\//, "");
+                    const listed = catalog.pipelines.some((pipeline) => pipeline.project_root === row.projectRoot &&
+                        normalize(pipeline.path) === normalize(relPath));
+                    return { ...row, catalogListed: listed };
+                });
                 return { ok: true, content: { rows } };
             }
             catch (err) {
@@ -556,23 +626,24 @@ export function createWorkshopAuthorMutatingTools() {
 export function createSaveTool(options = {}) {
     return {
         name: "save",
-        description: "Validate-then-write the draft via catalog facades (createDraftPackage / overwriteDraftPackage). When directory is omitted, writes under workshop/<pipeline-id>, which the host adds to the catalog so Run can see the pipeline and task. Pass directory only when the operator names a folder. Soft undo does not reverse disk. Prefer mode auto; set allowInvalid only when the operator explicitly requests saving invalid YAML. Do not pass projectRoot — the host binds it.",
+        description: "Validate-then-write the draft via catalog facades (createDraftPackage / overwriteDraftPackage). When directory is omitted, writes under workshop/<pipeline-id> on registered catalogs (or <pipeline-id> on the workspace catalog). The host adds registered workshop paths to stageflow.yaml so Run can see them. Pass directory only when the operator names a folder. Soft undo does not reverse disk. Prefer mode auto; set allowInvalid only when the operator explicitly requests saving invalid YAML. Do not pass projectRoot — the host binds it.",
         async handler(args, ctx) {
-            const pinnedDestination = resolvePinnedSaveDestination(ctx.getContext());
-            const destination = pinnedDestination ?? resolveDestination(ctx, args);
-            if (!destination) {
+            const writeTarget = await resolveSaveWriteTarget(ctx, options);
+            if (!writeTarget.ok) {
                 return {
                     ok: false,
                     content: null,
-                    error: "destination is required — set context.destination or pass directory (do not invent a disk path)",
+                    error: writeTarget.error,
                 };
             }
-            const projectRoot = resolveProjectRoot(ctx, options.projectRoot);
-            if (!projectRoot) {
+            const { fsRoot, catalogRootKind, wireProjectRoot } = writeTarget.target;
+            const pinnedDestination = resolvePinnedSaveDestination(ctx.getContext(), fsRoot);
+            const destination = pinnedDestination ?? resolveDestination(ctx, args, catalogRootKind);
+            if (!destination) {
                 return {
                     ok: false,
                     content: null,
-                    error: "projectRoot is required — bind it on the draft context (host-owned; do not invent from tool args)",
+                    error: "destination is required — set context.destination or pass directory (do not invent a disk path)",
                 };
             }
             const draft = readDraftFromContext(ctx.getContext());
@@ -589,7 +660,9 @@ export function createSaveTool(options = {}) {
                     : {}),
                 ...(allowInvalid ? { allowInvalid: true } : {}),
             };
-            const published = await publishDraftPackage(projectRoot, input, mode);
+            const published = await publishDraftPackage(fsRoot, input, mode, {
+                catalogRootKind,
+            });
             const result = published.write;
             if (result.ok) {
                 const current = readWorkshopContext(ctx);
@@ -602,20 +675,34 @@ export function createSaveTool(options = {}) {
                             ? { pipelineFilename: destination.pipelineFilename }
                             : {}),
                     },
-                    projectRoot,
+                    projectRoot: fsRoot,
                 });
                 recordPinnedWorkshopSave(ctx.getContext(), {
                     directory: destination.directory,
                     ...(destination.pipelineFilename
                         ? { pipelineFilename: destination.pipelineFilename }
                         : {}),
-                    projectRoot,
+                    projectRoot: fsRoot,
                     draft,
+                    relativePath: result.pipelinePath,
                 });
             }
             return {
                 ok: result.ok,
-                content: result,
+                content: result.ok
+                    ? {
+                        ...result,
+                        published: {
+                            project_root: wireProjectRoot,
+                            project_root_path: fsRoot,
+                            pipeline_path: result.pipelinePath,
+                            stage_paths: result.stagePaths,
+                            ...(result.taskPath !== undefined
+                                ? { task_path: result.taskPath }
+                                : { task_path: null }),
+                        },
+                    }
+                    : result,
                 ...(result.ok ? {} : { error: result.error }),
             };
         },

package/dist/package-meta.d.ts

@@ -1,3 +1,3 @@
 export declare const PACKAGE_NAME = "stageflow";
-export declare const PACKAGE_VERSION = "0.32.0";
+export declare const PACKAGE_VERSION = "0.35.0";
 export declare const BUILD_SHA: string;

package/dist/package-meta.js

@@ -1,3 +1,3 @@
 export const PACKAGE_NAME = "stageflow";
-export const PACKAGE_VERSION = "0.32.0";
+export const PACKAGE_VERSION = "0.35.0";
 export const BUILD_SHA = process.env.STAGEFLOW_BUILD_SHA ?? "unknown";

package/dist/project/ensureProjectRootsFromEnv.d.ts

@@ -0,0 +1,3 @@
+import type { RunStore } from "../runstore/port.js";
+export declare function parseEnsureProjectRootsEnv(env: NodeJS.ProcessEnv): string[];
+export declare function ensureProjectRootsFromEnv(env: NodeJS.ProcessEnv, store: RunStore): Promise<void>;

package/dist/project/ensureProjectRootsFromEnv.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+export function parseEnsureProjectRootsEnv(env) {
+    const raw = env.STAGEFLOW_ENSURE_PROJECT_ROOTS?.trim();
+    if (!raw)
+        return [];
+    return raw
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+export async function ensureProjectRootsFromEnv(env, store) {
+    for (const entry of parseEnsureProjectRootsEnv(env)) {
+        const abs = path.resolve(entry);
+        try {
+            await store.ensureProject(abs);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.warn(`stageflow: could not register project_root ${abs}: ${message}`);
+        }
+    }
+}

package/dist/project/globalHome.d.ts

@@ -5,5 +5,6 @@ export declare class StageflowHomeError extends Error {
 }
 export declare function resetGlobalStageflowHomeForTests(): void;
 export declare function globalStageflowHome(): string;
+export declare function globalCredentialRoot(): string;
 export declare function assertStageflowHomeWritable(): void;
 export declare function ensureGlobalHome(): string;

package/dist/project/globalHome.js

@@ -10,8 +10,10 @@ export class StageflowHomeError extends Error {
     }
 }
 let memoizedHome;
+let memoizedCredentialRoot;
 export function resetGlobalStageflowHomeForTests() {
     memoizedHome = undefined;
+    memoizedCredentialRoot = undefined;
 }
 function resolveStageflowHomeFromEnv() {
     const raw = process.env.STAGEFLOW_HOME?.trim();
@@ -30,6 +32,22 @@ export function globalStageflowHome() {
     }
     return memoizedHome;
 }
+function resolveCredentialRootFromEnv() {
+    const raw = process.env.STAGEFLOW_CREDENTIAL_HOME?.trim();
+    if (raw) {
+        if (path.isAbsolute(raw)) {
+            return path.resolve(raw);
+        }
+        return path.resolve(process.cwd(), raw);
+    }
+    return path.join(os.homedir(), ".stageflow");
+}
+export function globalCredentialRoot() {
+    if (memoizedCredentialRoot === undefined) {
+        memoizedCredentialRoot = resolveCredentialRootFromEnv();
+    }
+    return memoizedCredentialRoot;
+}
 function stageflowHomeNotWritableMessage(resolvedPath) {
     const uid = process.getuid?.() ?? 0;
     const gid = process.getgid?.() ?? 0;

package/dist/project/workspaceCatalog.d.ts

@@ -0,0 +1,10 @@
+export declare const WORKSPACE_CATALOG_ID = "workspace";
+export type WorkspaceProvisionResult = {
+    path: string;
+    ok: boolean;
+    reason?: string;
+};
+export declare function resetWorkspaceProvisionForTests(): void;
+export declare function lastWorkspaceProvisionResult(): WorkspaceProvisionResult | undefined;
+export declare function workspaceCatalogPath(home?: string): string;
+export declare function ensureWorkspaceCatalog(home?: string): WorkspaceProvisionResult;

package/dist/project/workspaceCatalog.js

@@ -0,0 +1,91 @@
+import { accessSync, constants, mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { globalStageflowHome } from "./globalHome.js";
+export const WORKSPACE_CATALOG_ID = "workspace";
+let lastProvisionResult;
+export function resetWorkspaceProvisionForTests() {
+    lastProvisionResult = undefined;
+}
+export function lastWorkspaceProvisionResult() {
+    return lastProvisionResult;
+}
+export function workspaceCatalogPath(home) {
+    return path.join(home ?? globalStageflowHome(), "workspace");
+}
+function workspaceManifestYaml() {
+    return `version: 1
+catalog:
+  pipelines:
+    - .
+  tasks:
+    - .
+  triggers:
+    - .
+  patterns:
+    pipeline: "*.pipeline.yaml"
+    task: "*.task.yaml"
+    trigger: "*.trigger.yaml"
+`;
+}
+function workspaceNotWritableReason(resolvedPath) {
+    const uid = process.getuid?.() ?? 0;
+    const gid = process.getgid?.() ?? 0;
+    return `Workspace catalog is not writable (${resolvedPath}). Running as uid=${uid} gid=${gid}. Try: sudo chown -R ${uid}:${gid} ${path.dirname(resolvedPath)}`;
+}
+function isWritableDir(dir) {
+    try {
+        accessSync(dir, constants.W_OK);
+        return true;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return false;
+            try {
+                accessSync(parent, constants.W_OK);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+}
+export function ensureWorkspaceCatalog(home) {
+    const wsPath = workspaceCatalogPath(home);
+    if (!isWritableDir(wsPath)) {
+        const result = {
+            path: wsPath,
+            ok: false,
+            reason: workspaceNotWritableReason(wsPath),
+        };
+        lastProvisionResult = result;
+        return result;
+    }
+    try {
+        mkdirSync(wsPath, { recursive: true });
+        const manifestPath = path.join(wsPath, "stageflow.yaml");
+        try {
+            accessSync(manifestPath, constants.F_OK);
+        }
+        catch {
+            writeFileSync(manifestPath, workspaceManifestYaml(), "utf8");
+        }
+        const result = { path: wsPath, ok: true };
+        lastProvisionResult = result;
+        return result;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const result = {
+            path: wsPath,
+            ok: false,
+            reason: `${workspaceNotWritableReason(wsPath)} (${message})`,
+        };
+        lastProvisionResult = result;
+        return result;
+    }
+}

package/dist/projection/projectRun.d.ts

@@ -46,4 +46,3 @@ export type RunProjection = {
     total_cost_usd?: number;
 };
 export declare function projectRun(detail: RunDetail): RunProjection;
-export { projectRun as projectRunForMcp };

package/dist/projection/projectRun.js

@@ -80,4 +80,3 @@ export function projectRun(detail) {
         })),
     };
 }
-export { projectRun as projectRunForMcp };

package/dist/runstore/backup.js

@@ -8,7 +8,8 @@ import { pipeline } from "node:stream/promises";
 import { createWriteStream } from "node:fs";
 import Database from "better-sqlite3";
 import { PACKAGE_VERSION } from "../package-meta.js";
-import { globalStageflowHome } from "../project/globalHome.js";
+import { globalCredentialRoot, globalStageflowHome } from "../project/globalHome.js";
+import { isUsableAuthFile } from "../runtime/credentialBinding.js";
 import { readFilesystemSize } from "./diskUsage.js";
 import { isInsideDir } from "./workspaceLayout.js";
 export class BackupError extends Error {
@@ -45,6 +46,14 @@ export function assertBackupOutPathAllowed(outPath, homeDir = globalStageflowHom
     }
     return resolved;
 }
+function isCredentialRootDir(dir) {
+    return path.resolve(dir) === path.resolve(globalCredentialRoot());
+}
+function packAuthMember(homeDir, authPath, noCredentials) {
+    return (!noCredentials &&
+        isCredentialRootDir(homeDir) &&
+        isUsableAuthFile(authPath));
+}
 function fingerprint(filePath) {
     if (!existsSync(filePath))
         return null;
@@ -203,7 +212,8 @@ export async function createBackup(options) {
             });
             contents.push("settings.json");
         }
-        if (!noCredentials && existsSync(authPath)) {
+        const includeAuth = packAuthMember(homeDir, authPath, noCredentials);
+        if (includeAuth) {
             const stagedAuth = path.join(staging, "auth.json");
             copyFileSync(authPath, stagedAuth);
             chmodSync(stagedAuth, 0o600);
@@ -226,14 +236,14 @@ export async function createBackup(options) {
             schema_version: userVersion,
             contents,
             db_only: false,
-            credentials_included: !noCredentials && existsSync(authPath),
+            credentials_included: includeAuth,
             a2a_artifacts_included: includeA2a,
             settings_fingerprint_before: settingsBefore,
             settings_fingerprint_after: settingsAfter,
             auth_fingerprint_before: authBefore,
             auth_fingerprint_after: authAfter,
             fingerprint_skew: fingerprintSkew,
-            secret_warning: SECRET_WARNING,
+            secret_warning: includeAuth ? SECRET_WARNING : "",
         };
         const manifestPath = path.join(staging, "manifest.json");
         writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, {

package/dist/runstore/port.d.ts

@@ -99,6 +99,7 @@ export type StageSnapshot = {
     attempt_count: number;
     /** Total $ spent on this stage across every attempt; omitted when no attempt reported usage. */
     cost_usd?: number;
+    usage?: StageUsage;
 };
 export type StageExecution = {
     run_id: string;
@@ -470,12 +471,21 @@ export interface RunStore {
     upsertTrigger(input: UpsertTriggerInput): Promise<TriggerRecord>;
     getTrigger(id: string): Promise<TriggerRecord | null>;
     listTriggers(): Promise<TriggerRecord[]>;
-    /** Record a fire: stamps last_fired_at/last_run_id. Throws if the trigger is missing. */
+    /** Record a fire: stamps last_fired_at/last_run_id and appends trigger_fires. Throws if the trigger is missing. */
     recordTriggerFired(id: string, runId: string): Promise<void>;
+    /** Newest first. */
+    listTriggerFires(triggerId: string, limit: number): Promise<Array<{
+        fired_at: string;
+        run_id: string;
+    }>>;
     /** Persist the next computed fire time for a schedule-kind trigger. Throws if the trigger is missing. */
     setTriggerNextRun(id: string, nextRunAt: string): Promise<void>;
     /** Read a single adapter-owned state value for a trigger, or null if unset. */
     getTriggerAdapterState(triggerId: string, key: string): Promise<string | null>;
+    getTriggerAdapterStateMeta(triggerId: string, key: string): Promise<{
+        value: string;
+        updated_at: string;
+    } | null>;
     /** Upsert a single adapter-owned state value for a trigger. */
     setTriggerAdapterState(triggerId: string, key: string, value: string): Promise<void>;
     readRun(runId: string): Promise<RunDetail>;

package/dist/runstore/restore.js

@@ -7,7 +7,8 @@ import { pipeline } from "node:stream/promises";
 import { createWriteStream } from "node:fs";
 import Database from "better-sqlite3";
 import { PACKAGE_VERSION } from "../package-meta.js";
-import { globalStageflowHome } from "../project/globalHome.js";
+import { globalCredentialRoot, globalStageflowHome } from "../project/globalHome.js";
+import { isUsableAuthFile } from "../runtime/credentialBinding.js";
 import { CURRENT_SCHEMA_VERSION } from "./sqlite/migrations/index.js";
 import { StoreSchemaError } from "./sqlite/storeSchemaError.js";
 import { assertStoreQuickCheck } from "./sqlite/applyStorePragmas.js";
@@ -234,7 +235,9 @@ export async function applyRestoreArchive(options) {
                 if (existsSync(settingsSrc)) {
                     copyFileSync(settingsSrc, path.join(homeDir, "settings.json"));
                 }
-                if (existsSync(authSrc)) {
+                const restoreAuth = path.resolve(homeDir) === path.resolve(globalCredentialRoot()) &&
+                    isUsableAuthFile(authSrc);
+                if (restoreAuth) {
                     const agentDir = path.join(homeDir, "agent");
                     mkdirSync(agentDir, { recursive: true });
                     try {

package/dist/runstore/sqlite/SqliteRunStore.d.ts

@@ -82,8 +82,16 @@ export declare class SqliteRunStore implements RunStore {
     getTrigger(id: string): Promise<TriggerRecord | null>;
     listTriggers(): Promise<TriggerRecord[]>;
     recordTriggerFired(id: string, runId: string): Promise<void>;
+    listTriggerFires(triggerId: string, limit: number): Promise<Array<{
+        fired_at: string;
+        run_id: string;
+    }>>;
     setTriggerNextRun(id: string, nextRunAt: string): Promise<void>;
     getTriggerAdapterState(triggerId: string, key: string): Promise<string | null>;
+    getTriggerAdapterStateMeta(triggerId: string, key: string): Promise<{
+        value: string;
+        updated_at: string;
+    } | null>;
     setTriggerAdapterState(triggerId: string, key: string, value: string): Promise<void>;
     readRun(runId: string): Promise<RunDetail>;
     createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;

package/dist/runstore/sqlite/SqliteRunStore.js

@@ -942,13 +942,29 @@ export class SqliteRunStore {
     async recordTriggerFired(id, runId) {
         await this.ready();
         const now = new Date().toISOString();
-        const result = this.db
-            .prepare(`UPDATE triggers SET last_fired_at = @last_fired_at, last_run_id = @last_run_id, updated_at = @updated_at
-         WHERE id = @id`)
-            .run({ id, last_fired_at: now, last_run_id: runId, updated_at: now });
-        if (result.changes === 0) {
-            throw new Error(`Trigger not found: ${id}`);
-        }
+        const apply = this.db.transaction(() => {
+            const result = this.db
+                .prepare(`UPDATE triggers SET last_fired_at = @last_fired_at, last_run_id = @last_run_id, updated_at = @updated_at
+           WHERE id = @id`)
+                .run({ id, last_fired_at: now, last_run_id: runId, updated_at: now });
+            if (result.changes === 0) {
+                throw new Error(`Trigger not found: ${id}`);
+            }
+            this.db
+                .prepare(`INSERT INTO trigger_fires (trigger_id, run_id, fired_at)
+           VALUES (@trigger_id, @run_id, @fired_at)`)
+                .run({ trigger_id: id, run_id: runId, fired_at: now });
+        });
+        apply();
+    }
+    async listTriggerFires(triggerId, limit) {
+        await this.ready();
+        return this.db
+            .prepare(`SELECT fired_at, run_id FROM trigger_fires
+         WHERE trigger_id = ?
+         ORDER BY fired_at DESC, id DESC
+         LIMIT ?`)
+            .all(triggerId, limit);
     }
     async setTriggerNextRun(id, nextRunAt) {
         await this.ready();
@@ -962,11 +978,15 @@ export class SqliteRunStore {
         }
     }
     async getTriggerAdapterState(triggerId, key) {
+        const row = await this.getTriggerAdapterStateMeta(triggerId, key);
+        return row?.value ?? null;
+    }
+    async getTriggerAdapterStateMeta(triggerId, key) {
         await this.ready();
         const row = this.db
-            .prepare(`SELECT value FROM trigger_adapter_state WHERE trigger_id = ? AND key = ?`)
+            .prepare(`SELECT value, updated_at FROM trigger_adapter_state WHERE trigger_id = ? AND key = ?`)
             .get(triggerId, key);
-        return row ? row.value : null;
+        return row ?? null;
     }
     async setTriggerAdapterState(triggerId, key, value) {
         await this.ready();

package/dist/runstore/sqlite/migrations/012-trigger-fires.d.ts

@@ -0,0 +1,7 @@
+import type Database from "better-sqlite3";
+export declare const MIGRATION_012: {
+    version: number;
+    name: string;
+    minStageflowVersion: string;
+    up(db: Database.Database): void;
+};

package/dist/runstore/sqlite/migrations/012-trigger-fires.js

@@ -0,0 +1,18 @@
+import { PACKAGE_VERSION } from "../../../package-meta.js";
+export const MIGRATION_012 = {
+    version: 12,
+    name: "012_trigger_fires",
+    minStageflowVersion: PACKAGE_VERSION,
+    up(db) {
+        db.exec(`
+CREATE TABLE IF NOT EXISTS trigger_fires (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  trigger_id TEXT NOT NULL,
+  run_id TEXT NOT NULL,
+  fired_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS trigger_fires_trigger_fired
+  ON trigger_fires (trigger_id, fired_at DESC);
+`);
+    },
+};

package/dist/runstore/sqlite/migrations/index.js

@@ -10,6 +10,7 @@ import { MIGRATION_008 } from "./008-triggers-table.js";
 import { MIGRATION_009 } from "./009-trigger-next-run.js";
 import { MIGRATION_010 } from "./010-trigger-adapter-state.js";
 import { MIGRATION_011 } from "./011-email-dispatch-key.js";
+import { MIGRATION_012 } from "./012-trigger-fires.js";
 const DEFAULT_MIGRATIONS = [
     MIGRATION_001,
     MIGRATION_002,
@@ -22,6 +23,7 @@ const DEFAULT_MIGRATIONS = [
     MIGRATION_009,
     MIGRATION_010,
     MIGRATION_011,
+    MIGRATION_012,
 ];
 export const CURRENT_SCHEMA_VERSION = DEFAULT_MIGRATIONS[DEFAULT_MIGRATIONS.length - 1].version;
 function throwStoreSchemaTooNew(db, version, maxKnown) {

package/dist/runstore/stageSnapshot.d.ts

@@ -1,2 +1,4 @@
-import type { RunStore, StageSnapshot } from "./port.js";
+import { type StageUsage } from "../types/usage.js";
+import type { RunStore, StageExecution, StageSnapshot } from "./port.js";
 export declare function buildStageSnapshotFromStore(store: RunStore, runId: string, stageId: string, workspaceDir: string): Promise<StageSnapshot>;
+export declare function mergeStageExecutionUsage(executions: StageExecution[]): StageUsage | undefined;