@unbrained/pm-cli 2026.10.12 → 2026.10.13

package/dist/sdk/relationship-context.d.ts

@@ -11,99 +11,99 @@ export type RelationshipContextRole = "prerequisite" | "dependent" | "ancestor"
 export type RelationshipContextCompleteness = "complete" | "truncated" | "sampled" | "approximate" | "stale_index" | "redacted";
 /** Caller-owned compact node details joined into graph context. */
 export interface RelationshipContextNodeDetails {
-    /** Stable graph node identifier. */
-    id: string;
-    /** Optional display title. */
-    title?: string;
-    /** Optional lifecycle status. */
-    status?: string;
-    /** Optional evidence pointers such as files, tests, or history ids. */
-    evidence?: readonly string[];
+/** Stable graph node identifier. */
+id: string;
+/** Optional display title. */
+title?: string;
+/** Optional lifecycle status. */
+status?: string;
+/** Optional evidence pointers such as files, tests, or history ids. */
+evidence?: readonly string[];
 }
 /** One selected graph-context node with explainable inclusion. */
 export interface RelationshipContextNode extends RelationshipContextNodeDetails {
-    /** Shortest bounded distance from the root. */
-    distance: number;
-    /** Semantic family of this node relative to its discovery counterpart. */
-    role: RelationshipContextRole;
-    /** Node through which bounded traversal first discovered this node. */
-    via: string;
-    /** Concise deterministic reasons the node was selected. */
-    reasons: string[];
+/** Shortest bounded distance from the root. */
+distance: number;
+/** Semantic family of this node relative to its discovery counterpart. */
+role: RelationshipContextRole;
+/** Node through which bounded traversal first discovered this node. */
+via: string;
+/** Concise deterministic reasons the node was selected. */
+reasons: string[];
 }
 /** Counts-first packet overview served before any row payload. */
 export interface RelationshipContextSummary {
-    /** Root node identifier. */
-    rootId: string;
-    /** Root lifecycle status when the caller supplied node details. */
-    rootStatus?: string;
-    /** Root-incident edge counts per semantic family under the active filters. */
-    directEdges: Record<RelationshipContextRole, number>;
-    /** Total root-incident edges under the active filters. */
-    directTotal: number;
-    /** Nodes discovered by the bounded traversal, excluding the root. */
-    discoveredNodes: number;
-    /** Nodes returned in this page. */
-    returnedNodes: number;
-    /** Edges returned in this page. */
-    returnedEdges: number;
-    /** Discovered nodes omitted by pagination, node, or token bounds. */
-    omittedNodes: number;
-    /** Qualifying edges omitted by edge or token bounds. */
-    omittedEdges: number;
-    /** Root evidence pointers promoted into the packet. */
-    evidenceCount: number;
-    /** Whether a continuation cursor is available. */
-    hasMore: boolean;
+/** Root node identifier. */
+rootId: string;
+/** Root lifecycle status when the caller supplied node details. */
+rootStatus?: string;
+/** Root-incident edge counts per semantic family under the active filters. */
+directEdges: Record<RelationshipContextRole, number>;
+/** Total root-incident edges under the active filters. */
+directTotal: number;
+/** Nodes discovered by the bounded traversal, excluding the root. */
+discoveredNodes: number;
+/** Nodes returned in this page. */
+returnedNodes: number;
+/** Edges returned in this page. */
+returnedEdges: number;
+/** Discovered nodes omitted by pagination, node, or token bounds. */
+omittedNodes: number;
+/** Qualifying edges omitted by edge or token bounds. */
+omittedEdges: number;
+/** Root evidence pointers promoted into the packet. */
+evidenceCount: number;
+/** Whether a continuation cursor is available. */
+hasMore: boolean;
 }
 /** Controls for bounded graph-context assembly. */
 export interface RelationshipContextOptions {
-    /** Traversal direction relative to each visited node. */
-    direction?: RelationshipTraversalDirection;
-    /** Optional registered kind filter. */
-    kinds?: readonly string[];
-    /** Maximum traversal depth. */
-    maxDepth?: number;
-    /** Maximum nodes returned in this page. */
-    nodeLimit?: number;
-    /** Maximum edges returned in this page. */
-    edgeLimit?: number;
-    /** Maximum estimated output tokens charged to rows and edges. */
-    tokenBudget?: number;
-    /** Opaque continuation from an equivalent query. */
-    cursor?: string;
-    /** Registry used to explain custom relationship semantics. */
-    registry?: RelationshipKindRegistry;
-    /** Abort signal checked during traversal. */
-    signal?: AbortSignal;
+/** Traversal direction relative to each visited node. */
+direction?: RelationshipTraversalDirection;
+/** Optional registered kind filter. */
+kinds?: readonly string[];
+/** Maximum traversal depth. */
+maxDepth?: number;
+/** Maximum nodes returned in this page. */
+nodeLimit?: number;
+/** Maximum edges returned in this page. */
+edgeLimit?: number;
+/** Maximum estimated output tokens charged to rows and edges. */
+tokenBudget?: number;
+/** Opaque continuation from an equivalent query. */
+cursor?: string;
+/** Registry used to explain custom relationship semantics. */
+registry?: RelationshipKindRegistry;
+/** Abort signal checked during traversal. */
+signal?: AbortSignal;
 }
 /** Explainable graph context packet. */
 export interface RelationshipContextResult {
-    /** Root node details. */
-    root: RelationshipContextNodeDetails;
-    /** Counts-first overview of the packet. */
-    summary: RelationshipContextSummary;
-    /** Bounded related-node page. */
-    nodes: RelationshipContextNode[];
-    /** Bounded edges whose endpoints are present in the packet. */
-    edges: RelationshipEdge[];
-    /** Root evidence pointers promoted for immediate consumption. */
-    evidence: string[];
-    /** Completeness, continuation, and cost envelope. */
-    meta: {
-        exact: true;
-        truncated: boolean;
-        completeness: RelationshipContextCompleteness;
-        nodeLimit: number;
-        edgeLimit: number;
-        tokenBudget: number;
-        usedTokens: number;
-        visitedNodes: number;
-        inspectedEdges: number;
-        omittedNodes: number;
-        omittedEdges: number;
-        nextCursor?: string;
-    };
+/** Root node details. */
+root: RelationshipContextNodeDetails;
+/** Counts-first overview of the packet. */
+summary: RelationshipContextSummary;
+/** Bounded related-node page. */
+nodes: RelationshipContextNode[];
+/** Bounded edges whose endpoints are present in the packet. */
+edges: RelationshipEdge[];
+/** Root evidence pointers promoted for immediate consumption. */
+evidence: string[];
+/** Completeness, continuation, and cost envelope. */
+meta: {
+exact: true;
+truncated: boolean;
+completeness: RelationshipContextCompleteness;
+nodeLimit: number;
+edgeLimit: number;
+tokenBudget: number;
+usedTokens: number;
+visitedNodes: number;
+inspectedEdges: number;
+omittedNodes: number;
+omittedEdges: number;
+nextCursor?: string;
+};
 }
 /** Build one deterministic bounded graph-context packet with continuation. */
 export declare function buildRelationshipContext(graph: RelationshipGraph, rootId: string, details: readonly RelationshipContextNodeDetails[], options?: RelationshipContextOptions): RelationshipContextResult;

