@d19n/youfibre-odin-sdk 2.0.166 → 2.0.168

package/dist/process-model/process-validator.js

@@ -0,0 +1,509 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProcessSuccessIndexKey = exports.validateAgainstProcess = void 0;
+/**
+ * Evaluate `ctx.record` against `ctx.process` for the record's current stage.
+ */
+function validateAgainstProcess(ctx) {
+    var _a, _b, _c, _d, _e;
+    const stageKey = (_b = (_a = ctx.record.stage) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : '';
+    const stage = ctx.process.stages.find((s) => s.key === stageKey);
+    if (!stage) {
+        return {
+            recordId: (_c = ctx.record.id) !== null && _c !== void 0 ? _c : '<unknown>',
+            recordNumber: ctx.record.recordNumber,
+            stageKey,
+            stageRecognised: false,
+            verdicts: [],
+            ageInStage: computeAgeInStage(ctx.record, undefined, undefined),
+            overall: 'unmatched-variance',
+        };
+    }
+    const verdicts = ((_d = stage.dependencies) !== null && _d !== void 0 ? _d : []).map((dep) => evaluateDependency(dep, ctx));
+    return {
+        recordId: (_e = ctx.record.id) !== null && _e !== void 0 ? _e : '<unknown>',
+        recordNumber: ctx.record.recordNumber,
+        stageKey,
+        stageRecognised: true,
+        verdicts,
+        ageInStage: computeAgeInStage(ctx.record, stage.warnAfter, stage.alertAfter),
+        overall: computeOverall(verdicts),
+    };
+}
+exports.validateAgainstProcess = validateAgainstProcess;
+// ──────────────────────────────────────────────────────────────────────
+// Aging
+// ──────────────────────────────────────────────────────────────────────
+function parseDurationToDays(s) {
+    if (!s)
+        return undefined;
+    const match = /^(\d+)\s*([dhmw])$/.exec(s.trim());
+    if (!match)
+        return undefined;
+    const n = Number.parseInt(match[1], 10);
+    switch (match[2]) {
+        case 'h':
+            return n / 24;
+        case 'd':
+            return n;
+        case 'w':
+            return n * 7;
+        case 'm':
+            return n * 30;
+        default:
+            return undefined;
+    }
+}
+function computeAgeInStage(record, warnAfter, alertAfter) {
+    if (!record.createdAt) {
+        return { days: -1, status: 'unknown' };
+    }
+    const createdMs = new Date(record.createdAt).getTime();
+    if (Number.isNaN(createdMs)) {
+        return { days: -1, status: 'unknown' };
+    }
+    const days = Math.floor((Date.now() - createdMs) / (24 * 60 * 60 * 1000));
+    const warnAfterDays = parseDurationToDays(warnAfter);
+    const alertAfterDays = parseDurationToDays(alertAfter);
+    let status = 'green';
+    if (alertAfterDays !== undefined && days >= alertAfterDays)
+        status = 'alert';
+    else if (warnAfterDays !== undefined && days >= warnAfterDays)
+        status = 'warn';
+    return { days, status, warnAfterDays, alertAfterDays };
+}
+// ──────────────────────────────────────────────────────────────────────
+// Dependency dispatch
+// ──────────────────────────────────────────────────────────────────────
+function evaluateDependency(dep, ctx) {
+    switch (dep.kind) {
+        case 'related-record':
+            return evaluateRelatedRecord(dep, ctx);
+        case 'cross-system-record-exists':
+            return evaluateCrossSystemRecordExists(dep, ctx);
+        case 'process-success':
+            return evaluateProcessSuccess(dep, ctx);
+        case 'invariant':
+            return evaluateInvariant(dep, ctx);
+    }
+}
+const INVARIANT_PREDICATES = {
+    'stage-age-lte': (record, arg) => {
+        if (!arg)
+            return 'unknown';
+        const days = parseDurationToDays(arg);
+        if (days === undefined)
+            return 'unknown';
+        if (!record.createdAt)
+            return 'unknown';
+        const createdMs = new Date(record.createdAt).getTime();
+        if (Number.isNaN(createdMs))
+            return 'unknown';
+        const ageDays = (Date.now() - createdMs) / (24 * 60 * 60 * 1000);
+        return ageDays <= days;
+    },
+};
+function evaluateInvariant(dep, ctx) {
+    var _a;
+    const ref = dep.predicateRef;
+    if (!ref) {
+        return {
+            depId: dep.id,
+            depKind: 'invariant',
+            status: 'unsupported-kind',
+            unresolvedReason: `Invariant dep '${dep.id}' has no predicateRef declared; engine cannot evaluate.`,
+        };
+    }
+    const [predicateId, ...rest] = ref.split(':');
+    const arg = rest.length > 0 ? rest.join(':') : undefined;
+    const predicate = INVARIANT_PREDICATES[predicateId];
+    if (!predicate) {
+        const action = findInvariantVarianceMatch(dep, 'predicate-not-registered');
+        if (action) {
+            return {
+                depId: dep.id,
+                depKind: 'invariant',
+                status: 'variance',
+                varianceShape: 'predicate-not-registered',
+                varianceActualSummary: `predicateRef '${ref}' is not registered in the engine`,
+                prescribedAction: action,
+            };
+        }
+        return {
+            depId: dep.id,
+            depKind: 'invariant',
+            status: 'unsupported-kind',
+            unresolvedReason: `Predicate '${predicateId}' (from predicateRef '${ref}') is not registered in INVARIANT_PREDICATES.`,
+        };
+    }
+    const result = predicate(ctx.record, arg);
+    if (result === 'unknown') {
+        return {
+            depId: dep.id,
+            depKind: 'invariant',
+            status: 'unsupported-kind',
+            unresolvedReason: `Predicate '${predicateId}' returned 'unknown' for record ${(_a = ctx.record.id) !== null && _a !== void 0 ? _a : '<no-id>'} — a required input is missing.`,
+        };
+    }
+    if (result === true) {
+        return { depId: dep.id, depKind: 'invariant', status: 'correct' };
+    }
+    const action = findInvariantVarianceMatch(dep, 'predicate-failed');
+    if (!action) {
+        return {
+            depId: dep.id,
+            depKind: 'invariant',
+            status: 'unmatched-variance',
+            varianceActualSummary: `predicate '${ref}' returned false`,
+            unresolvedReason: `Predicate '${ref}' failed and no onVariance clause matched 'predicate-failed'.`,
+        };
+    }
+    return {
+        depId: dep.id,
+        depKind: 'invariant',
+        status: 'variance',
+        varianceShape: 'predicate-failed',
+        varianceActualSummary: `predicate '${ref}' returned false`,
+        prescribedAction: action,
+    };
+}
+function findInvariantVarianceMatch(dep, shape) {
+    if (!dep.onVariance || dep.onVariance.length === 0)
+        return null;
+    for (const clause of dep.onVariance) {
+        if (clause.when === shape)
+            return clause.action;
+    }
+    for (const clause of dep.onVariance) {
+        if (clause.when === 'otherwise')
+            return clause.action;
+    }
+    return null;
+}
+// ──────────────────────────────────────────────────────────────────────
+// related-record kind
+// ──────────────────────────────────────────────────────────────────────
+function evaluateRelatedRecord(dep, ctx) {
+    var _a, _b;
+    if (dep.parentFilter && !matchesAllFilters(ctx.record, dep.parentFilter)) {
+        return { depId: getDepId(dep), depKind: 'related-record', status: 'correct' };
+    }
+    const records = (_a = ctx.relations[dep.relation.entity]) !== null && _a !== void 0 ? _a : [];
+    const matching = records.filter((r) => matchesAllFilters(r, dep.relation.filter));
+    const minCount = (_b = dep.relation.minCount) !== null && _b !== void 0 ? _b : (dep.relation.maxCount !== undefined ? 0 : 1);
+    const maxCount = dep.relation.maxCount;
+    const meetsMin = matching.length >= minCount;
+    const meetsMax = maxCount === undefined || matching.length <= maxCount;
+    if (meetsMin && meetsMax) {
+        return { depId: getDepId(dep), depKind: 'related-record', status: 'correct' };
+    }
+    const clauseMatch = findRelatedRecordVarianceMatch(dep, records);
+    if (!clauseMatch) {
+        return {
+            depId: getDepId(dep),
+            depKind: 'related-record',
+            status: 'unmatched-variance',
+            varianceActualSummary: summariseRecords(records, dep.relation.entity),
+            unresolvedReason: `Filter not satisfied (matching=${matching.length}, minCount=${minCount}${maxCount === undefined ? '' : `, maxCount=${maxCount}`}) and no onVariance clause matched the actual data shape.`,
+        };
+    }
+    return {
+        depId: getDepId(dep),
+        depKind: 'related-record',
+        status: 'variance',
+        varianceShape: clauseMatch.shape,
+        varianceActualSummary: clauseMatch.summary,
+        prescribedAction: clauseMatch.action,
+    };
+}
+function findRelatedRecordVarianceMatch(dep, records) {
+    if (!dep.onVariance || dep.onVariance.length === 0)
+        return null;
+    for (const clause of dep.onVariance) {
+        switch (clause.when) {
+            case 'no-related-records': {
+                if (records.length === 0) {
+                    return {
+                        shape: 'no-related-records',
+                        summary: 'no related records linked at all',
+                        action: clause.action,
+                    };
+                }
+                break;
+            }
+            case 'no-records-matching': {
+                const anyMatch = records.some((r) => matchesAllFilters(r, clause.match));
+                if (!anyMatch) {
+                    return {
+                        shape: 'no-records-matching',
+                        summary: `${records.length} record(s) linked, none match: ${describeFilters(clause.match)}`,
+                        action: clause.action,
+                    };
+                }
+                break;
+            }
+            case 'all-records-matching-also-match': {
+                const selectorMatches = records.filter((r) => matchesAllFilters(r, clause.selector));
+                if (selectorMatches.length === 0)
+                    break;
+                const allAlsoMatch = selectorMatches.every((r) => matchesAllFilters(r, clause.additional));
+                if (allAlsoMatch) {
+                    return {
+                        shape: 'all-records-matching-also-match',
+                        summary: `${selectorMatches.length} record(s) match selector ${describeFilters(clause.selector)}; all also match ${describeFilters(clause.additional)}`,
+                        action: clause.action,
+                    };
+                }
+                break;
+            }
+            case 'otherwise': {
+                return {
+                    shape: 'otherwise',
+                    summary: `${records.length} record(s) linked; no specific clause matched, falling through to otherwise`,
+                    action: clause.action,
+                };
+            }
+        }
+    }
+    return null;
+}
+// ──────────────────────────────────────────────────────────────────────
+// cross-system-record-exists kind
+// ──────────────────────────────────────────────────────────────────────
+function evaluateCrossSystemRecordExists(dep, ctx) {
+    var _a, _b, _c, _d;
+    if (dep.parentFilter && !matchesAllFilters(ctx.record, dep.parentFilter)) {
+        return {
+            depId: getDepId(dep),
+            depKind: 'cross-system-record-exists',
+            status: 'correct',
+        };
+    }
+    const key = `${dep.mapping.system}:${dep.mapping.remoteEntity}`;
+    const records = (_a = ctx.crossSystemRecords) === null || _a === void 0 ? void 0 : _a[key];
+    if (records === undefined) {
+        return {
+            depId: getDepId(dep),
+            depKind: 'cross-system-record-exists',
+            status: 'unsupported-kind',
+            unresolvedReason: `Cross-system records for '${key}' were not hydrated for this run; engine cannot evaluate this dep.`,
+        };
+    }
+    if (records.length === 0) {
+        const clauseAction = findCrossSystemVarianceMatch(dep, 'no-cross-system-record');
+        if (!clauseAction) {
+            return {
+                depId: getDepId(dep),
+                depKind: 'cross-system-record-exists',
+                status: 'unmatched-variance',
+                varianceActualSummary: `no ${key} record found`,
+                unresolvedReason: `Cross-system counterpart on ${dep.mapping.system} not found and no onVariance clause matched 'no-cross-system-record'.`,
+            };
+        }
+        return {
+            depId: getDepId(dep),
+            depKind: 'cross-system-record-exists',
+            status: 'variance',
+            varianceShape: 'no-cross-system-record',
+            varianceActualSummary: `no ${key} record found by ${dep.mapping.mapping.fromProperty}→${dep.mapping.mapping.toProperty}`,
+            prescribedAction: clauseAction,
+        };
+    }
+    if (dep.remoteFilter && dep.remoteFilter.length > 0) {
+        const matching = records.filter((r) => { var _a; return matchesAllFilters(r, (_a = dep.remoteFilter) !== null && _a !== void 0 ? _a : []); });
+        if (matching.length === 0) {
+            const clauseAction = findCrossSystemVarianceMatch(dep, 'cross-system-record-mismatched');
+            const summary = `${records.length} ${key} record(s) found; none match ${describeFilters(dep.remoteFilter)}; sample StageKey=${(_d = (_c = (_b = records[0]) === null || _b === void 0 ? void 0 : _b.stage) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : '<none>'}`;
+            if (!clauseAction) {
+                return {
+                    depId: getDepId(dep),
+                    depKind: 'cross-system-record-exists',
+                    status: 'unmatched-variance',
+                    varianceActualSummary: summary,
+                    unresolvedReason: `Cross-system counterpart found but doesn't match remoteFilter, and no onVariance clause matched 'cross-system-record-mismatched'.`,
+                };
+            }
+            return {
+                depId: getDepId(dep),
+                depKind: 'cross-system-record-exists',
+                status: 'variance',
+                varianceShape: 'cross-system-record-mismatched',
+                varianceActualSummary: summary,
+                prescribedAction: clauseAction,
+            };
+        }
+    }
+    return {
+        depId: getDepId(dep),
+        depKind: 'cross-system-record-exists',
+        status: 'correct',
+    };
+}
+function findCrossSystemVarianceMatch(dep, shape) {
+    if (!dep.onVariance || dep.onVariance.length === 0)
+        return null;
+    for (const clause of dep.onVariance) {
+        if (clause.when === shape)
+            return clause.action;
+    }
+    for (const clause of dep.onVariance) {
+        if (clause.when === 'otherwise')
+            return clause.action;
+    }
+    return null;
+}
+// ──────────────────────────────────────────────────────────────────────
+// process-success kind
+// ──────────────────────────────────────────────────────────────────────
+function buildProcessSuccessIndexKey(process, withinWindow) {
+    return `${process}::${withinWindow !== null && withinWindow !== void 0 ? withinWindow : '<no-window>'}`;
+}
+exports.buildProcessSuccessIndexKey = buildProcessSuccessIndexKey;
+function evaluateProcessSuccess(dep, ctx) {
+    var _a, _b, _c, _d;
+    const indexKey = buildProcessSuccessIndexKey(dep.process, dep.withinWindow);
+    const index = (_a = ctx.processSuccessIndexes) === null || _a === void 0 ? void 0 : _a[indexKey];
+    if (!index) {
+        return {
+            depId: getDepId(dep),
+            depKind: 'process-success',
+            status: 'unsupported-kind',
+            unresolvedReason: `process-success index for '${dep.process}' (window=${(_b = dep.withinWindow) !== null && _b !== void 0 ? _b : '<no-window>'}) was not pre-fetched for this run; engine cannot evaluate.`,
+        };
+    }
+    const recordId = ctx.record.id;
+    if (!recordId) {
+        return {
+            depId: getDepId(dep),
+            depKind: 'process-success',
+            status: 'unsupported-kind',
+            unresolvedReason: 'record.id missing; cannot look up process-success record.',
+        };
+    }
+    const hit = index.get(recordId);
+    if (hit) {
+        return { depId: getDepId(dep), depKind: 'process-success', status: 'correct' };
+    }
+    const matchedClause = findProcessSuccessVarianceMatch(dep, 'no-process-record-found');
+    if (!matchedClause) {
+        return {
+            depId: getDepId(dep),
+            depKind: 'process-success',
+            status: 'unmatched-variance',
+            varianceActualSummary: `no SUCCESS '${dep.process}' record found within ${(_c = dep.withinWindow) !== null && _c !== void 0 ? _c : '<no-window>'} for record.id=${recordId}`,
+            unresolvedReason: `No SUCCESS '${dep.process}' record found and no onVariance clause matched 'no-process-record-found'.`,
+        };
+    }
+    return {
+        depId: getDepId(dep),
+        depKind: 'process-success',
+        status: 'variance',
+        varianceShape: 'no-process-record-found',
+        varianceActualSummary: `no SUCCESS '${dep.process}' record found within ${(_d = dep.withinWindow) !== null && _d !== void 0 ? _d : '<no-window>'}`,
+        prescribedAction: matchedClause,
+    };
+}
+function findProcessSuccessVarianceMatch(dep, shape) {
+    if (!dep.onVariance || dep.onVariance.length === 0)
+        return null;
+    for (const clause of dep.onVariance) {
+        if (clause.when === shape)
+            return clause.action;
+    }
+    for (const clause of dep.onVariance) {
+        if (clause.when === 'otherwise')
+            return clause.action;
+    }
+    return null;
+}
+// ──────────────────────────────────────────────────────────────────────
+// Filter primitives
+// ──────────────────────────────────────────────────────────────────────
+function matchesAllFilters(record, filters) {
+    return filters.every((f) => matchesFilter(record, f));
+}
+function matchesFilter(record, filter) {
+    const value = readColumn(record, filter.column);
+    switch (filter.op) {
+        case 'eq':
+            return value === filter.value;
+        case 'notEq':
+            return value !== filter.value;
+        case 'in':
+            return Array.isArray(filter.value) && filter.value.includes(value);
+        case 'notIn':
+            return Array.isArray(filter.value) && !filter.value.includes(value);
+        case 'notNull':
+            return value !== null && value !== undefined;
+        case 'isNull':
+            return value === null || value === undefined;
+        case 'gte':
+            return (value !== null &&
+                value !== undefined &&
+                typeof value === typeof filter.value &&
+                value >= filter.value);
+        case 'lte':
+            return (value !== null &&
+                value !== undefined &&
+                typeof value === typeof filter.value &&
+                value <= filter.value);
+    }
+}
+function readColumn(record, column) {
+    var _a, _b, _c;
+    switch (column) {
+        case 'id':
+            return record.id;
+        case 'Type':
+            return record.type;
+        case 'StageKey':
+            return (_a = record.stage) === null || _a === void 0 ? void 0 : _a.key;
+        case 'StageName':
+            return (_b = record.stage) === null || _b === void 0 ? void 0 : _b.name;
+        case 'CreatedAt':
+            return record.createdAt;
+        case 'UpdatedAt':
+            return record.updatedAt;
+        case 'recordNumber':
+            return record.recordNumber;
+        default:
+            return (_c = record.properties) === null || _c === void 0 ? void 0 : _c[column];
+    }
+}
+// ──────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────
+function getDepId(dep) {
+    if ('id' in dep && dep.id)
+        return dep.id;
+    return `<no-id:${dep.kind}>`;
+}
+function summariseRecords(records, entity) {
+    if (records.length === 0)
+        return `0 records of ${entity}`;
+    const byType = records.reduce((acc, r) => {
+        var _a, _b;
+        const t = (_a = r.type) !== null && _a !== void 0 ? _a : '<no-type>';
+        acc[t] = ((_b = acc[t]) !== null && _b !== void 0 ? _b : 0) + 1;
+        return acc;
+    }, {});
+    const parts = Object.entries(byType).map(([t, n]) => `${n} ${t}`);
+    return `${records.length} record(s) of ${entity}: ${parts.join(', ')}`;
+}
+function describeFilters(filters) {
+    return filters
+        .map((f) => `${f.column} ${f.op}${f.value === undefined ? '' : ` ${JSON.stringify(f.value)}`}`)
+        .join(' AND ');
+}
+function computeOverall(verdicts) {
+    if (verdicts.length === 0)
+        return 'correct';
+    // Priority: variance > unmatched-variance > correct > unsupported-kind.
+    if (verdicts.some((v) => v.status === 'variance'))
+        return 'variance';
+    if (verdicts.some((v) => v.status === 'unmatched-variance'))
+        return 'unmatched-variance';
+    if (verdicts.some((v) => v.status === 'correct'))
+        return 'correct';
+    return 'unsupported-kind';
+}

package/dist/process-model/types.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Process-model evaluation types — the deployable subset of the agent-os
+ * authoring model `agent-os/knowledge/business-processes/types.ts`.
+ *
+ *     data + process template + evaluation mechanism → correct / variance
+ *
+ * The authoring model carries rendering / BPMN / documentation fields
+ * (entryActions, handoffs, stageJobs, rag, owners, notifications). The
+ * EVALUATION engine reads only `stages[].{key, name, terminal, dependencies,
+ * warnAfter, alertAfter}` plus the dependency + onVariance shapes — so this
+ * lifted copy is deliberately slim: only what `validateAgainstProcess` reads
+ * and what a frozen `ProcessDef` projection needs to carry.
+ *
+ * Source of truth remains the agent-os authoring files. The `*-process.
+ * projection.ts` siblings are frozen mechanical extractions, each with a
+ * "verified against live BP on <date>" header (same pattern as
+ * `wholesale-provider/install-stage-kci-spec.ts`).
+ */
+export interface PropertyFilter {
+    column: string;
+    op: 'eq' | 'in' | 'notIn' | 'notEq' | 'notNull' | 'isNull' | 'gte' | 'lte';
+    value?: string | number | string[];
+}
+export declare type Severity = 'INFO' | 'WARN' | 'BLOCKER';
+export interface CrossSystemMapping {
+    /** Where the counterpart record lives, e.g. 'NET'. */
+    system: string;
+    /** The remote entity key, e.g. 'OrderModule:Order' on NET. */
+    remoteEntity: string;
+    /** Which YF-side property's value matches which remote-side property's value. */
+    mapping: {
+        fromProperty: string;
+        toProperty: string;
+    };
+}
+export declare type ActionDecl = {
+    kind: 'revert-parent-to';
+    stageKey: string;
+    properties?: Record<string, string | number | boolean | null>;
+    notes?: string;
+} | {
+    kind: 'cancel-parent';
+    stageKey: string;
+    properties?: Record<string, string | number | boolean | null>;
+    notes?: string;
+} | {
+    kind: 'advance-parent-to';
+    stageKey: string;
+    properties?: Record<string, string | number | boolean | null>;
+    notes?: string;
+} | {
+    kind: 'manual-triage';
+    reason: string;
+} | {
+    kind: 'invoke-platform-api';
+    target?: 'yf' | 'net';
+    endpoint: string;
+    method?: 'get' | 'post' | 'patch' | 'put' | 'delete';
+    payload?: Record<string, unknown>;
+    targetSelector?: PropertyFilter[];
+    notes?: string;
+};
+export declare type RelatedRecordVarianceClause = {
+    when: 'no-related-records';
+    action: ActionDecl;
+} | {
+    when: 'no-records-matching';
+    match: PropertyFilter[];
+    action: ActionDecl;
+} | {
+    when: 'all-records-matching-also-match';
+    selector: PropertyFilter[];
+    additional: PropertyFilter[];
+    action: ActionDecl;
+} | {
+    when: 'otherwise';
+    action: ActionDecl;
+};
+export declare type ProcessSuccessVarianceClause = {
+    when: 'no-process-record-found';
+    action: ActionDecl;
+} | {
+    when: 'process-record-failed';
+    action: ActionDecl;
+} | {
+    when: 'process-record-stale';
+    action: ActionDecl;
+} | {
+    when: 'otherwise';
+    action: ActionDecl;
+};
+export declare type CrossSystemRecordExistsVarianceClause = {
+    when: 'no-cross-system-record';
+    action: ActionDecl;
+} | {
+    when: 'cross-system-record-mismatched';
+    action: ActionDecl;
+} | {
+    when: 'otherwise';
+    action: ActionDecl;
+};
+export declare type InvariantVarianceClause = {
+    when: 'predicate-failed';
+    action: ActionDecl;
+} | {
+    when: 'predicate-not-registered';
+    action: ActionDecl;
+} | {
+    when: 'otherwise';
+    action: ActionDecl;
+};
+export interface ProcessSuccessDependency {
+    kind: 'process-success';
+    id?: string;
+    /** Process-execution `name` (action_key for actions, custom name for workflows). */
+    process: string;
+    matchOn: 'journeyId' | 'input.id';
+    withinWindow?: string;
+    severity: Severity;
+    notes?: string;
+    onVariance?: ProcessSuccessVarianceClause[];
+}
+export interface CrossSystemRecordExistsDependency {
+    kind: 'cross-system-record-exists';
+    id?: string;
+    parentFilter?: PropertyFilter[];
+    mapping: CrossSystemMapping;
+    remoteFilter?: PropertyFilter[];
+    severity: Severity;
+    notes?: string;
+    onVariance?: CrossSystemRecordExistsVarianceClause[];
+}
+export interface RelatedRecordDependency {
+    kind: 'related-record';
+    id?: string;
+    parentFilter?: PropertyFilter[];
+    relation: {
+        entity: string;
+        filter: PropertyFilter[];
+        minCount?: number;
+        maxCount?: number;
+    };
+    severity: Severity;
+    notes?: string;
+    onVariance?: RelatedRecordVarianceClause[];
+}
+export interface InvariantDependency {
+    kind: 'invariant';
+    id: string;
+    description: string;
+    severity: Severity;
+    predicateRef?: string;
+    onVariance?: InvariantVarianceClause[];
+}
+export declare type Dependency = ProcessSuccessDependency | CrossSystemRecordExistsDependency | RelatedRecordDependency | InvariantDependency;
+export interface StageDef {
+    key: string;
+    name: string;
+    terminal?: boolean;
+    dependencies?: Dependency[];
+    /** Time-in-stage thresholds, e.g. '7d'. Drive the AgeInStage signal. */
+    warnAfter?: string;
+    alertAfter?: string;
+}
+export interface ProcessDef {
+    /** Process id (upper-snake), e.g. ORDER, INSTALL. */
+    id: string;
+    title: string;
+    /** Canonical entity key, e.g. 'OrderModule:Order'. */
+    entity: string;
+    /** Constraint scoping this process to a subset of the entity. */
+    scopeFilter?: PropertyFilter[];
+    stages: StageDef[];
+}
+export interface ProcessSuccessRecord {
+    id?: string;
+    name?: string;
+    status?: string;
+    startedAt?: string;
+    completedAt?: string;
+    journeyId?: string;
+    input?: {
+        id?: string;
+    } & Record<string, unknown>;
+}