@unson/brainbase-mcp 0.43.0 → 0.44.1

package/dist/routine-cycle.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Portable lifecycle for a routine cycle.
+ *
+ * The consumer owns each routine's Graph, tenant, credentials, storage, and
+ * systemd behavior. This core only selects the injected handler, converts a
+ * thrown handler error into the consumer's error result, and invokes the same
+ * finalizer for both success and failure. That keeps the cycle boundary
+ * reusable without moving Brainbase policy into the OSS package.
+ */
+export type RoutineCycleInput = Record<string, unknown>;
+export type RoutineCycleHandler = (input: RoutineCycleInput, context?: unknown) => unknown | PromiseLike<unknown>;
+export type RoutineCycleErrorResult = (error: unknown, routine: string) => unknown;
+export type RoutineCycleSummary = (routine: string, result: unknown) => unknown;
+export type RoutineCycleContentAvailability = (routine: string, result: unknown) => boolean | undefined;
+export type RoutineCycleContentEmptyAnomaly = (routine: string) => Record<string, unknown>;
+export type RoutineCyclePostprocessor = (routine: string, result: unknown) => unknown;
+export interface RoutineCycleRuntimeOptions {
+    handlers: Record<string, RoutineCycleHandler>;
+    onError?: RoutineCycleErrorResult;
+    summarize?: RoutineCycleSummary;
+    /** Consumer may report whether a completed routine produced usable content. */
+    contentAvailable?: RoutineCycleContentAvailability;
+    /** Consumer may preserve its public wording for an empty completed result. */
+    contentEmptyAnomaly?: RoutineCycleContentEmptyAnomaly;
+    /** Consumer-specific decoration runs after the portable finalizer. */
+    postprocess?: RoutineCyclePostprocessor;
+}
+export interface RoutineCycleFinalizeOptions {
+    /** A consumer may report that a completed routine had no usable content. */
+    contentAvailable?: boolean;
+    contentEmptyAnomaly?: Record<string, unknown>;
+}
+/**
+ * Normalize the lifecycle fields shared by every routine consumer.
+ *
+ * Consumer code remains responsible for redacting and shaping its domain
+ * output. This function owns the portable status/coverage/anomaly contract so
+ * a consumer cannot accidentally drop an anomaly while adding its own summary.
+ */
+export declare function finalizeRoutineCycleResult(routine: string, result: unknown, options?: RoutineCycleFinalizeOptions): Record<string, unknown>;
+export declare class RoutineCycleRuntime {
+    private readonly handlers;
+    private readonly onError;
+    private readonly summarize;
+    private readonly contentAvailable?;
+    private readonly contentEmptyAnomaly?;
+    private readonly postprocess?;
+    constructor(options: RoutineCycleRuntimeOptions);
+    execute(input?: RoutineCycleInput, context?: unknown): Promise<unknown>;
+}
+export declare function createRoutineCycleRuntime(options: RoutineCycleRuntimeOptions): RoutineCycleRuntime;

package/dist/routine-cycle.js

