@mastra/pg 1.31.0-alpha.2 → 1.31.0-alpha.4

package/dist/_types/@internal_core/dist/knowledge-compat/index.d.ts

@@ -0,0 +1,594 @@
+//#region src/knowledge-compat/index.d.ts
+declare const KNOWLEDGE_V2_CORE_FEATURE = "knowledge-v2";
+declare const KNOWLEDGE_STORAGE_CONTRACT_VERSION: 2;
+declare const KNOWLEDGE_STORAGE_SCHEMA_VERSION: 2;
+/** Hard cap on scope nodes returned by one `listScopeNodes` read. */
+declare const MAX_KNOWLEDGE_SCOPE_NODES = 1000;
+interface ListKnowledgeScopeNodesInput {
+  /** Only the scope at this address and the scopes beneath it, following parent edges transitively. */
+  withinAddress?: string;
+  /** Only the scopes at these exact addresses. */
+  addresses?: string[];
+  /** Only the scope nodes with these UUIDs. Combines with the other filters. */
+  ids?: string[];
+  /** `nextCursor` from the previous page of the same query. */
+  cursor?: string;
+  /** Page size, from 1 to `MAX_KNOWLEDGE_SCOPE_NODES` (the default). */
+  limit?: number;
+}
+interface ListKnowledgeScopeNodesOutput {
+  /** Scope nodes ordered by name, then id. */
+  scopes: KnowledgeScopeNodeSummary[];
+  /** Pass back as `cursor` for the next page; `null` when this is the last page. */
+  nextCursor: string | null;
+}
+declare function createKnowledgeScopeNodeCursor(scope: Pick<KnowledgeScopeNodeSummary, 'name' | 'id'>, input: ListKnowledgeScopeNodesInput): string;
+/** Validates the page size and cursor of a `listScopeNodes` query; throws on a cursor from a different query. */
+declare function parseListKnowledgeScopeNodesInput(input?: ListKnowledgeScopeNodesInput): {
+  limit: number;
+  after: {
+    name: string;
+    id: string;
+  } | null;
+};
+/** Builds a page from up to `limit + 1` name/id-ordered scope nodes. */
+declare function pageKnowledgeScopeNodes(rows: KnowledgeScopeNodeSummary[], limit: number, input: ListKnowledgeScopeNodesInput): ListKnowledgeScopeNodesOutput;
+/** A node placed inside a structural scope. Child scopes are members too, with `scope: null`. */
+interface KnowledgeScopeMember {
+  id: string;
+  type: 'node';
+  name: string;
+  kind: string;
+  content?: string;
+  description?: string;
+  scope: string[] | null;
+  version: number;
+  mergedInto?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+interface ListKnowledgeScopeMembersInput {
+  scopeNodeId: string;
+  /** `nextCursor` from the previous page for the same scope. */
+  cursor?: string;
+  /** Members to return, 1–500 (default 500). */
+  limit?: number;
+}
+interface ListKnowledgeScopeMembersOutput {
+  /** Most recently updated members first (ties by name, then ID), at most `limit`. */
+  members: KnowledgeScopeMember[];
+  /** True when the scope has more members than were returned. */
+  hasMore: boolean;
+  /** Pass as `cursor` to read the next page; `null` on the last page. */
+  nextCursor: string | null;
+}
+declare const MAX_KNOWLEDGE_SCOPE_MEMBERS_LIMIT = 500;
+/** Clamps a requested member limit to 1–{@link MAX_KNOWLEDGE_SCOPE_MEMBERS_LIMIT}. */
+declare function knowledgeScopeMembersLimit(limit: number | undefined): number;
+/** Validates the page size and cursor of a `listScopeMembers` query; throws on a cursor from another scope. */
+declare function parseListKnowledgeScopeMembersInput(input: ListKnowledgeScopeMembersInput): {
+  limit: number;
+  after: {
+    updatedAt: Date;
+    name: string;
+    id: string;
+  } | null;
+};
+/** Builds a page from up to `limit + 1` members in `listScopeMembers` order. */
+declare function pageKnowledgeScopeMembers(rows: KnowledgeScopeMember[], limit: number, input: ListKnowledgeScopeMembersInput): ListKnowledgeScopeMembersOutput;
+/** A reconciled structural scope node with its containing scope nodes. */
+interface KnowledgeScopeNodeSummary {
+  /** UUID of the `isScope` node. */
+  id: string;
+  /** Canonical address the scope node was reconciled from (e.g. `features:memory`). */
+  address: string;
+  name: string;
+  kind?: string;
+  description?: string;
+  /** UUIDs of the scope nodes that contain this scope (membership edges). */
+  parentIds: string[];
+}
+declare const TABLE_KNOWLEDGE_NODE_SCOPES = "mastra_knowledge_node_scopes";
+declare const TABLE_KNOWLEDGE_RECORD_SCOPES = "mastra_knowledge_record_scopes";
+declare const TABLE_KNOWLEDGE_SCOPE_GRANTS = "mastra_knowledge_scope_grants";
+declare const TABLE_KNOWLEDGE_ACCESS_STATE = "mastra_knowledge_access_state";
+declare const TABLE_KNOWLEDGE_SCOPE_ADDRESSES = "mastra_knowledge_scope_addresses";
+declare const TABLE_KNOWLEDGE_NODE_ADDRESSES = "mastra_knowledge_node_addresses";
+declare const TABLE_KNOWLEDGE_IMPORT_STATE = "mastra_knowledge_import_state";
+declare const TABLE_KNOWLEDGE_IMPORT_RUNS = "mastra_knowledge_import_runs";
+declare const TABLE_KNOWLEDGE_PROPOSALS = "mastra_knowledge_proposals";
+declare const KNOWLEDGE_TABLE_NAMES: readonly ["mastra_knowledge_nodes", "mastra_knowledge_records", "mastra_knowledge_mentions", "mastra_knowledge_activity", "mastra_knowledge_semantic_outbox", "mastra_knowledge_node_scopes", "mastra_knowledge_record_scopes", "mastra_knowledge_scope_grants", "mastra_knowledge_access_state", "mastra_knowledge_scope_addresses", "mastra_knowledge_node_addresses", "mastra_knowledge_import_state", "mastra_knowledge_import_runs", "mastra_knowledge_proposals"];
+/** Knowledge v1 tables with no v2 equivalent; an explicit schema reset drops them. */
+declare const RETIRED_KNOWLEDGE_TABLE_NAMES: readonly ['mastra_knowledge_cursors'];
+/** Tables and indexes published v1 adapters created for every app, whether or not it used Knowledge. */
+declare const PUBLISHED_KNOWLEDGE_V1_TABLE_NAMES: ReadonlySet<string>;
+declare const PUBLISHED_KNOWLEDGE_V1_INDEX_NAMES: ReadonlySet<string>;
+declare const KNOWLEDGE_V2_NODES_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly name: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly kind: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly isScope: {
+    readonly type: 'boolean';
+    readonly nullable: false;
+  };
+  readonly metadata: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly deletedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly deletedBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly type: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly canonicalName: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly content: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly description: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly mergedInto: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_RECORDS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly node: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly text: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly metadata: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly version: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly capturedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly updatedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly deletedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly deletedBy: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly when: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_MENTIONS_SCHEMA: {
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_records";
+      readonly column: 'id';
+    };
+  };
+  readonly targetNodeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly sourceType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_NODE_SCOPES_SCHEMA: {
+  readonly nodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly addedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_RECORD_SCOPES_SCHEMA: {
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_records";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly addedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_SCOPE_GRANTS_SCHEMA: {
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly scopeRefId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly role: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly canSuggest: {
+    readonly type: 'boolean';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_ACCESS_STATE_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly epoch: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly schemaVersion: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA: {
+  readonly address: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly scopeNodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+};
+declare const KNOWLEDGE_NODE_ADDRESSES_SCHEMA: {
+  readonly source: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly address: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly nodeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+};
+declare const KNOWLEDGE_IMPORT_STATE_SCHEMA: {
+  readonly importerId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly binding: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly key: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly value: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+};
+declare const KNOWLEDGE_IMPORT_RUNS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly importerId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly binding: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly importKind: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly triggerKind: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly status: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly error: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly transcriptThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly traceId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly queuedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly startedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly completedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_V2_ACTIVITY_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly action: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly targetType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly targetId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly contextScopeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_nodes";
+      readonly column: 'id';
+    };
+  };
+  readonly importRunId: {
+    readonly type: 'text';
+    readonly nullable: true;
+    readonly references: {
+      readonly table: "mastra_knowledge_import_runs";
+      readonly column: 'id';
+    };
+  };
+  readonly details: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+  readonly recordType: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly recordId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly scope: {
+    readonly type: 'jsonb';
+    readonly nullable: true;
+  };
+  readonly scopeKey: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly sourceThreadId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+};
+declare const KNOWLEDGE_PROPOSALS_SCHEMA: {
+  readonly id: {
+    readonly type: 'text';
+    readonly nullable: false;
+    readonly primaryKey: true;
+  };
+  readonly targetType: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly targetId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly action: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly changes: {
+    readonly type: 'jsonb';
+    readonly nullable: false;
+  };
+  readonly reason: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly proposerContextScopeId: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly expectedVersion: {
+    readonly type: 'integer';
+    readonly nullable: false;
+  };
+  readonly status: {
+    readonly type: 'text';
+    readonly nullable: false;
+  };
+  readonly reviewerContextScopeId: {
+    readonly type: 'text';
+    readonly nullable: true;
+  };
+  readonly reviewedAt: {
+    readonly type: 'timestamp';
+    readonly nullable: true;
+  };
+  readonly createdAt: {
+    readonly type: 'timestamp';
+    readonly nullable: false;
+  };
+};
+type KnowledgeSchemaInspection = {
+  status: 'compatible';
+  schemaVersion: typeof KNOWLEDGE_STORAGE_SCHEMA_VERSION;
+} | {
+  status: 'uninitialized';
+  schemaVersion: null;
+} | {
+  status: 'incompatible-reset-required';
+  schemaVersion: number | null;
+  reason: string;
+} | {
+  status: 'unavailable';
+  schemaVersion: null;
+  reason: string;
+};
+interface KnowledgeSchemaSnapshot {
+  available: boolean;
+  tableNames: readonly string[];
+  schemaVersion?: number;
+  reason?: string;
+}
+interface KnowledgeV2Core {
+  assertKnowledgeDescriptionWithinBound(description: string | undefined): void;
+  assertKnowledgeRecordTextWithinBound(text: string): void;
+  assertKnowledgeSchemaCompatible(inspection: KnowledgeSchemaInspection): void;
+  inspectKnowledgeSchema(snapshot: KnowledgeSchemaSnapshot): KnowledgeSchemaInspection;
+}
+declare function assertKnowledgeV2CoreSupport(features: ReadonlySet<string>): void;
+declare function createKnowledgeV2CoreLoader(features: ReadonlySet<string>, loadStorageModule: () => Promise<unknown>): () => Promise<KnowledgeV2Core>;
+//#endregion
+export { KNOWLEDGE_ACCESS_STATE_SCHEMA, KNOWLEDGE_IMPORT_RUNS_SCHEMA, KNOWLEDGE_IMPORT_STATE_SCHEMA, KNOWLEDGE_NODE_ADDRESSES_SCHEMA, KNOWLEDGE_NODE_SCOPES_SCHEMA, KNOWLEDGE_PROPOSALS_SCHEMA, KNOWLEDGE_RECORD_SCOPES_SCHEMA, KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA, KNOWLEDGE_SCOPE_GRANTS_SCHEMA, KNOWLEDGE_STORAGE_CONTRACT_VERSION, KNOWLEDGE_STORAGE_SCHEMA_VERSION, KNOWLEDGE_TABLE_NAMES, KNOWLEDGE_V2_ACTIVITY_SCHEMA, KNOWLEDGE_V2_CORE_FEATURE, KNOWLEDGE_V2_MENTIONS_SCHEMA, KNOWLEDGE_V2_NODES_SCHEMA, KNOWLEDGE_V2_RECORDS_SCHEMA, KnowledgeSchemaInspection, KnowledgeSchemaSnapshot, KnowledgeScopeMember, KnowledgeScopeNodeSummary, ListKnowledgeScopeMembersInput, ListKnowledgeScopeMembersOutput, ListKnowledgeScopeNodesInput, ListKnowledgeScopeNodesOutput, MAX_KNOWLEDGE_SCOPE_MEMBERS_LIMIT, MAX_KNOWLEDGE_SCOPE_NODES, PUBLISHED_KNOWLEDGE_V1_INDEX_NAMES, PUBLISHED_KNOWLEDGE_V1_TABLE_NAMES, RETIRED_KNOWLEDGE_TABLE_NAMES, TABLE_KNOWLEDGE_ACCESS_STATE, TABLE_KNOWLEDGE_IMPORT_RUNS, TABLE_KNOWLEDGE_IMPORT_STATE, TABLE_KNOWLEDGE_NODE_ADDRESSES, TABLE_KNOWLEDGE_NODE_SCOPES, TABLE_KNOWLEDGE_PROPOSALS, TABLE_KNOWLEDGE_RECORD_SCOPES, TABLE_KNOWLEDGE_SCOPE_ADDRESSES, TABLE_KNOWLEDGE_SCOPE_GRANTS, assertKnowledgeV2CoreSupport, createKnowledgeScopeNodeCursor, createKnowledgeV2CoreLoader, knowledgeScopeMembersLimit, pageKnowledgeScopeMembers, pageKnowledgeScopeNodes, parseListKnowledgeScopeMembersInput, parseListKnowledgeScopeNodesInput };
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/@internal_core/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-pg
 description: Documentation for @mastra/pg. Use when working with @mastra/pg APIs, configuration, or implementation.
 metadata:
   package: "@mastra/pg"