package/dist/sdk/relationship-history.d.ts

@@ -3,140 +3,140 @@ import { RelationshipGraph, RelationshipKindRegistry, type RelationshipEdge } fr
 export type RelationshipEventAction = "add" | "remove" | "supersede";
 /** Caller-authored relationship mutation before its sequence is assigned. */
 export interface RelationshipEventInput {
-    /** Globally unique idempotency key for this event. */
-    eventId: string;
-    /** Stable logical relationship identifier across superseding events. */
-    relationshipId: string;
-    /** Append, remove, or replace the logical relationship. */
-    action: RelationshipEventAction;
-    /** Edge required for add and supersede actions. */
-    edge?: RelationshipEdge;
-    /** Attributable actor responsible for the mutation. */
-    author: string;
-    /** Valid event-time timestamp. */
-    timestamp: string;
-    /** Optional optimistic concurrency precondition. */
-    expectedVersion?: number;
-    /** Optional human-readable mutation rationale. */
-    reason?: string;
+/** Globally unique idempotency key for this event. */
+eventId: string;
+/** Stable logical relationship identifier across superseding events. */
+relationshipId: string;
+/** Append, remove, or replace the logical relationship. */
+action: RelationshipEventAction;
+/** Edge required for add and supersede actions. */
+edge?: RelationshipEdge;
+/** Attributable actor responsible for the mutation. */
+author: string;
+/** Valid event-time timestamp. */
+timestamp: string;
+/** Optional optimistic concurrency precondition. */
+expectedVersion?: number;
+/** Optional human-readable mutation rationale. */
+reason?: string;
 }
 /** One immutable sequenced relationship mutation. */
 export interface RelationshipEvent extends Omit<RelationshipEventInput, "expectedVersion"> {
-    /** One-based append sequence assigned by the ledger. */
-    sequence: number;
+/** One-based append sequence assigned by the ledger. */
+sequence: number;
 }
 /** Point-in-time materialized relationship view. */
 export interface RelationshipSnapshot {
-    /** Final event sequence included in this snapshot. */
-    version: number;
-    /** Timestamp of the final included event, when one exists. */
-    asOf?: string;
-    /** Deterministic active edge materialization. */
-    edges: readonly RelationshipEdge[];
-    /** Immutable graph query view over the active edges. */
-    graph: RelationshipGraph;
+/** Final event sequence included in this snapshot. */
+version: number;
+/** Timestamp of the final included event, when one exists. */
+asOf?: string;
+/** Deterministic active edge materialization. */
+edges: readonly RelationshipEdge[];
+/** Immutable graph query view over the active edges. */
+graph: RelationshipGraph;
 }
 /** Stable cursor page over a fixed relationship event-log version. */
 export interface RelationshipEventPage {
-    /** Log version against which this page was produced. */
-    version: number;
-    /** Events in append order. */
-    events: RelationshipEvent[];
-    /** Whether another event page exists. */
-    hasMore: boolean;
-    /** Opaque continuation cursor when another page exists. */
-    nextCursor?: string;
+/** Log version against which this page was produced. */
+version: number;
+/** Events in append order. */
+events: RelationshipEvent[];
+/** Whether another event page exists. */
+hasMore: boolean;
+/** Opaque continuation cursor when another page exists. */
+nextCursor?: string;
 }
 /** Bounded controls for deterministic relationship-event batch iteration. */
 export interface RelationshipEventStreamOptions {
-    /** One-based first event version to include. */
-    fromVersion?: number;
-    /** One-based final event version to include. */
-    toVersion?: number;
-    /** Maximum number of events yielded in each immutable batch. */
-    batchSize?: number;
+/** One-based first event version to include. */
+fromVersion?: number;
+/** One-based final event version to include. */
+toVersion?: number;
+/** Maximum number of events yielded in each immutable batch. */
+batchSize?: number;
 }
 /** Result of folding an immutable relationship-event prefix into domain state. */
 export interface RelationshipEventProjection<State> {
-    /** Final projected state returned by the caller-owned reducer. */
-    state: State;
-    /** Final event sequence included in the projection. */
-    version: number;
-    /** Number of events processed by this projection. */
-    processed: number;
-    /** Timestamp of the final included event, when one exists. */
-    asOf?: string;
+/** Final projected state returned by the caller-owned reducer. */
+state: State;
+/** Final event sequence included in the projection. */
+version: number;
+/** Number of events processed by this projection. */
+processed: number;
+/** Timestamp of the final included event, when one exists. */
+asOf?: string;
 }
 /** Pure reducer used to derive application state from relationship events. */
 export type RelationshipEventReducer<State> = (state: State, event: RelationshipEvent) => State;
 /** Construction controls for the in-memory reference ledger. */
 export interface RelationshipEventLogOptions {
-    /** Registry defining edge semantics and cardinality. */
-    registry?: RelationshipKindRegistry;
+/** Registry defining edge semantics and cardinality. */
+registry?: RelationshipKindRegistry;
 }
 /** Filesystem controls for the durable relationship event store. */
 export interface RelationshipEventStoreOptions extends RelationshipEventLogOptions {
-    /** Tracker root that owns the relationship history directory. */
-    pmRoot: string;
-    /** Fixed node universe validated by every replay and append. */
-    nodes: Iterable<string>;
-    /** Optional JSONL path relative to the tracker root. */
-    relativePath?: string;
+/** Tracker root that owns the relationship history directory. */
+pmRoot: string;
+/** Fixed node universe validated by every replay and append. */
+nodes: Iterable<string>;
+/** Optional JSONL path relative to the tracker root. */
+relativePath?: string;
 }
 /** Collision policy applied while publishing a durable event batch. */
 export type RelationshipExistingEventPolicy = "error" | "skip_identical";
 /** Controls for one atomic durable relationship-event batch. */
 export interface RelationshipEventBatchOptions {
-    /**
+/**
      * Existing event ids fail by default. Migration resume flows may skip an id
      * only when every persisted semantic field is identical to the input.
      */
-    existingEventPolicy?: RelationshipExistingEventPolicy;
+existingEventPolicy?: RelationshipExistingEventPolicy;
 }
 /** Result of one validated, atomic durable relationship-event batch. */
 export interface RelationshipEventBatchResult {
-    /** Durable stream version observed while holding the writer lock. */
-    version_before: number;
-    /** Durable stream version after the atomic publication. */
-    version_after: number;
-    /** Immutable sequenced events newly published by this call. */
-    appended: readonly RelationshipEvent[];
-    /** Existing byte-equivalent event ids skipped by resume mode. */
-    skipped_event_ids: readonly string[];
+/** Durable stream version observed while holding the writer lock. */
+version_before: number;
+/** Durable stream version after the atomic publication. */
+version_after: number;
+/** Immutable sequenced events newly published by this call. */
+appended: readonly RelationshipEvent[];
+/** Existing byte-equivalent event ids skipped by resume mode. */
+skipped_event_ids: readonly string[];
 }
 /**
  * Append-only in-memory reference ledger. Durable adapters can persist the
  * returned immutable events while reusing the same replay and validation model.
  */
 export declare class RelationshipEventLog {
-    #private;
-    /** Create an empty relationship ledger for a fixed node universe. */
-    constructor(nodes: Iterable<string>, options?: RelationshipEventLogOptions);
-    /** Current append sequence. */
-    get version(): number;
-    /** Return an immutable copy of the full event stream. */
-    events(): readonly RelationshipEvent[];
-    /**
+#private;
+/** Create an empty relationship ledger for a fixed node universe. */
+constructor(nodes: Iterable<string>, options?: RelationshipEventLogOptions);
+/** Current append sequence. */
+get version(): number;
+/** Return an immutable copy of the full event stream. */
+events(): readonly RelationshipEvent[];
+/**
      * Iterate a stable event prefix in immutable, bounded batches. Consumers can
      * build streaming projections without copying or exposing the mutable ledger.
      * `fromVersion === toVersion + 1` is the intentional empty checkpoint range;
      * larger watermarks are rejected as invalid for the selected prefix.
      */
-    stream(options?: RelationshipEventStreamOptions): Generator<readonly RelationshipEvent[]>;
-    /** Fold a selected immutable event prefix into caller-owned domain state. */
-    project<State>(initialState: State, reducer: RelationshipEventReducer<State>, options?: Omit<RelationshipEventStreamOptions, "batchSize">): RelationshipEventProjection<State>;
-    /** Validate and append one attributable relationship mutation. */
-    append(input: RelationshipEventInput): RelationshipEvent;
-    /** Materialize an exact point-in-time graph without mutating the ledger. */
-    snapshot(options?: {
-        atVersion?: number;
-        atTimestamp?: string;
-    }): RelationshipSnapshot;
-    /** Page the immutable event stream with a cursor bound to this log version. */
-    page(options: {
-        limit: number;
-        cursor?: string;
-    }): RelationshipEventPage;
+stream(options?: RelationshipEventStreamOptions): Generator<readonly RelationshipEvent[]>;
+/** Fold a selected immutable event prefix into caller-owned domain state. */
+project<State>(initialState: State, reducer: RelationshipEventReducer<State>, options?: Omit<RelationshipEventStreamOptions, "batchSize">): RelationshipEventProjection<State>;
+/** Validate and append one attributable relationship mutation. */
+append(input: RelationshipEventInput): RelationshipEvent;
+/** Materialize an exact point-in-time graph without mutating the ledger. */
+snapshot(options?: {
+atVersion?: number;
+atTimestamp?: string;
+}): RelationshipSnapshot;
+/** Page the immutable event stream with a cursor bound to this log version. */
+page(options: {
+limit: number;
+cursor?: string;
+}): RelationshipEventPage;
 }
 /**
  * Lock-serialized durable JSONL adapter for {@link RelationshipEventLog}.
@@ -144,17 +144,17 @@ export declare class RelationshipEventLog {
  * independent processes share optimistic versions without lost updates.
  */
 export declare class RelationshipEventStore {
-    #private;
-    private constructor();
-    /** Open and validate an existing stream or create an empty store view. */
-    static open(options: RelationshipEventStoreOptions): Promise<RelationshipEventStore>;
-    /** Absolute JSONL path, exposed for diagnostics and backup tooling. */
-    get path(): string;
-    /** Refresh from durable history and return the current validated append sequence. */
-    currentVersion(): Promise<number>;
-    /** Append one event after refreshing under the shared workspace lock. */
-    append(input: RelationshipEventInput): Promise<RelationshipEvent>;
-    /**
+#private;
+private constructor();
+/** Open and validate an existing stream or create an empty store view. */
+static open(options: RelationshipEventStoreOptions): Promise<RelationshipEventStore>;
+/** Absolute JSONL path, exposed for diagnostics and backup tooling. */
+get path(): string;
+/** Refresh from durable history and return the current validated append sequence. */
+currentVersion(): Promise<number>;
+/** Append one event after refreshing under the shared workspace lock. */
+append(input: RelationshipEventInput): Promise<RelationshipEvent>;
+/**
      * Validate and publish a relationship-event batch as one durable replacement.
      * The shared writer lock covers refresh, collision checks, full in-memory
      * validation, and atomic rename. A validation or filesystem failure therefore
@@ -162,16 +162,16 @@ export declare class RelationshipEventStore {
      * intended for migrations and bulk imports; latency-sensitive single events
      * should continue to use {@link append} and its O_APPEND write.
      */
-    appendBatch(inputs: readonly RelationshipEventInput[], options?: RelationshipEventBatchOptions): Promise<RelationshipEventBatchResult>;
-    /** Refresh from durable history and materialize an exact validated snapshot. */
-    snapshot(options?: Parameters<RelationshipEventLog["snapshot"]>[0]): Promise<RelationshipSnapshot>;
-    /** Refresh from durable history and page immutable events. */
-    page(options: Parameters<RelationshipEventLog["page"]>[0]): Promise<RelationshipEventPage>;
-    /**
+appendBatch(inputs: readonly RelationshipEventInput[], options?: RelationshipEventBatchOptions): Promise<RelationshipEventBatchResult>;
+/** Refresh from durable history and materialize an exact validated snapshot. */
+snapshot(options?: Parameters<RelationshipEventLog["snapshot"]>[0]): Promise<RelationshipSnapshot>;
+/** Refresh from durable history and page immutable events. */
+page(options: Parameters<RelationshipEventLog["page"]>[0]): Promise<RelationshipEventPage>;
+/**
      * Refresh once under the shared store lock, then stream a coherent immutable
      * prefix without holding the writer lock while the consumer processes batches.
      */
-    stream(options?: RelationshipEventStreamOptions): AsyncGenerator<readonly RelationshipEvent[]>;
-    /** Refresh once and fold a coherent durable prefix into application state. */
-    project<State>(initialState: State, reducer: RelationshipEventReducer<State>, options?: Omit<RelationshipEventStreamOptions, "batchSize">): Promise<RelationshipEventProjection<State>>;
+stream(options?: RelationshipEventStreamOptions): AsyncGenerator<readonly RelationshipEvent[]>;
+/** Refresh once and fold a coherent durable prefix into application state. */
+project<State>(initialState: State, reducer: RelationshipEventReducer<State>, options?: Omit<RelationshipEventStreamOptions, "batchSize">): Promise<RelationshipEventProjection<State>>;
 }

