agentengine-sdk-python 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

ksadk/memory/coordinator.py

@@ -129,6 +129,11 @@ class MemoryCoordinator:
                 latency_ms=0,
                 accounting_accuracy="opaque",
             )
+        # TTL / 状态过滤（长任务方案 §7.2）：过期与已 supersede 的记录不进召回。
+        now_iso = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+        active = [r for r in result.records if r.is_active_now(now_iso=now_iso)]
+        if len(active) != len(result.records):
+            result = replace(result, records=active)
         return result
 
     def list_core(self, request: CoreMemoryRequest) -> list[MemoryRecord]:
@@ -270,6 +275,11 @@ class MemoryCoordinator:
                 by_id[record.memory_id] = record
         return list(by_id.values())
 
+    def find_existing_for_candidate(self, candidate: MemoryCandidate) -> MemoryRecord | None:
+        """Return the active fact occupying the candidate's logical slot."""
+        records = self._find_active_slot_records(candidate)
+        return records[0] if records else None
+
     def propose_and_commit(
         self,
         candidate: MemoryCandidate,
@@ -346,7 +356,7 @@ class MemoryCoordinator:
             importance=candidate.importance,
             valid_from=now_iso,
             valid_to="",
-            expires_at="",
+            expires_at=candidate.expires_at,
             source_session_id="",
             source_event_ids=list(candidate.source_event_ids),
             source_seq_range=None,
@@ -359,17 +369,23 @@ class MemoryCoordinator:
                 "operation": evaluation.operation,
                 **({"slot_key": candidate.slot_key} if candidate.slot_key else {}),
                 **(
-                    {
-                        "supersedes": [
-                            item.memory_id for item in conflicting_records or [existing]
-                        ]
-                    }
+                    {"supersedes": [item.memory_id for item in conflicting_records or [existing]]}
                     if evaluation.operation == "update" and existing is not None
                     else {}
                 ),
             },
             created_at=now_iso,
             updated_at=now_iso,
+            # 长任务方案 §7.2：来源 Artifact / 敏感级别 / 写策略 / TTL / supersede 链。
+            source_artifact_refs=tuple(candidate.source_artifact_refs),
+            source_artifacts=tuple(candidate.source_artifacts),
+            sensitivity=candidate.sensitivity,
+            write_policy=candidate.write_policy,
+            supersedes=tuple(
+                item.memory_id for item in (conflicting_records or [existing]) if item is not None
+            )
+            if evaluation.operation == "update" and existing is not None
+            else (),
         )
         self._provider.upsert(
             record,

ksadk/memory/extraction.py

@@ -34,6 +34,14 @@ _PREFERENCE_CORRECTION = re.compile(
     re.IGNORECASE,
 )
 _PREFERENCE_SLOT = re.compile(r"(?:我|本人)?喜欢(?P<action>吃|喝|用|看|听|玩)")
+# 一般祈使纠偏（"以后报表不要用英文，请改成中文"）：语义边界不如动作型偏好
+# 清晰，但"否定旧值 + 指定新值"结构明确，仍按显式纠错（update）处理。
+_GENERAL_CORRECTION = re.compile(
+    r"(?:以后|今后)?(?P<subject>[一-龥A-Za-z0-9]{1,12})?"
+    r"(?:请)?(?:不要|别)(?P<old>.{1,20}?)[，,]?"
+    r"(?:请)?(?:改成|改为|换成|改用)(?P<new>.+?)(?:[。.!！]|$)",
+    re.IGNORECASE,
+)
 _HOBBY_DECLARATION = re.compile(
     r"(?:我|本人)?的?爱好(?P<correction>其实|现在|改)?(?:是|改成|变成)\s*(?P<value>.+?)"
     r"(?:[。.!！]|$)",
@@ -47,7 +55,16 @@ _IMPLICIT_PREFERENCE_PATTERNS: tuple[re.Pattern[str], ...] = (
     ),
 )
 # 工具稳定事实信号。
-_FACT_SIGNALS = ("confirmed", "最终确认", "final", "verified", "确认成功")
+_FACT_SIGNALS = (
+    "confirmed",
+    "最终确认",
+    "final",
+    "verified",
+    "确认成功",
+    "查询成功",
+    "已认证",
+    "已核实",
+)
 
 
 def _event_text(event: any) -> str:  # type: ignore[name-defined]
@@ -123,6 +140,28 @@ def propose_memory_candidates(
                         )
                     )
                     continue
