stageflow 0.27.0 → 0.31.0

package/dist/operatorAgent/proposals.js

@@ -0,0 +1,144 @@
+import { readDraftFromContext } from "./draftContext.js";
+const UNDO_CONFLICT_NOTICE = "Undo blocked: the draft changed after this mutation. Ask the agent to reverse the change instead of rejecting.";
+export function draftFingerprint(draft) {
+    return JSON.stringify(draft);
+}
+export function formatArtifact(value) {
+    return JSON.stringify(value, null, 2);
+}
+function stageIds(draft) {
+    return draft.pipeline.stages.map((stage, index) => typeof stage.id === "string" && stage.id ? stage.id : `stage-${index}`);
+}
+export function diffDraftPackages(before, after) {
+    const diffs = [];
+    const pipelinePath = `${after.pipeline.id || before.pipeline.id || "pipeline"}.pipeline.yaml`;
+    if (JSON.stringify(before.pipeline) !== JSON.stringify(after.pipeline)) {
+        diffs.push({
+            path: pipelinePath,
+            kind: "modified",
+            before: formatArtifact(before.pipeline),
+            after: formatArtifact(after.pipeline),
+        });
+    }
+    const beforeStages = new Map((before.stages ?? []).map((s) => [s.path, s]));
+    const afterStages = new Map((after.stages ?? []).map((s) => [s.path, s]));
+    for (const [path, art] of afterStages) {
+        const prev = beforeStages.get(path);
+        if (!prev) {
+            diffs.push({
+                path,
+                kind: "added",
+                after: formatArtifact(art.body),
+            });
+        }
+        else if (JSON.stringify(prev.body) !== JSON.stringify(art.body)) {
+            diffs.push({
+                path,
+                kind: "modified",
+                before: formatArtifact(prev.body),
+                after: formatArtifact(art.body),
+            });
+        }
+    }
+    for (const [path, art] of beforeStages) {
+        if (!afterStages.has(path)) {
+            diffs.push({
+                path,
+                kind: "removed",
+                before: formatArtifact(art.body),
+            });
+        }
+    }
+    const beforeTask = before.task
+        ? formatArtifact({ filename: before.task.filename, body: before.task.body })
+        : null;
+    const afterTask = after.task
+        ? formatArtifact({ filename: after.task.filename, body: after.task.body })
+        : null;
+    if (beforeTask !== afterTask) {
+        const path = after.task?.filename ?? before.task?.filename ?? "task.task.yaml";
+        if (!beforeTask && afterTask) {
+            diffs.push({ path, kind: "added", after: afterTask });
+        }
+        else if (beforeTask && !afterTask) {
+            diffs.push({ path, kind: "removed", before: beforeTask });
+        }
+        else {
+            diffs.push({
+                path,
+                kind: "modified",
+                before: beforeTask ?? undefined,
+                after: afterTask ?? undefined,
+            });
+        }
+    }
+    return diffs;
+}
+export function affectedStageIds(before, after) {
+    const beforeSet = new Set(stageIds(before));
+    const afterSet = new Set(stageIds(after));
+    const ids = new Set();
+    for (const id of afterSet) {
+        if (!beforeSet.has(id))
+            ids.add(id);
+    }
+    for (const id of beforeSet) {
+        if (!afterSet.has(id))
+            ids.add(id);
+    }
+    const beforeByPath = new Map((before.stages ?? []).map((s) => [s.path, s]));
+    for (const art of after.stages ?? []) {
+        const prev = beforeByPath.get(art.path);
+        if (!prev || JSON.stringify(prev.body) !== JSON.stringify(art.body)) {
+            const id = typeof art.body.id === "string" && art.body.id
+                ? art.body.id
+                : undefined;
+            if (id)
+                ids.add(id);
+        }
+    }
+    for (const art of before.stages ?? []) {
+        if (!(after.stages ?? []).some((s) => s.path === art.path)) {
+            const id = typeof art.body.id === "string" && art.body.id
+                ? art.body.id
+                : undefined;
+            if (id)
+                ids.add(id);
+        }
+    }
+    for (let i = 0; i < after.pipeline.stages.length; i += 1) {
+        const a = after.pipeline.stages[i];
+        const b = before.pipeline.stages[i];
+        const id = typeof a.id === "string" && a.id ? a.id : `stage-${i}`;
+        if (!b || JSON.stringify(a) !== JSON.stringify(b)) {
+            ids.add(id);
+        }
+    }
+    return [...ids];
+}
+export function enrichProposal(proposal, currentContext) {
+    const baseDraft = readDraftFromContext(proposal.baseContext ?? currentContext);
+    const nextDraft = readDraftFromContext(proposal.nextContext);
+    const baseContext = proposal.baseContext ??
+        { draft: baseDraft };
+    return {
+        ...proposal,
+        baseContext,
+        baseFingerprint: proposal.baseFingerprint ?? draftFingerprint(baseDraft),
+        appliedFingerprint: proposal.appliedFingerprint ?? draftFingerprint(nextDraft),
+        artifacts: proposal.artifacts ?? diffDraftPackages(baseDraft, nextDraft),
+        affectedStageIds: proposal.affectedStageIds ?? affectedStageIds(baseDraft, nextDraft),
+    };
+}
+/** True when the live draft no longer matches the post-apply fingerprint. */
+export function isMutationConflict(mutation, currentContext) {
+    const current = draftFingerprint(readDraftFromContext(currentContext));
+    if (mutation.appliedFingerprint) {
+        return mutation.appliedFingerprint !== current;
+    }
+    const next = draftFingerprint(readDraftFromContext(mutation.nextContext));
+    return next !== current;
+}
+export const UNDO_MUTATION_CONFLICT_NOTICE = UNDO_CONFLICT_NOTICE;
+/** @deprecated Prefer UNDO_MUTATION_CONFLICT_NOTICE — kept for callers mid-migration. */
+export const STALE_PROPOSAL_NOTICE = UNDO_CONFLICT_NOTICE;