package/dist/sdk/relationship-kinds/contract.d.ts

@@ -21,40 +21,40 @@ export type RelationshipTraversalFamily = "hierarchy" | "ordering" | "semantic"
 export type RelationshipOutcomeTraversal = "source_to_target" | "target_to_source" | "both";
 /** Versioned semantic definition for a built-in or application-defined edge kind. */
 export interface RelationshipKindDefinition {
-    /** Canonical, case-insensitive kind identifier. */
-    kind: string;
-    /** Whether traversing source to target has distinct meaning from the reverse. */
-    direction: RelationshipDirection;
-    /** Default closure vocabulary; omitted custom definitions infer it from legacy flags. */
-    traversal?: RelationshipTraversalFamily;
-    /** Direction this kind contributes to typed outcome reachability, when any. */
-    outcomeTraversal?: RelationshipOutcomeTraversal;
-    /** Optional canonical kind used when traversing a directed edge in reverse. */
-    inverse?: string;
-    /** Whether the kind participates in execution-order cycle checks. */
-    ordering: boolean;
-    /** Optional chronological constraint; recurrence uses source-after-target without becoming scheduling precedence. */
-    temporalOrder?: RelationshipTemporalOrder;
-    /** Execution direction for ordering kinds; defaults to source before target. */
-    precedence?: RelationshipPrecedence;
-    /** Whether the kind contributes to structural ancestry. */
-    hierarchy: boolean;
-    /** Endpoint that represents the parent; defaults to source for custom kinds. */
-    hierarchyDirection?: RelationshipHierarchyDirection;
-    /** Maximum logical outgoing edges of this kind from one node. */
-    outgoing: RelationshipCardinality;
-    /** Maximum logical incoming edges of this kind to one node. */
-    incoming: RelationshipCardinality;
-    /** Edge replacement and retention behavior. */
-    lifecycle: RelationshipLifecycle;
-    /** JSON Schema for optional application-owned payloads. */
-    payloadSchema?: Readonly<Record<string, unknown>>;
-    /** Legacy spellings normalized to this definition. */
-    aliases?: readonly string[];
-    /** Compatibility version of this semantic contract. */
-    compatibilityVersion: number;
-    /** Whether source and target may be the same node. */
-    allowSelf: boolean;
+/** Canonical, case-insensitive kind identifier. */
+kind: string;
+/** Whether traversing source to target has distinct meaning from the reverse. */
+direction: RelationshipDirection;
+/** Default closure vocabulary; omitted custom definitions infer it from legacy flags. */
+traversal?: RelationshipTraversalFamily;
+/** Direction this kind contributes to typed outcome reachability, when any. */
+outcomeTraversal?: RelationshipOutcomeTraversal;
+/** Optional canonical kind used when traversing a directed edge in reverse. */
+inverse?: string;
+/** Whether the kind participates in execution-order cycle checks. */
+ordering: boolean;
+/** Optional chronological constraint; recurrence uses source-after-target without becoming scheduling precedence. */
+temporalOrder?: RelationshipTemporalOrder;
+/** Execution direction for ordering kinds; defaults to source before target. */
+precedence?: RelationshipPrecedence;
+/** Whether the kind contributes to structural ancestry. */
+hierarchy: boolean;
+/** Endpoint that represents the parent; defaults to source for custom kinds. */
+hierarchyDirection?: RelationshipHierarchyDirection;
+/** Maximum logical outgoing edges of this kind from one node. */
+outgoing: RelationshipCardinality;
+/** Maximum logical incoming edges of this kind to one node. */
+incoming: RelationshipCardinality;
+/** Edge replacement and retention behavior. */
+lifecycle: RelationshipLifecycle;
+/** JSON Schema for optional application-owned payloads. */
+payloadSchema?: Readonly<Record<string, unknown>>;
+/** Legacy spellings normalized to this definition. */
+aliases?: readonly string[];
+/** Compatibility version of this semantic contract. */
+compatibilityVersion: number;
+/** Whether source and target may be the same node. */
+allowSelf: boolean;
 }
 /** Stable built-in relationship ontology without graph or storage dependencies. */
 export declare const BUILTIN_RELATIONSHIP_KINDS: readonly RelationshipKindDefinition[];