+            general = _GENERAL_CORRECTION.search(text)
+            if general:
+                subject = (general.group("subject") or "").strip()
+                new_value = general.group("new").strip().strip("。.，, ")
+                if new_value:
+                    content = f"{subject}改为{new_value}" if subject else f"改为{new_value}"
+                    candidates.append(
+                        MemoryCandidate(
+                            candidate_id=f"cand_{uuid.uuid4().hex[:16]}",
+                            operation="update",
+                            memory_type="profile",
+                            scope=scope,
+                            scope_id=scope_id,
+                            content=content[:1000],
+                            confidence=0.9,
+                            importance=0.8,
+                            source_event_ids=[event_id],
+                            slot_key=derive_profile_slot_key(content),
+                            reason="explicit_user_correction",
+                        )
+                    )
+                    continue
             correction = _PREFERENCE_CORRECTION.search(text)
             if correction:
                 prefix = correction.group("prefix").strip()

ksadk/memory/models.py

@@ -19,7 +19,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Literal
+from typing import Any, Literal, Mapping
 
 __all__ = [
     "LongTermMemoryRecord",
@@ -127,6 +127,8 @@ class MemoryExtractionStatus:
     status: str
     searchable: bool = False
     message: str = ""
+    # Query failure does not prove that the previously submitted write failed.
+    error_code: str = ""
 
 
 def map_session_state(state: int | None) -> str:
@@ -176,7 +178,7 @@ class MemoryConflictError(MemoryOperationError):
 MEMORY_MODEL_VERSION = "v1"
 
 MemoryScope = Literal["user", "agent", "workspace", "org"]
-MemoryType = Literal["profile", "fact", "episode"]
+MemoryType = Literal["profile", "fact", "episode", "unknown"]
 MemoryStatus = Literal["active", "superseded", "deleted", "expired"]
 MemoryOperation = Literal["add", "update", "delete", "ignore"]
 MemorySearchStatus = Literal["ok", "not_configured", "timeout", "unauthorized", "failed"]
@@ -193,6 +195,50 @@ SensitiveLabel = Literal[
     "binary",
     "none",
 ]
+#: 敏感级别（长任务方案 §7.2）：none=可跨作用域；low=限同作用域；high=禁止入长期 Memory。
+SensitivityLevel = Literal["none", "low", "high"]
+#: 写策略（长任务方案 §7.2）：auto=管线自动提交；user_confirm=需用户确认；locked=只读。
+WritePolicy = Literal["auto", "user_confirm", "locked"]
+MemoryArtifactModality = Literal[
+    "text", "image", "audio", "video", "document", "binary"
+]
+
+
+@dataclass(frozen=True)
+class MemoryArtifactRef:
+    """长期记忆引用的多模态 Artifact 元数据。
+
+    这里只保存可审计的引用与内容指纹，绝不保存 base64、文件字节或签名下载
+    URL。真正的内容仍由 Artifact Store 按权限读取，默认不会进入 Prompt。
+    """
+
+    uri: str
+    mime_type: str
+    content_hash: str
+    size_bytes: int
+    modality: MemoryArtifactModality = "binary"
+
+    def __post_init__(self) -> None:
+        if not self.uri.startswith("artifact://"):
+            raise ValueError("Memory Artifact 必须使用 artifact:// 稳定引用")
+        if not self.mime_type or "/" not in self.mime_type:
+            raise ValueError("Memory Artifact 必须声明合法 MIME type")
+        if not self.content_hash or len(self.content_hash) < 16:
+            raise ValueError("Memory Artifact 必须携带内容哈希")
+        if self.size_bytes < 0:
+            raise ValueError("Memory Artifact size_bytes 不能为负数")
+
+    @classmethod
+    def from_value(cls, value: MemoryArtifactRef | Mapping[str, Any]) -> MemoryArtifactRef:
+        if isinstance(value, cls):
+            return value
+        return cls(
+            uri=str(value.get("uri") or ""),
+            mime_type=str(value.get("mime_type") or ""),
+            content_hash=str(value.get("content_hash") or ""),
+            size_bytes=int(value.get("size_bytes") or 0),
+            modality=str(value.get("modality") or "binary"),  # type: ignore[arg-type]
+        )
 
 
 @dataclass(frozen=True)
@@ -206,8 +252,8 @@ class MemoryRecord:
     content: str
     summary: str
     status: MemoryStatus
-    confidence: float
-    importance: float
+    confidence: float | None
+    importance: float | None
     valid_from: str
     valid_to: str
     expires_at: str
@@ -215,10 +261,26 @@ class MemoryRecord:
     source_event_ids: list[str]
     source_seq_range: tuple[int, int] | None
     content_hash: str
-    version: int
+    # None means the provider has no record revision/CAS contract.
+    version: int | None
     metadata: dict[str, Any] = field(default_factory=dict)
     created_at: str = ""
     updated_at: str = ""
+    # ---- 长任务方案 §7.2 兼容扩展（全部带默认值，additive） ----
+    #: 来源 Artifact 引用（大 Tool Result / 摘要正文不进正文，只留引用）。
+    source_artifact_refs: tuple[str, ...] = field(default=())
+    #: 多模态来源的结构化元数据。只含稳定引用，不含媒体正文或临时下载 URL。
+    source_artifacts: tuple[MemoryArtifactRef, ...] = field(default=())
+    #: 敏感级别：high 禁止入长期 Memory（须先脱敏）；low 限同作用域。
+    sensitivity: SensitivityLevel = "none"
+    #: 写策略：locked 记录只能显式解锁后更新；user_confirm 需用户确认。
+    write_policy: WritePolicy = "auto"
+    #: 本记录 supersede 的旧记录（审计链）。
+    supersedes: tuple[str, ...] = field(default=())
+
+    def __post_init__(self) -> None:
+        normalized = tuple(MemoryArtifactRef.from_value(item) for item in self.source_artifacts)
+        object.__setattr__(self, "source_artifacts", normalized)
 
     def is_active_now(self, *, now_iso: str = "") -> bool:
         if self.status != "active":
@@ -245,6 +307,17 @@ class MemoryCandidate:
     sensitive_labels: list[SensitiveLabel] = field(default_factory=list)
     reason: str = ""
     slot_key: str = ""
+    # ---- 长任务方案 §7.2 兼容扩展（additive） ----
+    source_artifact_refs: tuple[str, ...] = field(default=())
+    source_artifacts: tuple[MemoryArtifactRef, ...] = field(default=())
+    sensitivity: SensitivityLevel = "none"
+    write_policy: WritePolicy = "auto"
+    #: TTL（ISO 日期字符串；空 = 不过期）。时效数据必须有来源和 TTL（§7.3）。
+    expires_at: str = ""
+
+    def __post_init__(self) -> None:
+        normalized = tuple(MemoryArtifactRef.from_value(item) for item in self.source_artifacts)
+        object.__setattr__(self, "source_artifacts", normalized)
 
     def is_hard_rejected(self) -> bool:
         return any(label != "none" for label in self.sensitive_labels)
@@ -271,6 +344,12 @@ class MemorySearchResult:
     latency_ms: int
     accounting_accuracy: str
     truncated_by_budget: bool = False
+    #: Harness-side retrieval projection. Additive fields keep Provider contracts
+    #: stable while making semantic fallback visible to Studio/observability.
+    retrieval_strategy: str = "provider"
+    reranker_status: str = "not_configured"
+    semantic_scorer_status: str = "not_configured"
+    dedicated_reranker_status: str = "not_configured"
 
 
 @dataclass(frozen=True)

ksadk/memory/provider_resolver.py

@@ -32,6 +32,9 @@ def resolve_memory_provider(provider_ref: str) -> MemoryProviderLike:
     """
     ref = str(provider_ref or "").strip().lower()
 
+    if ref.startswith("binding://"):
+        raise ValueError("RESOURCE_MEMORY_BINDING_REQUIRES_ACTIVATION")
+
     if ref in ("local-inmemory", "inmemory"):
         from ksadk.memory.adk.backends.inmemory_ltm_backend import (
             InMemoryLTMBackend,
@@ -60,6 +63,11 @@ def resolve_memory_provider(provider_ref: str) -> MemoryProviderLike:
 
         return LongTermMemoryService.from_env()
 
+    if ref in ("local-postgres", "postgres"):
+        from ksadk.memory.providers.local_postgres import PostgresMemoryProvider
+
+        return PostgresMemoryProvider()
+
     # 默认：持久 SQLite（local-default / local-sqlite / 未知 ref）
     from ksadk.memory.providers.local_sqlite import (
         resolve_default_memory_provider,

ksadk/memory/providers/local_postgres.py

@@ -0,0 +1,200 @@
+"""Postgres 长期记忆 Provider（分布式后端，plan §9 / 方案 P1）。
+
+实现与 :class:`SqliteMemoryProvider` 相同的 MemoryProvider Protocol，
+但用 psycopg 连接 Postgres，支持多副本共享。
+
+依赖：``ksadk[postgres]`` extra（psycopg[binary]）。缺依赖时显式报错。
+
+配置：``KSADK_MEMORY_PROVIDER=local-postgres`` + ``KSADK_MEMORY_POSTGRES_DSN``
+或 ``KSADK_CHECKPOINT_DSN``（复用同一连接串）。
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+from typing import Any
+
+from ksadk.memory.models import (
+    CoreMemoryRequest,
+    MemoryCapabilities,
+    MemoryDeleteRequest,
+    MemoryDeleteResult,
+    MemoryRecord,
+    MemorySearchRequest,
+    MemorySearchResult,
+)
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS memory_records (
+    memory_id TEXT PRIMARY KEY,
+    tenant_id TEXT NOT NULL,
+    workspace_id TEXT NOT NULL,
+    scope TEXT NOT NULL,
+    scope_id TEXT NOT NULL,
+    memory_type TEXT NOT NULL DEFAULT 'fact',
+    content TEXT NOT NULL,
+    version INTEGER NOT NULL DEFAULT 1,
+    status TEXT NOT NULL DEFAULT 'active',
+    source_event_ids TEXT NOT NULL DEFAULT '[]',
+    sensitive_labels TEXT NOT NULL DEFAULT '[]',
+    confidence REAL NOT NULL DEFAULT 0.8,
+    importance REAL NOT NULL DEFAULT 0.6,
+    created_at REAL NOT NULL,
+    updated_at REAL NOT NULL,
+    expires_at REAL
+);
+CREATE INDEX IF NOT EXISTS idx_memory_scope
+ON memory_records (tenant_id, workspace_id, scope, scope_id);
+CREATE INDEX IF NOT EXISTS idx_memory_status
+ON memory_records (tenant_id, workspace_id, status);
+"""
+
+
+class PostgresMemoryProvider:
+    """Postgres 长期记忆 Provider（多副本共享，实现 MemoryProviderLike Protocol）。
+
+    与 :class:`SqliteMemoryProvider` 接口一致，但用 Postgres 连接。
+    线程安全：单连接 + per-thread lock（与 SQLite 版相同策略）。
+    ``last_error`` 供 Coordinator 区分"吞错返空"与"真无记忆"。
+    """
+
+    capabilities_def = MemoryCapabilities(
+        semantic_search=False,
+        keyword_search=True,
+        metadata_filter=True,
+        versioned_update=True,
+        hard_delete=True,
+        ttl=True,
+        max_record_chars=8192,
+    )
+
+    def __init__(
+        self,
+        *,
+        dsn: str | None = None,
+        tenant_id: str = "local",
+        workspace_id: str = "local",
+    ) -> None:
+        self._dsn = (
+            dsn
+            or os.getenv("KSADK_MEMORY_POSTGRES_DSN")
+            or os.getenv("KSADK_CHECKPOINT_DSN", "")
+        )
+        if not self._dsn:
+            raise RuntimeError(
+                "PostgresMemoryProvider 需要 DSN"
+                "（KSADK_MEMORY_POSTGRES_DSN 或 KSADK_CHECKPOINT_DSN）"
+            )
+        try:
+            import psycopg  # type: ignore[import-not-found]
+        except ImportError as exc:
+            raise RuntimeError(
+                "PostgresMemoryProvider 需要"
+                " ksadk[postgres] extra（psycopg[binary]）"
+            ) from exc
+        self._psycopg = psycopg
+        self._tenant_id = tenant_id
+        self._workspace_id = workspace_id
+        self._lock = threading.Lock()
+        self._conn = psycopg.connect(self._dsn, autocommit=True)
+        self._conn.execute(_SCHEMA)
+        self.last_error: str = ""
+
+    # ---- MemoryProvider Protocol ----
+
+    def capabilities(self) -> MemoryCapabilities:
+        return self.capabilities_def
+
+    def search(self, request: MemorySearchRequest) -> MemorySearchResult:
+        start = time.monotonic()
+        try:
+            with self._lock:
+                query = request.query.strip()
+                if not query:
+                    return MemorySearchResult(
+                        records=[],
+                        elapsed_ms=int((time.monotonic() - start) * 1000),
+                    )
+                # keyword search (ILIKE, Postgres 大小写不敏感)
+                pattern = f"%{query}%"
+                rows = self._conn.execute(
+                    """SELECT * FROM memory_records
+                       WHERE tenant_id = %s AND workspace_id = %s
+                         AND status = 'active'
+                         AND (content ILIKE %s)
+                       ORDER BY importance DESC, updated_at DESC
+                       LIMIT %s""",
+                    (self._tenant_id, self._workspace_id, pattern, request.top_k),
+                ).fetchall()
+                records = [self._row_to_record(row) for row in rows]
+                return MemorySearchResult(
+                    records=records,
+                    elapsed_ms=int((time.monotonic() - start) * 1000),
+                )
+        except Exception as exc:  # noqa: BLE001 - 不阻断主对话
+            self.last_error = str(exc)
+            return MemorySearchResult(records=[], elapsed_ms=int((time.monotonic() - start) * 1000))
+
+    def list_core(self, request: CoreMemoryRequest) -> list[MemoryRecord]:
+        try:
+            with self._lock:
+                rows = self._conn.execute(
+                    """SELECT * FROM memory_records
+                       WHERE tenant_id = %s AND workspace_id = %s
+                         AND status = 'active'
+                       ORDER BY importance DESC, updated_at DESC
+                       LIMIT %s""",
+                    (self._tenant_id, self._workspace_id, request.max_blocks),
+                ).fetchall()
+                return [self._row_to_record(row) for row in rows]
+        except Exception as exc:  # noqa: BLE001
+            self.last_error = str(exc)
+            return []
+
+    def delete(self, request: MemoryDeleteRequest) -> MemoryDeleteResult:
+        try:
+            with self._lock:
+                self._conn.execute(
+                    "DELETE FROM memory_records WHERE memory_id = %s"
+                    " AND scope = %s AND scope_id = %s",
+                    (request.memory_id, request.scope, request.scope_id),
+                )
+            return MemoryDeleteResult(deleted=True)
+        except Exception as exc:  # noqa: BLE001
+            self.last_error = str(exc)
+            return MemoryDeleteResult(deleted=False)
+
+    def close(self) -> None:
+        with self._lock:
+            if self._conn:
+                self._conn.close()
+
+    # ---- helpers ----
+
+    def _row_to_record(self, row: Any) -> MemoryRecord:
+        # psycopg Row 可按列名访问
+        import json
+
+        return MemoryRecord(
+            memory_id=row["memory_id"],
+            tenant_id=row["tenant_id"],
+            workspace_id=row["workspace_id"],
+            scope=row["scope"],
+            scope_id=row["scope_id"],
+            memory_type=row["memory_type"],
+            content=row["content"],
+            version=row["version"],
+            status=row["status"],
+            source_event_ids=json.loads(row["source_event_ids"] or "[]"),
+            sensitive_labels=json.loads(row["sensitive_labels"] or "[]"),
+            confidence=row["confidence"],
+            importance=row["importance"],
+            created_at=row["created_at"],
+            updated_at=row["updated_at"],
+            expires_at=row["expires_at"],
+        )
+
+
+__all__ = ["PostgresMemoryProvider"]

ksadk/memory/providers/local_sqlite.py

@@ -16,12 +16,14 @@ import re
 import sqlite3
 import threading
 import time
+from dataclasses import asdict
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
 
 from ksadk.memory.models import (
     CoreMemoryRequest,
+    MemoryArtifactRef,
     MemoryCapabilities,
     MemoryDeleteRequest,
     MemoryDeleteResult,
@@ -82,6 +84,15 @@ def _row_to_record(row: sqlite3.Row) -> MemoryRecord:
         metadata=json.loads(row["metadata"] or "{}"),
         created_at=row["created_at"] or "",
         updated_at=row["updated_at"] or "",
+        # 长任务方案 §7.2 扩展列（additive migration）。
+        source_artifact_refs=tuple(json.loads(row["source_artifact_refs"] or "[]")),
+        source_artifacts=tuple(
+            MemoryArtifactRef.from_value(item)
+            for item in json.loads(row["source_artifacts"] or "[]")
+        ),
+        sensitivity=row["sensitivity"] or "none",
+        write_policy=row["write_policy"] or "auto",
+        supersedes=tuple(json.loads(row["supersedes"] or "[]")),
     )
 
 
@@ -115,6 +126,23 @@ CREATE INDEX IF NOT EXISTS idx_scope ON memory_records(tenant_id, workspace_id,
 CREATE INDEX IF NOT EXISTS idx_content_hash ON memory_records(content_hash);
 """
 
+#: 长任务方案 §7.2 扩展列（additive；老库经 ALTER TABLE 补列）。
+_EXTENSION_COLUMNS: tuple[tuple[str, str], ...] = (
+    ("source_artifact_refs", "TEXT NOT NULL DEFAULT '[]'"),
+    ("source_artifacts", "TEXT NOT NULL DEFAULT '[]'"),
+    ("sensitivity", "TEXT NOT NULL DEFAULT 'none'"),
+    ("write_policy", "TEXT NOT NULL DEFAULT 'auto'"),
+    ("supersedes", "TEXT NOT NULL DEFAULT '[]'"),
+)
+
+
+def _migrate(conn: sqlite3.Connection) -> None:
+    """给老库补扩展列（SQLite 无 IF NOT EXISTS for ADD COLUMN，逐列试加）。"""
+    existing = {r["name"] for r in conn.execute("PRAGMA table_info(memory_records)")}
+    for column, decl in _EXTENSION_COLUMNS:
+        if column not in existing:
+            conn.execute(f"ALTER TABLE memory_records ADD COLUMN {column} {decl}")
+
 
 class SqliteMemoryProvider:
     """本地 SQLite 长期记忆 Provider。
@@ -154,6 +182,7 @@ class SqliteMemoryProvider:
         self._conn = sqlite3.connect(self._db_path, check_same_thread=False)
         self._conn.row_factory = sqlite3.Row
         self._conn.executescript(_SCHEMA)
+        _migrate(self._conn)
         self._conn.commit()
         self.last_error: str = ""
         # 每次 Provider 启动执行一次有界清理；不在每次 recall/upsert 热路径扫描全表。
@@ -230,8 +259,9 @@ class SqliteMemoryProvider:
                     memory_id, tenant_id, workspace_id, scope, scope_id, memory_type,
                     content, summary, status, confidence, importance, valid_from, valid_to,
                     expires_at, source_session_id, source_event_ids, source_seq_range,
-                    content_hash, version, metadata, created_at, updated_at
-                ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
+                    content_hash, version, metadata, created_at, updated_at,
+                    source_artifact_refs, source_artifacts, sensitivity, write_policy, supersedes
+                ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
                 ON CONFLICT(memory_id) DO UPDATE SET
                     content=excluded.content, summary=excluded.summary, status=excluded.status,
                     confidence=excluded.confidence, importance=excluded.importance,
@@ -239,7 +269,11 @@ class SqliteMemoryProvider:
                     expires_at=excluded.expires_at, source_event_ids=excluded.source_event_ids,
                     source_seq_range=excluded.source_seq_range, content_hash=excluded.content_hash,
                     version=excluded.version, metadata=excluded.metadata,
-                        updated_at=excluded.updated_at
+                        updated_at=excluded.updated_at,
+                        source_artifact_refs=excluded.source_artifact_refs,
+                        source_artifacts=excluded.source_artifacts,
+                        sensitivity=excluded.sensitivity, write_policy=excluded.write_policy,
+                        supersedes=excluded.supersedes
                 """,
                 (
                     record.memory_id,
@@ -264,6 +298,11 @@ class SqliteMemoryProvider:
                     json.dumps(record.metadata, ensure_ascii=False),
                     created,
                     now,
+                    json.dumps(list(record.source_artifact_refs)),
+                    json.dumps([asdict(item) for item in record.source_artifacts]),
+                    record.sensitivity,
+                    record.write_policy,
+                    json.dumps(list(record.supersedes)),
                 ),
             )
             self._conn.commit()