Skip to content
Merged
Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
22 commits
Select commit Hold shift + click to select a range
e393793
feat(scope): add durable organization and bindings
PsiACE Sep 2, 2026
a1d0fb0
feat(migration): register existing runtime scopes
PsiACE Sep 2, 2026
99e4088
feat(artifact): publish exact revisions across scopes
PsiACE Sep 2, 2026
bbd4c4a
refactor(scope): replace project reporting with selections
PsiACE Sep 2, 2026
5cce29b
feat(integrations): resolve server-owned scopes
PsiACE Sep 2, 2026
14278d2
test(scope): verify selection and plugin contracts
PsiACE Sep 2, 2026
5d5b550
docs(scope): explain server-owned organization
PsiACE Sep 2, 2026
605701b
refactor(scope): remove legacy runtime migration
PsiACE Sep 2, 2026
d8a637d
fix(scope): retry bindings without savepoints
PsiACE Sep 2, 2026
325f20d
fix(scope): reject unregistered runtime partitions
PsiACE Sep 2, 2026
f45cc69
fix(scope): serialize hierarchy mutations
PsiACE Sep 2, 2026
056dd9e
fix(codex): guard operations by scope mode
PsiACE Sep 2, 2026
5e35afd
fix(publication): reject incomplete memory copies
PsiACE Sep 2, 2026
83f5235
chore: merge master into scope runtime
PsiACE Sep 2, 2026
3daf855
fix(ci): escape plugin shell variable safely
PsiACE Sep 2, 2026
74abed5
chore: merge latest master into scope runtime
PsiACE Sep 3, 2026
015dc00
chore: merge latest master into scope runtime
PsiACE Sep 3, 2026
befc32f
chore: merge latest master into scope runtime
PsiACE Sep 3, 2026
3a14f3a
fix(runtime): preserve referenced scope recall
PsiACE Sep 3, 2026
a7e5e7b
fix(publication): make delivery atomic
PsiACE Sep 3, 2026
94b388a
docs: use registered scope identifiers
PsiACE Sep 3, 2026
e02e10d
chore: merge latest master into scope runtime
PsiACE Sep 3, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
fix(publication): make delivery atomic
  • Loading branch information
PsiACE committed Sep 3, 2026
commit a7e5e7b2a612e0d1bd20c059a881a32b71b243d3
94 changes: 58 additions & 36 deletions src/powercontext/builtin/publication.py
Original file line number Diff line number Diff line change
Expand Up @@ -16,20 +16,22 @@

from __future__ import annotations

import asyncio
import hashlib
import secrets
from collections.abc import Callable, Mapping
from typing import Any

from pydantic import BaseModel, ConfigDict, field_validator, model_validator
from sqlalchemy import insert, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncConnection

from powercontext.artifacts import ArtifactAddress, ArtifactRef
from powercontext.builtin.artifacts.experience import Experience
from powercontext.builtin.persistence.artifacts import ArtifactRepository
from powercontext.builtin.persistence.codec import dump_model
from powercontext.builtin.persistence.database import AsyncDatabase
from powercontext.builtin.persistence.experience_index import ExperienceIndex
from powercontext.builtin.persistence.tables import ARTIFACT_PUBLICATIONS_TABLE
from powercontext.builtin.scope import ScopeApplication
from powercontext.errors import PowerContextError
Expand Down Expand Up @@ -95,52 +97,63 @@ def __init__(
artifacts: ArtifactRepository,
scopes: ScopeApplication,
*,
experience_index: ExperienceIndex,
id_factory: PublicationIdFactory | None = None,
) -> None:
self._database = database
self._artifacts = artifacts
self._scopes = scopes
self._experience_index = experience_index
self._id_factory = generate_publication_artifact_id if id_factory is None else id_factory
self._write_lock = asyncio.Lock()

async def publish(self, request: ArtifactPublicationRequest, /) -> ArtifactPublication:
async with self._write_lock:
return await self._publish(request)

async def _publish(self, request: ArtifactPublicationRequest) -> ArtifactPublication:
await self._scopes.get(request.source.scope_id)
await self._scopes.get(request.target_scope_id)
async with self._database.transaction() as connection:
source = await self._artifacts.get(connection, request.source.scope_id, request.source.artifact)
if source.family == "memory":
raise ArtifactPublicationUnsupportedError(source.family)
existing = await self._find_request(connection, request.target_scope_id, request.idempotency_key)
if existing is not None:
if existing.source != request.source:
raise ArtifactPublicationConflictError(request.idempotency_key)
return existing