package/dist/operatorAgent/types.d.ts

@@ -0,0 +1,128 @@
+import type { DraftPackage } from "../config/draftPackage.js";
+import type { ValidationResult } from "../config/validateCatalog.js";
+import type { AcceptProposalResult, ProposalArtifactDiff, UndoMutationResult } from "./proposals.js";
+export type OperatorAgentToolResult = {
+    ok: boolean;
+    content: unknown;
+    error?: string;
+};
+export type OperatorAgentToolHandler = (args: Record<string, unknown>, ctx: OperatorAgentToolContext) => Promise<OperatorAgentToolResult> | OperatorAgentToolResult;
+export type OperatorAgentTool = {
+    name: string;
+    description: string;
+    handler: OperatorAgentToolHandler;
+};
+export type OperatorAgentToolContext = {
+    getContext(): unknown;
+    setContext(next: unknown): void;
+    /** Apply mutation immediately and record an undo receipt. */
+    emitProposal(proposal: OperatorAgentProposal): void;
+};
+export type OperatorAgentProposal = {
+    /** Mutation id (Accept confirms; Reject / undoMutation soft-undos). */
+    id: string;
+    summary: string;
+    /** Context after the mutation (already applied to the session). */
+    nextContext: unknown;
+    /** Context snapshot before the mutation (restore target for undo). */
+    baseContext?: unknown;
+    /** Fingerprint of the draft before apply. */
+    baseFingerprint?: string;
+    /** Fingerprint of the draft immediately after apply — undo requires a match. */
+    appliedFingerprint?: string;
+    artifacts?: ProposalArtifactDiff[];
+    affectedStageIds?: string[];
+};
+export type OperatorAgentContextAdapter = {
+    serialize(context: unknown): unknown;
+    applyProposal(context: unknown, proposal: OperatorAgentProposal): unknown;
+};
+export type OperatorAgentProfile = {
+    id: string;
+    title: string;
+    playbook: string;
+    tools: OperatorAgentTool[];
+    contextAdapter: OperatorAgentContextAdapter;
+    greeting?: string;
+};
+export type OperatorAgentSessionEvent = {
+    type: "message";
+    role: "assistant" | "user" | "system";
+    text: string;
+} | {
+    type: "proposal";
+    proposal: OperatorAgentProposal;
+} | {
+    type: "tool_result";
+    name: string;
+    result: OperatorAgentToolResult;
+} | {
+    type: "validation";
+    result: ValidationResult;
+} | {
+    type: "error";
+    message: string;
+};
+export type WorkshopToolActivityUpdate = {
+    id: string;
+    name: string;
+    status: "running" | "complete" | "error";
+    target?: string;
+    errorMessage?: string;
+    draft?: DraftPackage;
+    /** Build the turn is editing. Absent when the chat is unlinked. */
+    buildId?: string;
+};
+export type OperatorAgentSession = {
+    readonly profileId: string;
+    readonly profileTitle: string;
+    getContext(): unknown;
+    setContext(next: unknown): void;
+    /** Latest undoable mutation (Accept-card payload), or null. */
+    getPendingProposal(): OperatorAgentProposal | null;
+    getMutation(mutationId: string): OperatorAgentProposal | null;
+    /**
+     * Seed backend from prior transcript after process restart (KTD7).
+     * No-op for fake / models without prepareRestart.
+     */
+    prepareRestart?(transcript: readonly {
+        role: string;
+        text: string;
+    }[]): Promise<void>;
+    send(message: string, options?: {
+        onDelta?: (text: string) => void;
+        onActivity?: (update: WorkshopToolActivityUpdate) => void;
+        modelId?: string;
+    }): Promise<OperatorAgentSessionEvent[]>;
+    /** Interrupt the in-flight prompt. Resolves when the backend is idle. */
+    abort(): Promise<void>;
+    /** Confirm mutation (soft UX); draft already applied — does not re-apply. */
+    acceptProposal(proposalId?: string): AcceptProposalResult;
+    /** Soft-undo the mutation when the applied fingerprint still matches. */
+    rejectProposal(proposalId?: string): UndoMutationResult;
+    undoMutation(mutationId?: string): UndoMutationResult;
+    close(): void;
+};
+export type OperatorAgentHost = {
+    registerProfile(profile: OperatorAgentProfile): void;
+    getProfile(id: string): OperatorAgentProfile | undefined;
+    listProfiles(): OperatorAgentProfile[];
+    openSession(input: {
+        profileId: string;
+        context: unknown;
+    }): OperatorAgentSession;
+};
+export type WorkshopDraftContext = {
+    draft: DraftPackage;
+    destination?: {
+        directory: string;
+        pipelineFilename?: string;
+    };
+    /** Catalog write root for the save tool (usually the operator project). */
+    projectRoot?: string;
+    /** Workshop chat session that owns this host context. */
+    chatSessionId?: string;
+    /** Build this turn is editing. Absent when that chat is unlinked. */
+    buildId?: string;
+};
+export type { AcceptProposalResult, ProposalArtifactDiff, UndoMutationResult };