@@ -0,0 +1,153 @@
+/**
+ * Portable lifecycle for a routine cycle.
+ *
+ * The consumer owns each routine's Graph, tenant, credentials, storage, and
+ * systemd behavior. This core only selects the injected handler, converts a
+ * thrown handler error into the consumer's error result, and invokes the same
+ * finalizer for both success and failure. That keeps the cycle boundary
+ * reusable without moving Brainbase policy into the OSS package.
+ */
+function unsupportedRoutine(routine) {
+    return new Error(`unsupported routine: ${routine}`);
+}
+function defaultErrorResult(error, stage = 'routine_execution') {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        status: 'failed',
+        anomalies: [{ code: 'routine_execution_failed', stage, summary: message }]
+    };
+}
+function errorWithStage(error, stage) {
+    if (error && typeof error === 'object') {
+        try {
+            const existingStage = error.stage;
+            if (typeof existingStage !== 'string' || existingStage.trim() === '') {
+                Object.assign(error, { stage });
+            }
+            return error;
+        }
+        catch {
+            // A frozen host error still gets a stable wrapper below.
+        }
+    }
+    const wrapped = new Error(error instanceof Error ? error.message : String(error));
+    Object.assign(wrapped, { stage, cause: error });
+    return wrapped;
+}
+function safeErrorResult(onError, error, routine, stage) {
+    const staged = errorWithStage(error, stage);
+    try {
+        return onError(staged, routine);
+    }
+    catch (handlerError) {
+        return defaultErrorResult(handlerError, stage);
+    }
+}
+/**
+ * Normalize the lifecycle fields shared by every routine consumer.
+ *
+ * Consumer code remains responsible for redacting and shaping its domain
+ * output. This function owns the portable status/coverage/anomaly contract so
+ * a consumer cannot accidentally drop an anomaly while adding its own summary.
+ */
+export function finalizeRoutineCycleResult(routine, result, options = {}) {
+    const source = result && typeof result === 'object' && !Array.isArray(result)
+        ? result
+        : {};
+    let status = typeof source.status === 'string' ? source.status : 'failed';
+    const anomalies = Array.isArray(source.anomalies) ? [...source.anomalies] : [];
+    if (status === 'completed' && options.contentAvailable === false) {
+        status = 'partial';
+        anomalies.push(options.contentEmptyAnomaly || {
+            code: 'routine_content_empty',
+            routine,
+            summary: 'routine completed without usable content'
+        });
+    }
+    const coverage = options.contentAvailable === false
+        ? 'partial'
+        : typeof source.coverage === 'string'
+            ? source.coverage
+            : status === 'failed'
+                ? 'unavailable'
+                : anomalies.length > 0 || status === 'partial' ? 'partial' : 'confirmed';
+    return {
+        ...source,
+        status,
+        anomalies,
+        coverage,
+        summary: {
+            routine,
+            status,
+            coverage,
+            anomaly_count: anomalies.length
+        }
+    };
+}
+export class RoutineCycleRuntime {
+    handlers;
+    onError;
+    summarize;
+    contentAvailable;
+    contentEmptyAnomaly;
+    postprocess;
+    constructor(options) {
+        if (!options || typeof options !== 'object' || !options.handlers || typeof options.handlers !== 'object') {
+            throw new Error('routine cycle handlers are required');
+        }
+        this.handlers = options.handlers;
+        this.onError = options.onError || ((error) => defaultErrorResult(error));
+        this.summarize = options.summarize || ((_routine, result) => result);
+        this.contentAvailable = options.contentAvailable;
+        this.contentEmptyAnomaly = options.contentEmptyAnomaly;
+        this.postprocess = options.postprocess;
+    }
+    async execute(input = {}, context) {
+        const routine = typeof input?.routine === 'string' ? input.routine : String(input?.routine || '');
+        let result;
+        try {
+            const handler = this.handlers[routine];
+            if (typeof handler !== 'function')
+                throw unsupportedRoutine(routine);
+            result = await handler(input, context);
+        }
+        catch (error) {
+            result = safeErrorResult(this.onError, error, routine, 'routine_execution');
+        }
+        let summarized;
+        try {
+            summarized = await this.summarize(routine, result);
+        }
+        catch (error) {
+            summarized = safeErrorResult(this.onError, error, routine, 'summary');
+        }
+        let finalized;
+        try {
+            finalized = finalizeRoutineCycleResult(routine, summarized, {
+                contentAvailable: this.contentAvailable?.(routine, summarized),
+                contentEmptyAnomaly: this.contentEmptyAnomaly?.(routine) || {
+                    code: 'routine_content_empty',
+                    routine,
+                    summary: 'routine completed without usable content'
+                }
+            });
+        }
+        catch (error) {
+            finalized = finalizeRoutineCycleResult(routine, safeErrorResult(this.onError, error, routine, 'finalize'));
+        }
+        if (!this.postprocess)
+            return finalized;
+        try {
+            return await this.postprocess(routine, finalized);
+        }
+        catch (error) {
+            // Decoration is consumer-owned, but it remains inside the portable
+            // cycle boundary so a decoration failure cannot escape as an untracked
+            // successful routine.
+            return finalizeRoutineCycleResult(routine, safeErrorResult(this.onError, error, routine, 'postprocess'));
+        }
+    }
+}
+export function createRoutineCycleRuntime(options) {
+    return new RoutineCycleRuntime(options);
+}

package/dist/routine-liveness.d.ts