package/dist/sdk/relationship-migration.d.ts

@@ -3,35 +3,35 @@ import type { RelationshipEventInput } from "./relationship-history.js";
 import type { RelationshipKindRegistry } from "./relationships.js";
 /** Controls for deterministic legacy relationship-event planning. */
 export interface RelationshipEventBackfillOptions {
-    /** Stable migration identity retained in generated event and relationship ids. */
-    migrationId: string;
-    /** Attributable actor responsible for the migration. */
-    author: string;
-    /** Valid event timestamp shared by the deterministic migration batch. */
-    timestamp: string;
-    /** Optional custom relationship ontology used during legacy normalization. */
-    registry?: RelationshipKindRegistry;
-    /** Event ids already committed by an earlier partial or concurrent run. */
-    existingEventIds?: Iterable<string>;
+/** Stable migration identity retained in generated event and relationship ids. */
+migrationId: string;
+/** Attributable actor responsible for the migration. */
+author: string;
+/** Valid event timestamp shared by the deterministic migration batch. */
+timestamp: string;
+/** Optional custom relationship ontology used during legacy normalization. */
+registry?: RelationshipKindRegistry;
+/** Event ids already committed by an earlier partial or concurrent run. */
+existingEventIds?: Iterable<string>;
 }
 /** Deterministic migration plan plus compact governance evidence. */
 export interface RelationshipEventBackfillPlan {
-    /** Caller-provided stable migration identity. */
-    migration_id: string;
-    /** SHA-256 identity of the complete normalized plan before resume filtering. */
-    fingerprint: string;
-    /** Fixed node universe required when opening a relationship event store. */
-    nodes: readonly string[];
-    /** Missing deterministic events that remain to be committed. */
-    events: readonly RelationshipEventInput[];
-    /** Total unique normalized edges represented by the complete plan. */
-    edge_count: number;
-    /** Events omitted because their deterministic ids already exist. */
-    skipped_existing_count: number;
-    /** Duplicate raw dependency identities found before graph deduplication. */
-    duplicate_dependency_rows: number;
-    /** Missing internal references retained as explicit placeholder nodes. */
-    dangling_reference_count: number;
+/** Caller-provided stable migration identity. */
+migration_id: string;
+/** SHA-256 identity of the complete normalized plan before resume filtering. */
+fingerprint: string;
+/** Fixed node universe required when opening a relationship event store. */
+nodes: readonly string[];
+/** Missing deterministic events that remain to be committed. */
+events: readonly RelationshipEventInput[];
+/** Total unique normalized edges represented by the complete plan. */
+edge_count: number;
+/** Events omitted because their deterministic ids already exist. */
+skipped_existing_count: number;
+/** Duplicate raw dependency identities found before graph deduplication. */
+duplicate_dependency_rows: number;
+/** Missing internal references retained as explicit placeholder nodes. */
+dangling_reference_count: number;
 }
 /**
  * Convert legacy item relationship fields into an immutable deterministic event