package/dist/operatorAgent/types.js

@@ -0,0 +1 @@
+export {};

package/dist/package-meta.d.ts

@@ -1,3 +1,3 @@
 export declare const PACKAGE_NAME = "stageflow";
-export declare const PACKAGE_VERSION = "0.27.0";
+export declare const PACKAGE_VERSION = "0.31.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.27.0";
+export const PACKAGE_VERSION = "0.31.0";
 export const BUILD_SHA = process.env.STAGEFLOW_BUILD_SHA ?? "unknown";

package/dist/project/findManifestRoot.d.ts

@@ -0,0 +1,3 @@
+/** Walk up from `startDir` for the nearest `stageflow.yaml`, independent of git. */
+export declare function findManifestRoot(startDir: string): string | null;
+export declare function clearFindManifestRootCacheForTests(): void;

package/dist/project/findManifestRoot.js

@@ -0,0 +1,35 @@
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+const cache = new Map();
+function normalizeRoot(dir) {
+    try {
+        return realpathSync(path.resolve(dir));
+    }
+    catch {
+        return path.resolve(dir);
+    }
+}
+/** Walk up from `startDir` for the nearest `stageflow.yaml`, independent of git. */
+export function findManifestRoot(startDir) {
+    const normalized = path.resolve(startDir);
+    if (cache.has(normalized)) {
+        return cache.get(normalized) ?? null;
+    }
+    let dir = normalized;
+    let result = null;
+    for (;;) {
+        if (existsSync(path.join(dir, "stageflow.yaml"))) {
+            result = normalizeRoot(dir);
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    cache.set(normalized, result);
+    return result;
+}
+export function clearFindManifestRootCacheForTests() {
+    cache.clear();
+}

package/dist/project/resolveStageflowContext.d.ts

@@ -8,4 +8,11 @@ export type StageflowContext = ProjectContext & {
     manifestIssues: LoadIssue[];
 };
 export declare function projectContextFromStageflow(ctx: StageflowContext): ProjectContext;
+/**
+ * Project root resolution is keyed off the nearest `stageflow.yaml`, not git:
+ * a manifest defines a project on its own, the same way a `package.json`
+ * does for npm. Git is checked independently (`isGitProject`) for callers
+ * that need it for execution (checkout/worktrees), not as a precondition
+ * for finding or reading the catalog.
+ */
 export declare function resolveStageflowContext(invocationCwd: string): Promise<StageflowContext>;

package/dist/project/resolveStageflowContext.js

@@ -2,6 +2,7 @@ import { access } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { loadStageflowManifestOutcome, manifestPathForProject, } from "../config/loadStageflowManifest.js";
+import { findManifestRoot } from "./findManifestRoot.js";
 import { findProjectRoot } from "./findProjectRoot.js";
 import { globalStageflowHome } from "./globalHome.js";
 export function projectContextFromStageflow(ctx) {
@@ -12,55 +13,70 @@ export function projectContextFromStageflow(ctx) {
         isGitProject: ctx.isGitProject,
     };
 }
+/**
+ * Project root resolution is keyed off the nearest `stageflow.yaml`, not git:
+ * a manifest defines a project on its own, the same way a `package.json`
+ * does for npm. Git is checked independently (`isGitProject`) for callers
+ * that need it for execution (checkout/worktrees), not as a precondition
+ * for finding or reading the catalog.
+ */
 export async function resolveStageflowContext(invocationCwd) {
     const resolvedInvocation = path.resolve(invocationCwd);
-    const gitRoot = findProjectRoot(resolvedInvocation);
     const globalHome = globalStageflowHome();
-    if (gitRoot === null) {
+    const manifestRoot = findManifestRoot(resolvedInvocation);
+    if (manifestRoot !== null) {
+        const isGitProject = findProjectRoot(manifestRoot) !== null;
+        const manifestPath = manifestPathForProject(manifestRoot);
+        try {
+            await access(manifestPath);
+        }
+        catch {
+            return resolveWithoutManifest(resolvedInvocation, globalHome);
+        }
+        const outcome = await loadStageflowManifestOutcome(manifestRoot);
+        if (!outcome.ok) {
+            return {
+                invocationCwd: resolvedInvocation,
+                projectRoot: manifestRoot,
+                globalHome,
+                isGitProject,
+                manifest: null,
+                manifestStatus: "invalid",
+                manifestIssues: outcome.issues,
+            };
+        }
         return {
             invocationCwd: resolvedInvocation,
-            projectRoot: os.homedir(),
+            projectRoot: manifestRoot,
             globalHome,
-            isGitProject: false,
-            manifest: null,
-            manifestStatus: "not_git",
+            isGitProject,
+            manifest: outcome.value,
+            manifestStatus: "ok",
             manifestIssues: [],
         };
     }
-    const manifestPath = manifestPathForProject(gitRoot);
-    try {
-        await access(manifestPath);
-    }
-    catch {
+    return resolveWithoutManifest(resolvedInvocation, globalHome);
+}
+function resolveWithoutManifest(resolvedInvocation, globalHome) {
+    const gitRoot = findProjectRoot(resolvedInvocation);
+    if (gitRoot === null) {
         return {
             invocationCwd: resolvedInvocation,
-            projectRoot: gitRoot,
+            projectRoot: os.homedir(),
             globalHome,
-            isGitProject: true,
+            isGitProject: false,
             manifest: null,
-            manifestStatus: "missing",
+            manifestStatus: "not_git",
             manifestIssues: [],
         };
     }
-    const outcome = await loadStageflowManifestOutcome(gitRoot);
-    if (!outcome.ok) {
-        return {
-            invocationCwd: resolvedInvocation,
-            projectRoot: gitRoot,
-            globalHome,
-            isGitProject: true,
-            manifest: null,
-            manifestStatus: "invalid",
-            manifestIssues: outcome.issues,
-        };
-    }
     return {
         invocationCwd: resolvedInvocation,
         projectRoot: gitRoot,
         globalHome,
         isGitProject: true,
-        manifest: outcome.value,
-        manifestStatus: "ok",
+        manifest: null,
+        manifestStatus: "missing",
         manifestIssues: [],
     };
 }

package/dist/runstore/assertTmpdir.js

@@ -1,9 +1,13 @@
 import { accessSync, constants, mkdirSync } from "node:fs";
+import path from "node:path";
+import { globalStageflowHome } from "../project/globalHome.js";
 import { StoreOpenError } from "./sqlite/storeOpenError.js";
 export function assertTmpdirUsable(env = process.env) {
-    const raw = env.TMPDIR ?? env.TMP ?? env.TEMP;
+    let raw = env.TMPDIR ?? env.TMP ?? env.TEMP;
     if (raw === undefined || raw.trim() === "") {
-        throw new StoreOpenError("tmpdir_unusable: TMPDIR is unset. Set TMPDIR to a writable path (supported writable set: $STAGEFLOW_HOME and TMPDIR).", "tmpdir_unusable");
+        const soft = path.join(globalStageflowHome(), "tmp");
+        process.env.TMPDIR = soft;
+        raw = soft;
     }
     const dir = raw.trim();
     try {

package/dist/runstore/diskUsage.d.ts

@@ -32,7 +32,7 @@ export declare function durableRootDiskBreakdown(durableRoot: string, options?:
 export declare function parseDiskBytesThreshold(raw: string | undefined, filesystemTotalBytes: number): number | undefined;
 /**
  * Resolve `STAGEFLOW_MIN_FREE_DISK_BYTES`: bytes or `%` of filesystem.
- * Unset / empty / invalid → `max(2 GiB, 10% of filesystemTotalBytes)`.
+ * Unset / empty / invalid → `0` (admission check disabled). Set explicitly to enable.
  */
 export declare function resolveMinFreeDiskFloor(raw: string | undefined, filesystemTotalBytes: number): number;
 /**

package/dist/runstore/diskUsage.js

@@ -162,20 +162,15 @@ export function parseDiskBytesThreshold(raw, filesystemTotalBytes) {
         return undefined;
     return n;
 }
-const DEFAULT_MIN_FREE_DISK_BYTES = 2 * 1024 * 1024 * 1024;
 /**
  * Resolve `STAGEFLOW_MIN_FREE_DISK_BYTES`: bytes or `%` of filesystem.
- * Unset / empty / invalid → `max(2 GiB, 10% of filesystemTotalBytes)`.
+ * Unset / empty / invalid → `0` (admission check disabled). Set explicitly to enable.
  */
 export function resolveMinFreeDiskFloor(raw, filesystemTotalBytes) {
     const parsed = parseDiskBytesThreshold(raw, filesystemTotalBytes);
     if (parsed !== undefined)
         return parsed;
-    const total = Number.isFinite(filesystemTotalBytes) && filesystemTotalBytes > 0
-        ? filesystemTotalBytes
-        : 0;
-    const tenPercent = Math.floor(total * 0.1);
-    return Math.max(DEFAULT_MIN_FREE_DISK_BYTES, tenPercent);
+    return 0;
 }
 /**
  * One named warning when free space is below `STAGEFLOW_DISK_WARN_BYTES`. Never throws.

package/dist/runstore/port.d.ts

@@ -248,6 +248,22 @@ export type CreateForkGenerationInput = Omit<ForkGenerationRecord, "run_id" | "s
     status?: ForkGenerationStatus;
 };
 export type ForkGenerationPatch = Partial<Pick<ForkGenerationRecord, "status">>;
+/** Durable registration of a catalog-owned `*.trigger.yaml` definition. */
+export type TriggerRecord = {
+    id: string;
+    definition_ref: string;
+    enabled: boolean;
+    last_fired_at?: string;
+    last_run_id?: string;
+    next_run_at?: string;
+    created_at: string;
+    updated_at: string;
+};
+export type UpsertTriggerInput = {
+    id: string;
+    definitionRef: string;
+    enabled: boolean;
+};
 export type CompactStage = {
     id: string;
     status: StageSnapshot["status"];
@@ -446,6 +462,18 @@ export interface RunStore {
     ensureProject(absPath: string): Promise<string>;
     /** Absolute roots from the durable projects registry. */
     listRegisteredProjects(): Promise<string[]>;
+    /** Idempotent create-or-update of a trigger's catalog registration. */
+    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. */
+    recordTriggerFired(id: string, runId: string): Promise<void>;
+    /** 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>;
+    /** Upsert a single adapter-owned state value for a trigger. */
+    setTriggerAdapterState(triggerId: string, key: string, value: string): Promise<void>;
     readRun(runId: string): Promise<RunDetail>;
     updatePipelineDag(runId: string, dag: RunPipelineDagSnapshot): Promise<void>;
     createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;

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

@@ -1,7 +1,7 @@
 import Database from "better-sqlite3";
 import type { StageEnvelope } from "../../types/envelope.js";
 import type { StageLogLine } from "../../agent/activity.js";
-import { type CreateFeedbackLoopInput, type CreateFeedbackReplayInput, type CreateFeedbackReplayStagePassInput, type CreateForkGenerationInput, type CreateRunInput, type CreatedRun, type FeedbackLoopPatch, type FeedbackLoopRecord, type FeedbackLoopState, type FeedbackReplayPatch, type FeedbackReplayRecord, type FeedbackReplayStagePassPatch, type FeedbackReplayStagePassRecord, type ForkGenerationPatch, type ForkGenerationRecord, type ListRunsFilter, type RunDetail, type RunMeta, type RunPipelineDagSnapshot, type RunStatus, type RunStore, type RunSummary, type StageExecution, type StageExecutionPatch, type StageLogEvent, type VerificationCheckResult, type VerificationCheckResultPatch, type ConfigOriginRecord } from "../port.js";
+import { type CreateFeedbackLoopInput, type CreateFeedbackReplayInput, type CreateFeedbackReplayStagePassInput, type CreateForkGenerationInput, type CreateRunInput, type CreatedRun, type FeedbackLoopPatch, type FeedbackLoopRecord, type FeedbackLoopState, type FeedbackReplayPatch, type FeedbackReplayRecord, type FeedbackReplayStagePassPatch, type FeedbackReplayStagePassRecord, type ForkGenerationPatch, type ForkGenerationRecord, type ListRunsFilter, type RunDetail, type RunMeta, type RunPipelineDagSnapshot, type RunStatus, type RunStore, type RunSummary, type StageExecution, type StageExecutionPatch, type StageLogEvent, type TriggerRecord, type UpsertTriggerInput, type VerificationCheckResult, type VerificationCheckResultPatch, type ConfigOriginRecord } from "../port.js";
 import { type RunSubmissionRecord } from "../submission.js";
 type SqliteRunStoreOpenerMode = "assert" | "migrate";
 export declare class SqliteRunStore implements RunStore {
@@ -77,6 +77,13 @@ export declare class SqliteRunStore implements RunStore {
     listRuns(filter?: ListRunsFilter): Promise<RunSummary[]>;
     ensureProject(absPath: string): Promise<string>;
     listRegisteredProjects(): Promise<string[]>;
+    upsertTrigger(input: UpsertTriggerInput): Promise<TriggerRecord>;
+    getTrigger(id: string): Promise<TriggerRecord | null>;
+    listTriggers(): Promise<TriggerRecord[]>;
+    recordTriggerFired(id: string, runId: string): Promise<void>;
+    setTriggerNextRun(id: string, nextRunAt: string): Promise<void>;
+    getTriggerAdapterState(triggerId: string, key: string): Promise<string | null>;
+    setTriggerAdapterState(triggerId: string, key: string, value: string): Promise<void>;
     readRun(runId: string): Promise<RunDetail>;
     createFeedbackLoop(runId: string, input: CreateFeedbackLoopInput): Promise<FeedbackLoopRecord>;
     getFeedbackLoop(runId: string, loopId: string): Promise<FeedbackLoopRecord>;

package/dist/runstore/sqlite/SqliteRunStore.js

@@ -72,6 +72,18 @@ function feedbackLoopFromRow(row) {
         updated_at: row.updated_at,
     };
 }
+function triggerFromRow(row) {
+    return {
+        id: row.id,
+        definition_ref: row.definition_ref,
+        enabled: row.enabled !== 0,
+        ...(row.last_fired_at != null ? { last_fired_at: row.last_fired_at } : {}),
+        ...(row.last_run_id != null ? { last_run_id: row.last_run_id } : {}),
+        ...(row.next_run_at != null ? { next_run_at: row.next_run_at } : {}),
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
 function feedbackReplayFromRow(row) {
     return {
         run_id: row.run_id,
@@ -870,6 +882,84 @@ export class SqliteRunStore {
             .all();
         return rows.map((row) => row.project_root);
     }
+    async upsertTrigger(input) {
+        await this.ready();
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT INTO triggers (id, definition_ref, enabled, created_at, updated_at)
+         VALUES (@id, @definition_ref, @enabled, @created_at, @updated_at)
+         ON CONFLICT(id) DO UPDATE SET
+           definition_ref = @definition_ref,
+           enabled = @enabled,
+           updated_at = @updated_at`)
+            .run({
+            id: input.id,
+            definition_ref: input.definitionRef,
+            enabled: input.enabled ? 1 : 0,
+            created_at: now,
+            updated_at: now,
+        });
+        const record = await this.getTrigger(input.id);
+        if (!record)
+            throw new Error(`Trigger not found after upsert: ${input.id}`);
+        return record;
+    }
+    async getTrigger(id) {
+        await this.ready();
+        const row = this.db
+            .prepare(`SELECT id, definition_ref, enabled, last_fired_at, last_run_id, next_run_at, created_at, updated_at
+         FROM triggers WHERE id = ?`)
+            .get(id);
+        return row ? triggerFromRow(row) : null;
+    }
+    async listTriggers() {
+        await this.ready();
+        const rows = this.db
+            .prepare(`SELECT id, definition_ref, enabled, last_fired_at, last_run_id, next_run_at, created_at, updated_at
+         FROM triggers ORDER BY id`)
+            .all();
+        return rows.map(triggerFromRow);
+    }
+    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}`);
+        }
+    }
+    async setTriggerNextRun(id, nextRunAt) {
+        await this.ready();
+        const now = new Date().toISOString();
+        const result = this.db
+            .prepare(`UPDATE triggers SET next_run_at = @next_run_at, updated_at = @updated_at
+         WHERE id = @id`)
+            .run({ id, next_run_at: nextRunAt, updated_at: now });
+        if (result.changes === 0) {
+            throw new Error(`Trigger not found: ${id}`);
+        }
+    }
+    async getTriggerAdapterState(triggerId, key) {
+        await this.ready();
+        const row = this.db
+            .prepare(`SELECT value FROM trigger_adapter_state WHERE trigger_id = ? AND key = ?`)
+            .get(triggerId, key);
+        return row ? row.value : null;
+    }
+    async setTriggerAdapterState(triggerId, key, value) {
+        await this.ready();
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT INTO trigger_adapter_state (trigger_id, key, value, updated_at)
+         VALUES (@trigger_id, @key, @value, @updated_at)
+         ON CONFLICT(trigger_id, key) DO UPDATE SET
+           value = @value,
+           updated_at = @updated_at`)
+            .run({ trigger_id: triggerId, key, value, updated_at: now });
+    }
     async readRun(runId) {
         await this.ready();
         const row = this.getRunRow(runId);