@@ -0,0 +1,49 @@
+import type { Awaitable } from './runtime-host.js';
+import type { RoutineExpectation } from './routine-runtime.js';
+export interface RoutineReceiptHistoryQuery {
+    projectId: string;
+    sourceType: string;
+    sourceIdentity: string;
+    limit: number;
+}
+export interface RoutineReceiptHistoryPort {
+    listHistory(input: RoutineReceiptHistoryQuery, context?: unknown): Awaitable<{
+        items?: unknown[];
+    } | unknown>;
+}
+export interface RoutineLivenessExceptionPort {
+    (context?: unknown): Awaitable<unknown[]>;
+}
+export interface RoutineLivenessRuntimeOptions {
+    expectations: RoutineExpectation[];
+    runReceiptQueryService: RoutineReceiptHistoryPort;
+    listDeadLetters?: RoutineLivenessExceptionPort;
+    listKnowledgeEventDeadLetters?: RoutineLivenessExceptionPort;
+    listKnowledgeEventOutboxExceptions?: RoutineLivenessExceptionPort;
+    listRuntimeIdentityExceptions?: RoutineLivenessExceptionPort;
+    /** Consumers may add domain-specific priorities without moving them here. */
+    priority?: Readonly<Record<string, number>>;
+    now?: () => Date;
+}
+/** Convert a recurring local wall-clock schedule to an instant. */
+export declare function scheduledAtFor(expectation: RoutineExpectation, now: Date): Date;
+/**
+ * Portable liveness/reconciliation over routine expectations and receipts.
+ * Graph, tenant, storage and dead-letter sources remain injected consumer
+ * ports; only schedule, receipt and required-artifact semantics live here.
+ */
+export declare class RoutineLivenessRuntime {
+    private readonly expectations;
+    private readonly runReceiptQueryService;
+    private readonly listDeadLetters;
+    private readonly listKnowledgeEventDeadLetters;
+    private readonly listKnowledgeEventOutboxExceptions;
+    private readonly listRuntimeIdentityExceptions;
+    private readonly priority;
+    private readonly now;
+    constructor(options: RoutineLivenessRuntimeOptions);
+    listExceptions({ limit }?: {
+        limit?: number;
+    }, context?: unknown): Promise<unknown[]>;
+}
+export declare function createRoutineLivenessRuntime(options: RoutineLivenessRuntimeOptions): RoutineLivenessRuntime;

package/dist/routine-liveness.js