-  version: "1.31.0-alpha.2"
+  version: "1.31.0-alpha.4"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.31.0-alpha.2",
+  "version": "1.31.0-alpha.4",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

package/dist/docs/references/reference-storage-retention.md

@@ -95,29 +95,32 @@ Set the `retention` field on the store config.
 
 Each domain specifies its age-prunable tables and the timestamp column that anchors comparison, chosen so `maxAge` matches the meaning of the data. Append-only logs use creation time, live state uses last activity, and jobs or runs use completion time so in-flight work isn't pruned.
 
-| Domain            | Table key          | Anchor column    | `maxAge` measures                                                |
-| ----------------- | ------------------ | ---------------- | ---------------------------------------------------------------- |
-| `memory`          | `threads`          | `createdAt`      | Thread age                                                       |
-| `memory`          | `messages`         | `createdAt`      | Message age                                                      |
-| `memory`          | `resources`        | `createdAt`      | Resource age                                                     |
-| `threadState`     | `threadState`      | `updatedAt`      | Inactivity: state for still-active threads survives              |
-| `observability`   | `spans`            | `startedAt`      | Span age                                                         |
-| `observability`   | `metrics`          | `timestamp`      | Metric event age (vNext only)                                    |
-| `observability`   | `logs`             | `timestamp`      | Log event age (vNext only)                                       |
-| `observability`   | `scores`           | `timestamp`      | Score event age (vNext only)                                     |
-| `observability`   | `feedback`         | `timestamp`      | Feedback event age (vNext only)                                  |
-| `scores`          | `scorers`          | `createdAt`      | Score record age                                                 |
-| `workflows`       | `workflowSnapshot` | `updatedAt`      | Inactivity, suspended or long-running workflows survive          |
-| `backgroundTasks` | `backgroundTasks`  | `completedAt`    | Time since completion, in-flight tasks (`NULL`) are never pruned |
-| `experiments`     | `experiments`      | `completedAt`    | Time since completion, running experiments are never pruned      |
-| `notifications`   | `notifications`    | `createdAt`      | Notification age                                                 |
-| `harness`         | `sessions`         | `createdAt`      | Session record age                                               |
-| `schedules`       | `triggers`         | `actual_fire_at` | Fire-history age (epoch-ms column)                               |
+| Domain            | Table key          | Anchor column    | `maxAge` measures                                                                                                                |
+| ----------------- | ------------------ | ---------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `memory`          | `threads`          | `createdAt`      | Thread age                                                                                                                       |
+| `memory`          | `messages`         | `createdAt`      | Message age                                                                                                                      |
+| `memory`          | `resources`        | `createdAt`      | Resource age                                                                                                                     |
+| `memory`          | `runFences`        | `retiredAt`      | Time since the durable agent execution holding the fence settled. Fences of running executions (`NULL`) are never pruned         |
+| `threadState`     | `threadState`      | `updatedAt`      | Inactivity: state for still-active threads survives                                                                              |
+| `observability`   | `spans`            | `startedAt`      | Span age                                                                                                                         |
+| `observability`   | `metrics`          | `timestamp`      | Metric event age (vNext only)                                                                                                    |
+| `observability`   | `logs`             | `timestamp`      | Log event age (vNext only)                                                                                                       |
+| `observability`   | `scores`           | `timestamp`      | Score event age (vNext only)                                                                                                     |
+| `observability`   | `feedback`         | `timestamp`      | Feedback event age (vNext only)                                                                                                  |
+| `scores`          | `scorers`          | `createdAt`      | Score record age                                                                                                                 |
+| `workflows`       | `workflowSnapshot` | `updatedAt`      | Inactivity, suspended or long-running workflows survive                                                                          |
+| `workflows`       | `runOwnership`     | `updatedAt`      | Inactivity. A running durable agent execution renews its claim every 10 seconds, so keep `maxAge` well above its 30-second lease |
+| `backgroundTasks` | `backgroundTasks`  | `completedAt`    | Time since completion, in-flight tasks (`NULL`) are never pruned                                                                 |
+| `experiments`     | `experiments`      | `completedAt`    | Time since completion, running experiments are never pruned                                                                      |
+| `notifications`   | `notifications`    | `createdAt`      | Notification age                                                                                                                 |
+| `harness`         | `sessions`         | `createdAt`      | Session record age                                                                                                               |
+| `schedules`       | `triggers`         | `actual_fire_at` | Fire-history age (epoch-ms column)                                                                                               |
 
 > **Note:**
 >
 > - The memory `observational_memory` table has no timestamp anchor, so it can't be age-pruned and isn't a valid retention key.
 > - Experiments prune as whole units: an aged experiment's result rows are deleted together with it (results cascade with their parent), so a run is never left partially deleted. Retention doesn't have a separate `results` key.
+> - `runOwnership` and `runFences` hold the run fencing records of durable agents, one small record per run in each. If the `runOwnership` `maxAge` is too short, a running execution can lose its run, but an execution that lost a run still can't write. A fence is retired only when its execution settles, so the fence of a run that crashed and was never recovered is never pruned.
 > - For `schedules`, the growth table is the fire history (`schedule_triggers`, one row per fire): schedule definitions are config and aren't pruned.
 > - On PostgreSQL, timestamp anchors use the timezone-aware mirror columns (for example `createdAtZ`, `completedAtZ`).
 > - DuckDB observability stores append-only events for all five signals. Its `spans` policy uses the event `timestamp` column rather than `startedAt`.