content_digest = hashlib.sha256(dump_model(source.content, kind="artifact", name=source.family)).hexdigest()
target = await self._artifacts.copy_exact(
connection,
request.target_scope_id,
self._id_factory(),
request.source,
source,
content_digest,
)
publication = ArtifactPublication(
source=request.source,
target=ArtifactAddress(scope_id=request.target_scope_id, artifact=target.as_ref()),
content_digest=content_digest,
)
await connection.execute(
insert(ARTIFACT_PUBLICATIONS_TABLE).values(
**_publication_row(publication),
idempotency_key=request.idempotency_key,
)
try:
async with self._database.transaction() as connection:
return await self._publish(connection, request)
except IntegrityError:
async with self._database.transaction() as connection:
existing = await self._find_request(connection, request.target_scope_id, request.idempotency_key)
if existing is None:
raise
return _resolve_request(existing, request)

async def _publish(
self,
connection: AsyncConnection,
request: ArtifactPublicationRequest,
) -> ArtifactPublication:
source = await self._artifacts.get(connection, request.source.scope_id, request.source.artifact)
if source.family == "memory":
raise ArtifactPublicationUnsupportedError(source.family)
existing = await self._find_request(connection, request.target_scope_id, request.idempotency_key)
if existing is not None:
return _resolve_request(existing, request)

content_digest = hashlib.sha256(dump_model(source.content, kind="artifact", name=source.family)).hexdigest()
target = await self._artifacts.copy_exact(
connection,
request.target_scope_id,
self._id_factory(),
request.source,
source,
content_digest,
)
if isinstance(target, Experience):
await self._experience_index.replace(connection, request.target_scope_id, target)
publication = ArtifactPublication(
source=request.source,
target=ArtifactAddress(scope_id=request.target_scope_id, artifact=target.as_ref()),
content_digest=content_digest,
)
await connection.execute(
insert(ARTIFACT_PUBLICATIONS_TABLE).values(
**_publication_row(publication),
idempotency_key=request.idempotency_key,
)
return publication
)
return publication

async def get(self, target: ArtifactAddress, /) -> ArtifactPublication | None:
async with self._database.transaction() as connection:
Expand Down Expand Up @@ -187,6 +200,15 @@ def generate_publication_artifact_id() -> str:
return f"pub_{encoded}"


def _resolve_request(
existing: ArtifactPublication,
request: ArtifactPublicationRequest,
) -> ArtifactPublication:
if existing.source != request.source:
raise ArtifactPublicationConflictError(request.idempotency_key)
return existing


def _publication_row(publication: ArtifactPublication) -> dict[str, object]:
return {
"target_scope_id": publication.target.scope_id,
Expand Down
1 change: 1 addition & 0 deletions src/powercontext/builtin/runtime/relational.py
Original file line number Diff line number Diff line change
Expand Up @@ -370,6 +370,7 @@ def __init__(
database,
self.repositories.artifacts,
self.scopes,
experience_index=self.experience_index,
)
self._candidate_pipeline = candidate_pipeline
self.memory_extraction = candidate_pipeline is not None
Expand Down
139 changes: 133 additions & 6 deletions tests/builtin/test_publication.py
Original file line number Diff line number Diff line change
Expand Up @@ -19,8 +19,11 @@
import pytest

from powercontext.artifacts import ArtifactAddress, ArtifactRef
from powercontext.builtin.artifacts.experience import ExperienceContent, ExperienceDraft
from powercontext.builtin.artifacts.memory import MemoryEntryInput
from powercontext.builtin.persistence.artifacts import ArtifactRepository
from powercontext.builtin.persistence.errors import RepositoryNotFoundError
from powercontext.builtin.persistence.experience_index import NoExperienceIndex
from powercontext.builtin.persistence.sqlite import SQLiteConfig, SQLiteProfile
from powercontext.builtin.persistence.tables import BUILTIN_TABLES
from powercontext.builtin.publication import (
Expand All @@ -35,9 +38,25 @@
from tests.builtin.persistence.contract import Report, ReportContent, ReportDraft


def test_publication_copies_one_exact_revision_with_original_provenance() -> None:
class _IndexUnavailableError(RuntimeError):
pass


class _FailingExperienceIndex:
async def initialize(self, _connection, /) -> None:
pass

async def replace(self, _connection, _scope_id, _experience, /) -> None:
raise _IndexUnavailableError

async def search(self, _connection, _scope_id, _query, _limit, /):
return ()


def test_publication_copies_one_exact_revision_with_original_provenance(tmp_path) -> None:
async def scenario() -> None:
async with SQLiteProfile.open(SQLiteConfig(), tables=BUILTIN_TABLES) as profile:
config = SQLiteConfig(url=f"sqlite+aiosqlite:///{tmp_path / 'publication.db'}")
async with SQLiteProfile.open(config, tables=BUILTIN_TABLES) as profile:
scopes = ScopeApplication(profile.database)
source_scope = await scopes.create(
ScopeDraft(title="Source", summary="Private working state", idempotency_key="source")
Expand All @@ -49,7 +68,20 @@ async def scenario() -> None:
ScopeDraft(title="Relay", summary="Relayed result", idempotency_key="relay")
)
artifacts = ArtifactRepository((Report,))
publications = ArtifactPublicationApplication(profile.database, artifacts, scopes)
publications = (
ArtifactPublicationApplication(
profile.database,
artifacts,
scopes,
experience_index=NoExperienceIndex(),
),
ArtifactPublicationApplication(
profile.database,
artifacts,
scopes,
experience_index=NoExperienceIndex(),
),
)
async with profile.database.transaction() as connection:
first = await artifacts.create(
connection,
Expand All @@ -63,7 +95,7 @@ async def scenario() -> None:
target_scope_id=target_scope.scope_id,
idempotency_key="accepted-report",
)
results = await asyncio.gather(*(publications.publish(request) for _ in range(8)))
results = await asyncio.gather(*(publications[index % 2].publish(request) for index in range(8)))
published = results[0]
assert all(result == published for result in results)

Expand All @@ -81,7 +113,7 @@ async def scenario() -> None:
assert copied.lineage.publication_source == request.source
assert copied.lineage.publication_digest == published.content_digest

relayed = await publications.publish(
relayed = await publications[0].publish(
ArtifactPublicationRequest(
source=published.target,
target_scope_id=relay_scope.scope_id,
Expand All @@ -97,6 +129,95 @@ async def scenario() -> None:
asyncio.run(scenario())


def test_published_experience_is_searchable_in_target_scope_immediately() -> None:
async def scenario() -> None:
async with open_builtin_contexts(BuiltinConfig(database=SQLiteConfig())) as contexts:
source_scope = await contexts.scopes.create(
ScopeDraft(title="Source", summary="Private working state", idempotency_key="experience-source")
)
target_scope = await contexts.scopes.create(
ScopeDraft(title="Target", summary="Accepted result", idempotency_key="experience-target")
)
async with contexts.database.transaction() as connection:
source = await contexts.repositories.artifacts.create(
connection,
source_scope.scope_id,
"published-experience",
ExperienceDraft(
content=ExperienceContent(
situation="A publication crosses a Scope boundary.",
action="Copy the exact approved revision and its search projection.",
outcome="The target can recall the Experience immediately.",
lesson="Keep publication projection updates atomic.",
)
),
)

published = await contexts.publications.publish(
ArtifactPublicationRequest(
source=ArtifactAddress(scope_id=source_scope.scope_id, artifact=source.as_ref()),
target_scope_id=target_scope.scope_id,
idempotency_key="publish-experience",
)
)
hits = await contexts.search_experience(target_scope.scope_id, "projection updates atomic", 8)

assert tuple(hit.artifact_ref for hit in hits) == (published.target.artifact,)

asyncio.run(scenario())


def test_experience_publication_rolls_back_when_projection_update_fails() -> None:
async def scenario() -> None:
async with open_builtin_contexts(BuiltinConfig(database=SQLiteConfig())) as contexts:
source_scope = await contexts.scopes.create(
ScopeDraft(title="Source", summary="Private working state", idempotency_key="rollback-source")
)
target_scope = await contexts.scopes.create(
ScopeDraft(title="Target", summary="Accepted result", idempotency_key="rollback-target")
)
async with contexts.database.transaction() as connection:
source = await contexts.repositories.artifacts.create(
connection,
source_scope.scope_id,
"source-experience",
ExperienceDraft(
content=ExperienceContent(
situation="The search projection is unavailable.",
action="Abort the publication transaction.",
outcome="No partial target lifecycle remains.",
lesson="Keep derived state in the publication transaction.",
)
),
)
publications = ArtifactPublicationApplication(
contexts.database,
contexts.repositories.artifacts,
contexts.scopes,
experience_index=_FailingExperienceIndex(),
id_factory=lambda: "pub_rollback",
)
request = ArtifactPublicationRequest(
source=ArtifactAddress(scope_id=source_scope.scope_id, artifact=source.as_ref()),
target_scope_id=target_scope.scope_id,
idempotency_key="rollback-publication",
)

with pytest.raises(_IndexUnavailableError):
await publications.publish(request)

target = ArtifactAddress(
scope_id=target_scope.scope_id,
artifact=ArtifactRef(family="experience", artifact_id="pub_rollback", revision=1),
)
assert await publications.get(target) is None
async with contexts.database.transaction() as connection:
with pytest.raises(RepositoryNotFoundError):
await contexts.repositories.artifacts.get(connection, target.scope_id, target.artifact)

asyncio.run(scenario())


def test_publication_idempotency_key_cannot_select_another_revision() -> None:
async def scenario() -> None:
async with SQLiteProfile.open(SQLiteConfig(), tables=BUILTIN_TABLES) as profile:
Expand All @@ -108,7 +229,12 @@ async def scenario() -> None:
ScopeDraft(title="Target", summary="Accepted result", idempotency_key="target")
)
artifacts = ArtifactRepository((Report,))
publications = ArtifactPublicationApplication(profile.database, artifacts, scopes)
publications = ArtifactPublicationApplication(
profile.database,
artifacts,
scopes,
experience_index=NoExperienceIndex(),
)
async with profile.database.transaction() as connection:
first = await artifacts.create(
connection,
Expand Down Expand Up @@ -162,6 +288,7 @@ async def scenario() -> None:
contexts.database,
contexts.repositories.artifacts,
contexts.scopes,
experience_index=contexts.experience_index,
id_factory=lambda: "pub_blocked",
)
request = ArtifactPublicationRequest(
Expand Down