@@ -0,0 +1,227 @@
+const DEFAULT_PRIORITY = Object.freeze({
+    dead_letter: 1,
+    missing_receipt: 2,
+    required_artifact_missing: 3,
+    blocked_receipt: 4
+});
+function asDate(value, fieldName) {
+    const date = value instanceof Date ? new Date(value.getTime()) : new Date(value);
+    if (Number.isNaN(date.getTime()))
+        throw new Error(`${fieldName} must be a valid date`);
+    return date;
+}
+function zonedParts(date, timezone) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone: timezone,
+        hour12: false,
+        hourCycle: 'h23',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit'
+    }).formatToParts(date);
+    const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    return {
+        year: Number(values.year),
+        month: Number(values.month),
+        day: Number(values.day),
+        hour: Number(values.hour),
+        minute: Number(values.minute)
+    };
+}
+function timezoneOffsetMs(date, timezone) {
+    const parts = zonedParts(date, timezone);
+    const localAsUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, 0, 0);
+    return localAsUtc - date.getTime();
+}
+/** Convert a recurring local wall-clock schedule to an instant. */
+export function scheduledAtFor(expectation, now) {
+    const current = asDate(now, 'now');
+    const local = zonedParts(current, expectation.timezone);
+    const localNowMs = Date.UTC(local.year, local.month - 1, local.day, local.hour, local.minute, 0, 0);
+    const scheduled = new Date(localNowMs);
+    scheduled.setUTCHours(expectation.schedule.hour, expectation.schedule.minute, 0, 0);
+    if (expectation.schedule.kind === 'daily') {
+        if (scheduled.getTime() > localNowMs)
+            scheduled.setUTCDate(scheduled.getUTCDate() - 1);
+    }
+    else if (expectation.schedule.kind === 'weekly') {
+        const dayOfWeek = expectation.schedule.day_of_week;
+        if (dayOfWeek === undefined) {
+            throw new Error('weekly routine schedule day_of_week is required');
+        }
+        const weekday = new Date(localNowMs).getUTCDay();
+        const daysSinceSchedule = (weekday - dayOfWeek + 7) % 7;
+        scheduled.setUTCDate(scheduled.getUTCDate() - daysSinceSchedule);
+        if (scheduled.getTime() > localNowMs)
+            scheduled.setUTCDate(scheduled.getUTCDate() - 7);
+    }
+    else {
+        throw new Error(`Unsupported routine schedule kind: ${String(expectation.schedule.kind)}`);
+    }
+    // Resolve the offset at the candidate date. Two iterations cover DST
+    // transitions while keeping the core independent of a timezone library.
+    let instantMs = scheduled.getTime();
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        instantMs = scheduled.getTime() - timezoneOffsetMs(new Date(instantMs), expectation.timezone);
+    }
+    return new Date(instantMs);
+}
+function isBlockedReceipt(receipt) {
+    return ['blocked', 'failed', 'waiting_human'].includes(String(receipt.source_status))
+        || ['no_data', 'unconfirmed'].includes(String(receipt.evidence_state));
+}
+function normalizeArtifactName(value) {
+    return String(value || '').trim().toLowerCase().replace(/[\s-]+/g, '_');
+}
+function missingRequiredArtifacts(expectation, receipt) {
+    const evidenceRefs = Array.isArray(receipt.evidence_refs) ? receipt.evidence_refs : [];
+    return expectation.required_artifacts.filter((requiredArtifact) => !evidenceRefs.some((evidence) => {
+        if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence))
+            return false;
+        const item = evidence;
+        if (item.kind !== 'artifact_ref')
+            return false;
+        if (normalizeArtifactName(item.label) === normalizeArtifactName(requiredArtifact))
+            return true;
+        if (requiredArtifact === 'routine_summary') {
+            const ref = String(item.ref || '').toLowerCase();
+            return /(?:^|[/:_-])routine(?:[/:_-])summary(?:$|[/:_-])/.test(ref)
+                || /(?:^|[/:_-])summary(?:$|[/:_-])/.test(ref);
+        }
+        return false;
+    }));
+}
+function exceptionOverdueMs(exceptionItem, now) {
+    const reference = exceptionItem.grace_deadline_at
+        || exceptionItem.finished_at
+        || exceptionItem.created_at;
+    return reference ? Math.max(0, now.getTime() - asDate(reference, 'exception timestamp').getTime()) : 0;
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+/**
+ * Portable liveness/reconciliation over routine expectations and receipts.
+ * Graph, tenant, storage and dead-letter sources remain injected consumer
+ * ports; only schedule, receipt and required-artifact semantics live here.
+ */
+export class RoutineLivenessRuntime {
+    expectations;
+    runReceiptQueryService;
+    listDeadLetters;
+    listKnowledgeEventDeadLetters;
+    listKnowledgeEventOutboxExceptions;
+    listRuntimeIdentityExceptions;
+    priority;
+    now;
+    constructor(options) {
+        if (!options || !Array.isArray(options.expectations)) {
+            throw new Error('routine liveness expectations must be an array');
+        }
+        if (!options.runReceiptQueryService || typeof options.runReceiptQueryService.listHistory !== 'function') {
+            throw new Error('routine liveness runReceiptQueryService.listHistory is required');
+        }
+        this.expectations = options.expectations;
+        this.runReceiptQueryService = options.runReceiptQueryService;
+        this.listDeadLetters = options.listDeadLetters || (async () => []);
+        this.listKnowledgeEventDeadLetters = options.listKnowledgeEventDeadLetters || (async () => []);
+        this.listKnowledgeEventOutboxExceptions = options.listKnowledgeEventOutboxExceptions || (async () => []);
+        this.listRuntimeIdentityExceptions = options.listRuntimeIdentityExceptions || (async () => []);
+        this.priority = { ...DEFAULT_PRIORITY, ...(options.priority || {}) };
+        this.now = options.now || (() => new Date());
+    }
+    async listExceptions({ limit = 3 } = {}, context) {
+        const current = asDate(this.now(), 'now');
+        const [deadLetters, knowledgeEventDeadLetters, knowledgeEventOutboxExceptions, runtimeIdentityExceptions] = await Promise.all([
+            this.listDeadLetters(context),
+            this.listKnowledgeEventDeadLetters(context),
+            this.listKnowledgeEventOutboxExceptions(context),
+            this.listRuntimeIdentityExceptions(context)
+        ]);
+        const deadLettersByAutomation = new Map();
+        for (const item of Array.isArray(deadLetters) ? deadLetters : []) {
+            const value = record(item);
+            const automationId = typeof value.automation_id === 'string' ? value.automation_id : '';
+            if (automationId && !deadLettersByAutomation.has(automationId))
+                deadLettersByAutomation.set(automationId, value);
+        }
+        const exceptions = [
+            ...(Array.isArray(runtimeIdentityExceptions) ? runtimeIdentityExceptions : []),
+            ...(Array.isArray(knowledgeEventDeadLetters) ? knowledgeEventDeadLetters : []),
+            ...(Array.isArray(knowledgeEventOutboxExceptions) ? knowledgeEventOutboxExceptions : [])
+        ].map((item) => {
+            const value = record(item);
+            return {
+                ...value,
+                ...(value.path ? { path: String(value.path).split(/[\\/]/).pop() } : {})
+            };
+        });
+        for (const expectation of this.expectations) {
+            const scheduledAt = scheduledAtFor(expectation, current);
+            const graceDeadline = new Date(scheduledAt.getTime() + expectation.grace_minutes * 60 * 1000);
+            const deadLetter = deadLettersByAutomation.get(expectation.automation_id);
+            if (deadLetter) {
+                exceptions.push({
+                    code: 'dead_letter',
+                    automation_id: expectation.automation_id,
+                    created_at: deadLetter.created_at,
+                    path: deadLetter.path,
+                    scheduled_at: scheduledAt.toISOString(),
+                    grace_deadline_at: graceDeadline.toISOString()
+                });
+            }
+            const historyInput = {
+                projectId: expectation.project_id,
+                sourceType: expectation.source_type,
+                sourceIdentity: expectation.automation_id,
+                limit: 1
+            };
+            const history = record(await this.runReceiptQueryService.listHistory(historyInput, context));
+            const items = Array.isArray(history.items) ? history.items : [];
+            const latest = record(items[0]);
+            const latestFinishedAt = latest.finished_at ? asDate(latest.finished_at, 'receipt.finished_at') : null;
+            const receiptForSchedule = latestFinishedAt && latestFinishedAt >= scheduledAt ? latest : null;
+            if (!receiptForSchedule) {
+                if (current.getTime() > graceDeadline.getTime()) {
+                    exceptions.push({
+                        code: 'missing_receipt',
+                        automation_id: expectation.automation_id,
+                        scheduled_at: scheduledAt.toISOString(),
+                        grace_deadline_at: graceDeadline.toISOString()
+                    });
+                }
+                continue;
+            }
+            const missingArtifacts = missingRequiredArtifacts(expectation, receiptForSchedule);
+            if (isBlockedReceipt(receiptForSchedule) || missingArtifacts.length > 0) {
+                exceptions.push({
+                    code: isBlockedReceipt(receiptForSchedule) ? 'blocked_receipt' : 'required_artifact_missing',
+                    automation_id: expectation.automation_id,
+                    source_status: receiptForSchedule.source_status,
+                    evidence_state: receiptForSchedule.evidence_state,
+                    ...(missingArtifacts.length > 0 ? { missing_required_artifacts: missingArtifacts } : {}),
+                    finished_at: receiptForSchedule.finished_at,
+                    scheduled_at: scheduledAt.toISOString(),
+                    grace_deadline_at: graceDeadline.toISOString()
+                });
+            }
+        }
+        const safeLimit = Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
+        return exceptions
+            .map((item) => ({ item, overdueMs: exceptionOverdueMs(item, current) }))
+            .sort((left, right) => (this.priority[String(left.item.code)] ?? Number.MAX_SAFE_INTEGER)
+            - (this.priority[String(right.item.code)] ?? Number.MAX_SAFE_INTEGER)
+            || right.overdueMs - left.overdueMs
+            || String(left.item.automation_id || left.item.event_id || '')
+                .localeCompare(String(right.item.automation_id || right.item.event_id || '')))
+            .slice(0, safeLimit)
+            .map(({ item }) => item);
+    }
+}
+export function createRoutineLivenessRuntime(options) {
+    return new RoutineLivenessRuntime(options);
+}

package/dist/routine-runtime.d.ts

@@ -0,0 +1,101 @@
+import { type NormalizedRunReceipt } from './run-receipt.js';
+import { type Awaitable, type RuntimeHostContext, type RuntimeHostPorts } from './runtime-host.js';
+export type RoutineScheduleKind = 'daily' | 'weekly';
+export interface RoutineExpectationSchedule {
+    kind: RoutineScheduleKind;
+    hour: number;
+    minute: number;
+    day_of_week?: number;
+}
+export interface RoutineExpectation {
+    routine: string;
+    automation_id: string;
+    source_type: string;
+    project_id: string;
+    timezone: string;
+    schedule: RoutineExpectationSchedule;
+    grace_minutes: number;
+    required_artifacts: string[];
+}
+export interface RoutineExpectationConstraints {
+    sourceType?: string;
+    projectId?: string;
+    timezone?: string;
+}
+/**
+ * Parse a routine expectation document without assuming an organization,
+ * tenant, timezone, or scheduler. Consumers that need those constraints pass
+ * them explicitly, which keeps the common package portable.
+ */
+export declare function parseRoutineExpectations(value: unknown, constraints?: RoutineExpectationConstraints): RoutineExpectation[];
+export declare function loadRoutineExpectations(filePath: string, constraints?: RoutineExpectationConstraints): RoutineExpectation[];
+export interface RoutineDeadLetter {
+    automation_id: string;
+    created_at: string;
+    path: string;
+}
+/** Read routine dead-letter files without interpreting organization data. */
+export declare function listRoutineDeadLetters({ directory }: {
+    directory: string;
+}): Promise<RoutineDeadLetter[]>;
+export declare function countRoutineOutbox({ directory }: {
+    directory: string;
+}): Promise<number>;
+export interface RoutineRunRequest {
+    routine: string;
+    automationId: string;
+    projectId?: string;
+    sourceType?: string;
+    externalRunId?: string;
+    payload?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface RoutineRunnerStartInput {
+    request: RoutineRunRequest;
+    context: RuntimeHostContext;
+}
+export interface RoutineRunnerRetryInput extends RoutineRunnerStartInput {
+    previousRunId: string;
+}
+export interface RoutineRunnerResult {
+    /** Canonical run_receipt.v1 payload. The host persists it through the receipt port. */
+    receipt: unknown;
+    result?: unknown;
+}
+export interface RoutineRunnerPort {
+    start(input: RoutineRunnerStartInput): Awaitable<RoutineRunnerResult>;
+    retry?(input: RoutineRunnerRetryInput): Awaitable<RoutineRunnerResult>;
+}
+export interface RoutineReceiptPersistenceInput {
+    payload: unknown;
+    normalized: NormalizedRunReceipt;
+    context: RuntimeHostContext;
+}
+export interface RoutineReceiptPort {
+    persist(input: RoutineReceiptPersistenceInput): Awaitable<unknown>;
+    query(input: {
+        request: RoutineRunRequest;
+        context: RuntimeHostContext;
+    }): Awaitable<unknown>;
+}
+export interface RoutineRuntimePorts extends RuntimeHostPorts {
+    runner: RoutineRunnerPort;
+    receipt: RoutineReceiptPort;
+}
+export interface RoutineRunResult {
+    runnerResult: unknown;
+    normalizedReceipt: NormalizedRunReceipt;
+    persistedReceipt: unknown;
+    context: RuntimeHostContext;
+}
+export declare class RoutineRuntimeService {
+    private readonly ports;
+    constructor(ports: RoutineRuntimePorts);
+    start(request: RoutineRunRequest): Promise<RoutineRunResult>;
+    retry(request: RoutineRunRequest, previousRunId: string): Promise<RoutineRunResult>;
+    history(request: RoutineRunRequest): Promise<unknown>;
+    private execute;
+}
+export declare function createRoutineRuntime(ports: RoutineRuntimePorts): RoutineRuntimeService;
+/** Return whether an expectation's scheduled minute matches the supplied instant. */
+export declare function routineScheduleMatches(expectation: RoutineExpectation, instant: Date): boolean;