apsimo 1.3.0__tar.gz → 1.3.1__tar.gz

{apsimo-1.3.0 → apsimo-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apsimo
-Version: 1.3.0
+Version: 1.3.1
 Summary: Persistent identity, memory and autonomy for AI agents
 License-Expression: MIT
 Requires-Python: >=3.11
@@ -28,7 +28,7 @@ Requires-Dist: pandas>=2.0; extra == "vectors"
 Requires-Dist: pyarrow>=15.0; extra == "vectors"
 Requires-Dist: lancedb>=0.10; extra == "vectors"
 Provides-Extra: hermes
-Requires-Dist: apsimo-hermes<2,>=1.3.0; extra == "hermes"
+Requires-Dist: apsimo-hermes<2,>=1.3.1; extra == "hermes"
 Provides-Extra: mcp
 Requires-Dist: mcp[cli]<2,>=1.0; extra == "mcp"
 Provides-Extra: lancedb

{apsimo-1.3.0 → apsimo-1.3.1}/apsimo/api/authority.py

@@ -961,6 +961,7 @@ def compatible_scopes(method: str, path: str) -> frozenset[str]:
     if (method.upper(), path) in WORK_READ_SURFACE_V1 or (method.upper(), path) in {
         ("POST", "/v1/host/learning/correction"),
         ("POST", "/v1/host/response-guard/check"),
+        ("GET", "/v1/host/contacts/resolve"),
     }:
         return _API_ACCESS_COMPATIBILITY
     return _NO_COMPATIBILITY_SCOPES
@@ -1105,6 +1106,7 @@ def required_scope(method: str, path: str) -> str:
             return "charter:approval-decide"
         return "api:access"
     exact = {
+        ("GET", "/v1/host/contacts/resolve"): "turns:resolve-sender",
         ("GET", "/v1/host/admin/auth/status"): "auth:admin",
         ("GET", "/v1/host/contact-policy"): "contacts:policy-read",
         ("POST", "/v1/host/response-guard/check"): "response-guard:check",

{apsimo-1.3.0 → apsimo-1.3.1}/apsimo/api/routers/host.py

@@ -3907,6 +3907,26 @@ async def forget_turn_sources(body: SourceForgetRequest, request: Request = None
             "host_reconciliation": "pending_until_each_host_connects"}
 
 
+async def _resolve_scoped_sender_contact(authority, gateway: str, address: str):
+    """Read one verified handle within the credential's existing grants."""
+    platform = gateway.strip().lower()
+    if (not authority.authenticated or not authority.has_scope('turns:resolve-sender')
+            or platform not in authority.turn_ingress_platforms):
+        raise HTTPException(status_code=403, detail='Sender resolution is outside this transport grant')
+    if _contacts_store is None:
+        raise HTTPException(status_code=503, detail='Contact store not initialized')
+    from apsimo.contacts.identity_links import normalized_handle
+    try:
+        normalized_gateway, normalized_address = normalized_handle(platform, address)
+        contact = await _contacts_store.resolve_verified_handles(
+            normalized_gateway, [normalized_address])
+    except ValueError:
+        raise HTTPException(status_code=400, detail='Invalid sender handle') from None
+    if contact is None or contact.contact_id not in authority.person_ids:
+        raise HTTPException(status_code=404, detail='No enrolled contact for that handle')
+    return contact
+
+
 async def _ingest_turn_idempotently(
     body: TurnSyncRequest,
     request: Request | None = None,
@@ -3918,9 +3938,23 @@ async def _ingest_turn_idempotently(
     effects run. This is the server's final defense even when a host retries or
     two host integrations accidentally submit the same envelope.
     """
+    resolved_sender_contact_id = None
+    authority = request_authority(request)
+    if (body.sender is not None and not authority.legacy and authority.authenticated
+            and authority.has_scope('turns:resolve-sender')
+            and not (authority.allow_unscoped_api and authority.has_scope('api:access'))
+            and body.sender.platform.strip().lower() not in authority.attested_contact_platforms):
+        # Static transport enrollment cannot inherit the viewer on a failed
+        # lookup, or take the general resolver's canonical-ID/name fallbacks.
+        # Validate before checkpoints, reservations or any source write.
+        contact = await _resolve_scoped_sender_contact(
+            authority, body.sender.platform, body.sender.user_id)
+        resolved_sender_contact_id = contact.contact_id
+        body.context.contact_id = contact.contact_id
     turn_id = (body.context.turn_id or "").strip()
     if not turn_id:
-        return await _process_turn_sync(body, request=request), "unkeyed"
+        return await _process_turn_sync(body, request=request,
+            resolved_sender_contact_id=resolved_sender_contact_id), "unkeyed"
     if len(turn_id) > 256:
         raise HTTPException(
             status_code=422,
@@ -4010,7 +4044,8 @@ async def _ingest_turn_idempotently(
         ), "in_progress"
 
     try:
-        result = await _process_turn_sync(body, request=request)
+        result = await _process_turn_sync(body, request=request,
+            resolved_sender_contact_id=resolved_sender_contact_id)
     except BaseException as exc:
         ledger.mark_ambiguous(turn_id, digest, exc)
         raise
@@ -4177,6 +4212,8 @@ async def turns_sync_v2(
 async def _process_turn_sync(
     body: TurnSyncRequest,
     request: Request | None = None,
+    *,
+    resolved_sender_contact_id: str | None = None,
 ) -> TurnSyncResponse:
     # Keep direct blocks for canonical source storage. All existing text-only
     # cognition consumers receive only explicit text, never repr(base64/URLs).
@@ -4221,7 +4258,11 @@ async def _process_turn_sync(
         from apsimo.identity.participants import (
             SYSTEM_CONTACT_ID, ParticipantResolver, is_machine_turn,
         )
-        if body.sender is not None and _contacts_store is not None:
+        if resolved_sender_contact_id is not None:
+            body.context.contact_id = resolved_sender_contact_id
+            _resolution_method = "verified_handle"
+            _resolved_human_sender = True
+        elif body.sender is not None and _contacts_store is not None:
             _res = await ParticipantResolver(_contacts_store).resolve(
                 platform=body.sender.platform,
                 user_id=body.sender.user_id,
@@ -6282,7 +6323,7 @@ async def capture_introduction(body: ContactIntroRequest) -> ContactIntroRespons
 
 
 @router.get("/contacts/resolve", response_model=ContactResponse)
-async def resolve_contact_by_handle(gateway: str, address: str, create: bool = False) -> ContactResponse:
+async def resolve_contact_by_handle(gateway: str, address: str, request: Request, create: bool = False) -> ContactResponse:
     """Resolve a contact from a messaging handle (v0.21.2).
 
     Registered BEFORE /contacts/{contact_id} so it isn't shadowed by the
@@ -6298,6 +6339,14 @@ async def resolve_contact_by_handle(gateway: str, address: str, create: bool = F
     if _contacts_store is None:
         raise HTTPException(status_code=404, detail="Contact store not initialized")
     try:
+        authority = request_authority(request)
+        if not authority.legacy and not (
+                authority.allow_unscoped_api and authority.has_scope('api:access')):
+            # Fresh native profiles resolve only explicitly enrolled accounts.
+            # The memory provider's legacy create=true hint cannot provision a
+            # contact or expand the credential's person/transport grants here.
+            contact = await _resolve_scoped_sender_contact(authority, gateway, address)
+            return ContactResponse(**contact.to_dict())
         # Normalized, cross-gateway phone-identity resolution (a number is one contact regardless of
         # the transport it arrived on). find_by_handle stays exact-match for dedup callers.
         contact = await _contacts_store.resolve_messaging_handle(gateway, address)

{apsimo-1.3.0 → apsimo-1.3.1}/apsimo/cli.py

@@ -53,6 +53,7 @@ def main() -> None:
     # Backward compatibility
     init_p.add_argument("--host-framework", choices=["openclaw", "hermes", "claude-code", "codex", "crush", "standalone"], help="Host framework (deprecated: use --agent-harness or --mcp-harnesses)")
     init_p.add_argument("--contact-name", help="Contact name for this user")
+    init_p.add_argument("--owner-handle", action="append", metavar="CHANNEL=SENDER_ID", help="Enroll your exact Hermes sender ID when creating a private instance; repeat for each account")
     init_p.add_argument("--bind", default="127.0.0.1", help="Sidecar bind address (0.0.0.0 for all interfaces)")
     init_p.add_argument("--port", type=int, default=7777, help="Sidecar port")
     init_p.add_argument("--tier", type=int, choices=range(0, 8), metavar="TIER", help="Embedding tier (0-7)")

{apsimo-1.3.0 → apsimo-1.3.1}/apsimo/setup.py

@@ -1947,11 +1947,11 @@ def run_init(root_dir: str | None = None, args=None) -> int:
         root_dir: Root directory for config files
         args: Parsed argparse Namespace for non-interactive mode
     """
-    if (getattr(args, 'preferences_only', False) or getattr(args, 'preview', False)
+    if (getattr(args, 'owner_handle', None) or getattr(args, 'preferences_only', False) or getattr(args, 'preview', False)
             or getattr(args, 'whatsapp_read_receipts', None) is not None):
         if (getattr(args, 'no_harness', False) or getattr(args, 'mcp_harnesses', None)
                 or getattr(args, 'host_framework', None) not in (None, 'hermes')):
-            print('Hermes profile preferences cannot be combined with another harness setup.')
+            print('Hermes profile options cannot be combined with another harness setup.')
             return 1
         from apsimo.setup_hermes import run
         return run(root_dir, args)

{apsimo-1.3.0 → apsimo-1.3.1}/apsimo/setup_hermes.py

@@ -58,6 +58,33 @@ def _json(value):
     return json.dumps(value, indent=2, ensure_ascii=False) + '\n'
 
 
+def _owner_handles(args, ask, noninteractive):
+    """Local enrollment binds exact accounts; it does not configure channels."""
+    from .contacts.identity_links import normalized_handle
+    supplied = getattr(args, 'owner_handle', None)
+    values = list(supplied or [])
+    if not supplied and not noninteractive:
+        print('Optionally identify your own messaging accounts using Hermes sender IDs, not display names or group IDs.')
+        print('For example: telegram=123456789. Hermes continues to configure and authenticate each channel.')
+        while value := ask('Your account CHANNEL=SENDER_ID (blank to finish)'):
+            values.append(value)
+    handles, platforms = [], set()
+    for value in values:
+        platform, separator, address = value.partition('=')
+        platform, address = platform.strip().lower(), address.strip()
+        if (not separator or not re.fullmatch(r'[a-z0-9][a-z0-9_.-]{0,63}', platform)
+                or platform in {'cli', 'internal', 'system', 'background_review', 'colony_task'}
+                or any(ord(char) < 32 or ord(char) == 127 for char in address)):
+            raise ValueError('--owner-handle requires CHANNEL=SENDER_ID for your authenticated messaging account')
+        gateway, address = normalized_handle(platform, address)
+        if not address or address == '+':
+            raise ValueError('--owner-handle requires a nonempty sender ID')
+        if (gateway, address) not in handles:
+            handles.append((gateway, address))
+        platforms.add(platform)
+    return handles, sorted(platforms)
+
+
 def _receipt_preference(config, choice):
     """Project one native shared key, respecting Hermes' existing YAML layouts.
 
@@ -563,7 +590,7 @@ def run(root_dir=None, args=None):
             if root_dir or any(getattr(args, name, None) for name in (
                     'start', 'refresh_adapter', 'replace_memory_provider', 'local_work',
                     'native_goals', 'native_reviews', 'model_url', 'model', 'adapter_wheel', 'agent_name',
-                    'agent_values', 'timezone', 'quiet_hours', 'contact_name', 'encrypt',
+                    'agent_values', 'timezone', 'quiet_hours', 'contact_name', 'owner_handle', 'encrypt',
                     'passphrase', 'claim_genesis', 'mcp_harnesses', 'no_harness')) or (
                     getattr(args, 'host_framework', None) not in (None, 'hermes')):
                 raise ValueError('--preferences-only cannot be combined with instance or setup options')
@@ -593,6 +620,8 @@ def run(root_dir=None, args=None):
         if any((home/name).exists() for name in ('colony-memory.json', 'apsimo-memory.json')):
             raise ValueError('Existing native Apsimo settings need an explicit migration; select a new home')
         if (state/'instance.json').exists():
+            if getattr(args, 'owner_handle', None):
+                raise ValueError('--owner-handle is for a new private instance; existing owner bindings are retained')
             manifest = json.loads((state/'instance.json').read_text())
             if manifest.get('hermes_home') != str(home):
                 raise ValueError('This instance belongs to another Hermes home')
@@ -652,6 +681,7 @@ def run(root_dir=None, args=None):
         _preflight_outbox(home, resources)
         binding = _adapter_binding(python, resources)
         owner_name = ask('Your name', getattr(args, 'contact_name', None) or os.environ.get('USER', 'Owner'), True)
+        owner_handles, owner_platforms = _owner_handles(args, ask, noninteractive)
         agent_name = ask('Agent name', getattr(args, 'agent_name', None) or 'Assistant', True)
         agent_preferences = _agent_preferences(ask, args, config)
         endpoint = _endpoint(ask('Local model API root', getattr(args, 'model_url', None), True))
@@ -726,7 +756,11 @@ def run(root_dir=None, args=None):
                 store = SQLiteContactStore(ContactsConfig(sqlite_path=str(staged/'contacts.db')))
                 await store.connect()
                 try:
-                    return await setup.build_owner_contact(store, owner_name)
+                    contact_id = await setup.build_owner_contact(store, owner_name)
+                    for index, (gateway, address) in enumerate(owner_handles):
+                        await store.add_handle(contact_id, gateway, address,
+                            is_primary=index == 0, source='wizard', verified=True)
+                    return contact_id
                 finally:
                     await store.close()
             owner_id = asyncio.run(owner())
@@ -750,9 +784,11 @@ def run(root_dir=None, args=None):
             values = {('APSIMO_'+key[7:] if key.startswith('COLONY_') else key):value for key,value in values.items()}
             _private_write(staged/'.env', _native_environment(None, values))
             principal = {'principal': 'hermes-local', 'status': 'active', 'viewer_person_id': owner_id,
-                'audiences': ['viewer'], 'allow_unscoped_api': False, 'turn_ingress_platforms': ['cli'],
+                'audiences': ['viewer'], 'allow_unscoped_api': False, 'turn_ingress_platforms': ['cli', *owner_platforms],
                 'scopes': ['context:read', 'memory:read', 'memory:search', 'memory:write', 'turns:write'],
                 'credentials': [{'id': 'initial', 'secret': key, 'status': 'active'}]}
+            if owner_handles:
+                principal['scopes'].append('turns:resolve-sender')
             _private_write(staged/'api-keyring.json', _json({'version': 1, 'principals': [principal]}))
             model_configuration = {'provider': 'local', 'baseUrl': endpoint,
                 'apiKey': model_key, 'localHosts': local_hosts,
@@ -857,6 +893,8 @@ def run(root_dir=None, args=None):
         print(f'Private agent configured in {home}; state in {state}.')
         print('Adapter loading: ' + binding['mode'] + ' (canonical artifact bytes verified).')
         print('Canonical memory capture and recollection are enabled for new Hermes sessions.')
+        if owner_handles:
+            print('Owner accounts enrolled for: ' + ', '.join(owner_platforms) + '. Channel configuration and delivery still belong to Hermes.')
         print('Hermes hook output spill allowance is at least 65536 characters or already disabled; retrieval budgets are unchanged.')
         print('Source memory, temporal claims, contacts, commitments and self state persist without a graph.')
         print('Graph/vector recall and consequential background work are optional and currently disabled.')

{apsimo-1.3.0 → apsimo-1.3.1}/apsimo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apsimo
-Version: 1.3.0
+Version: 1.3.1
 Summary: Persistent identity, memory and autonomy for AI agents
 License-Expression: MIT
 Requires-Python: >=3.11
@@ -28,7 +28,7 @@ Requires-Dist: pandas>=2.0; extra == "vectors"
 Requires-Dist: pyarrow>=15.0; extra == "vectors"
 Requires-Dist: lancedb>=0.10; extra == "vectors"
 Provides-Extra: hermes
-Requires-Dist: apsimo-hermes<2,>=1.3.0; extra == "hermes"
+Requires-Dist: apsimo-hermes<2,>=1.3.1; extra == "hermes"
 Provides-Extra: mcp
 Requires-Dist: mcp[cli]<2,>=1.0; extra == "mcp"
 Provides-Extra: lancedb

{apsimo-1.3.0 → apsimo-1.3.1}/apsimo.egg-info/SOURCES.txt

@@ -707,6 +707,7 @@ tests/test_doctor.py
 tests/test_document_memory_guard.py
 tests/test_duckduckgo_provider.py
 tests/test_embedding_generations.py
+tests/test_enrolled_sender_turns.py
 tests/test_ensure_channel_id.py
 tests/test_env_risk.py
 tests/test_event_broadcasts.py
@@ -860,6 +861,7 @@ tests/test_router_tiers.py
 tests/test_runtime_model_observations.py
 tests/test_sandbox.py
 tests/test_scoped_api_authority.py
+tests/test_scoped_contact_resolution.py
 tests/test_secondary_review_contract.py
 tests/test_seed_retirement.py
 tests/test_selected_autonomy.py

{apsimo-1.3.0 → apsimo-1.3.1}/apsimo.egg-info/requires.txt

@@ -35,7 +35,7 @@ beautifulsoup4>=4.12
 neo4j>=5.18
 
 [hermes]
-apsimo-hermes<2,>=1.3.0
+apsimo-hermes<2,>=1.3.1
 
 [lancedb]
 lancedb>=0.6

{apsimo-1.3.0 → apsimo-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apsimo"
-version = "1.3.0"
+version = "1.3.1"
 description = "Persistent identity, memory and autonomy for AI agents"
 readme = "README.md"
 license = "MIT"
@@ -29,7 +29,7 @@ dependencies = [
 graph = ["neo4j>=5.18"]
 neo4j = ["neo4j>=5.18"]
 vectors = ["sentence-transformers>=3.0", "pandas>=2.0", "pyarrow>=15.0", "lancedb>=0.10"]
-hermes = ["apsimo-hermes>=1.3.0,<2"]
+hermes = ["apsimo-hermes>=1.3.1,<2"]
 mcp = ["mcp[cli]>=1.0,<2"]
 lancedb = ["lancedb>=0.6", "pyarrow>=14.0", "pandas>=2.0"]
 postgres = ["asyncpg>=0.29"]

apsimo-1.3.1/tests/test_enrolled_sender_turns.py

@@ -0,0 +1,94 @@
+"""Fresh transport grants admit only enrolled senders before source storage."""
+import asyncio
+import json
+import sqlite3
+from pathlib import Path
+
+from fastapi import FastAPI
+import httpx
+import pytest
+
+from apsimo import setup
+from apsimo.api.middleware import ApiKeyMiddleware
+from apsimo.api.routers import host
+from apsimo.contacts.config import ContactsConfig
+from apsimo.contacts.store import SQLiteContactStore
+from apsimo.turns import TurnIdempotencyLedger
+from test_native_setup import args, isolated_platform_environment  # Shared isolated wizard fixtures.
+
+
+@pytest.mark.parametrize('version', ['v1', 'v2'])
+def test_enrolled_sender_checked_before_turn_reservation(args, monkeypatch, version):
+    args.owner_handle = ['telegram=123456789']
+    assert setup.run_init(None, args) == 0
+    state = Path(args.hermes_home)/'apsimo'
+    principal = json.loads((state/'api-keyring.json').read_text())['principals'][0]
+    owner = principal['viewer_person_id']
+    monkeypatch.setenv('COLONY_STATE_DIR', str(state))
+    monkeypatch.setenv('COLONY_IDENTITY_SHADOW_CONTACTS', 'false')
+    for name in ('_graph', '_presence_store', '_context_provenance', '_telemetry', '_p8_runtime'):
+        monkeypatch.setattr(host, name, None)
+    ledger = TurnIdempotencyLedger(state/'turn-idempotency.db')
+
+    async def exercise():
+        store = SQLiteContactStore(ContactsConfig(sqlite_path=str(state/'contacts.db')))
+        await store.connect()
+        monkeypatch.setattr(host, '_contacts_store', store)
+        try:
+            guest = await store.create(display_name='Other account')
+            await store.add_handle(guest.contact_id, 'telegram', '987654321', verified=True)
+            await store.add_handle(owner, 'telegram', 'unverified', verified=False)
+            before_contacts = await store.list()
+            app = FastAPI()
+            app.include_router(host.router)
+            app.include_router(host.v2_router)
+            app.add_middleware(ApiKeyMiddleware, keyring_path=str(state/'api-keyring.json'))
+            headers = {'Authorization': 'Bearer ' + principal['credentials'][0]['secret']}
+
+            async def send(client, turn_id, platform, sender):
+                body = {'identity': {'host_id': 'fixture'},
+                    'context': {'contact_id': owner if sender is None else 'body-selected-person',
+                        'session_id': 'enrolled-source',
+                        'channel_id': platform + ':fixture', 'turn_id': turn_id}}
+                if sender is not None:
+                    body['sender'] = {'platform': platform, 'user_id': sender}
+                message = {'role': 'user', 'content': 'The archive reference is violet.'}
+                body.update(user_message=message, source_only=True)
+                if version == 'v1':
+                    return await client.post('/v1/host/turns/sync', json=body)
+                return await client.put('/v2/host/turns/' + turn_id, json=body)
+
+            async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app),
+                    base_url='http://fixture', headers=headers) as client:
+                denied = [('unknown', 'telegram', 'unknown', 404),
+                    ('canonical-id', 'telegram', owner, 404),
+                    ('other-person', 'telegram', '987654321', 404),
+                    ('unverified', 'telegram', 'unverified', 404),
+                    ('wrong-channel', 'whatsapp', '123456789', 403)]
+                for turn_id, platform, sender, code in denied:
+                    response = await send(client, turn_id, platform, sender)
+                    assert response.status_code == code, (turn_id, response.text)
+                with sqlite3.connect(ledger.db_path) as db:
+                    assert db.execute('SELECT count(*) FROM turn_sources').fetchone()[0] == 0
+                    assert db.execute('SELECT count(*) FROM turn_ingestion').fetchone()[0] == 0
+                assert await store.list() == before_contacts
+                response = await send(client, 'known-owner', 'telegram', '123456789')
+                assert response.status_code == (200 if version == 'v1' else 201), response.text
+                assert response.json()['source_recorded'] is True
+                replay = await send(client, 'known-owner', 'telegram', '123456789')
+                assert replay.status_code == 200 and replay.json()['source_recorded'] is True
+                with sqlite3.connect(ledger.db_path) as db:
+                    rows = db.execute('SELECT contact_id,messages_json FROM turn_sources').fetchall()
+                    assert len(rows) == 1 and rows[0][0] == owner
+                    assert json.loads(rows[0][1])[0]['content'] == 'The archive reference is violet.'
+                # Native CLI has no human sender ID. Its exact viewer binding
+                # still permits capture without inventing a transport handle.
+                response = await send(client, 'senderless-cli', 'cli', None)
+                assert response.status_code == (200 if version == 'v1' else 201), response.text
+                assert response.json()['source_recorded'] is True
+                with sqlite3.connect(ledger.db_path) as db:
+                    assert db.execute('SELECT contact_id FROM turn_sources WHERE turn_id=?',
+                        ('senderless-cli',)).fetchone() == (owner,)
+        finally:
+            await store.close()
+    asyncio.run(exercise())

{apsimo-1.3.0 → apsimo-1.3.1}/tests/test_native_setup.py

@@ -1,5 +1,6 @@
 """Guided native init preserves profiles and creates one private scoped instance."""
 import json
+import asyncio
 import os
 import socket
 from pathlib import Path
@@ -152,6 +153,98 @@ def test_new_private_instance_uses_canonical_resources_and_scoped_authority(args
     assert before == ((home/'config.yaml').read_bytes(), (state/'api-keyring.json').read_bytes())
 
 
+def test_enrolled_owner_accounts_resolve_through_the_generated_scoped_api(args, monkeypatch):
+    from fastapi import FastAPI
+    from apsimo.api.middleware import ApiKeyMiddleware
+    from apsimo.api.routers import host
+    from apsimo.contacts.config import ContactsConfig
+    from apsimo.contacts.store import SQLiteContactStore
+
+    home = Path(args.hermes_home)
+    home.mkdir(mode=0o700)
+    channels = {'telegram': {'enabled': True, 'allowed_users': ['123456789']}}
+    (home/'config.yaml').write_text(yaml.safe_dump(channels))
+    args.owner_handle = ['telegram=123456789', 'sms=+1 (202) 555-0198', 'telegram=123456789']
+    assert setup.run_init(None, args) == 0
+    state = home/'apsimo'
+    config = yaml.safe_load((home/'config.yaml').read_text())
+    assert config['telegram'] == channels['telegram']
+    assert config['plugins']['apsimo']['attested_system_platforms'] == ['cli']
+    principal = json.loads((state/'api-keyring.json').read_text())['principals'][0]
+    assert principal['turn_ingress_platforms'] == ['cli', 'sms', 'telegram']
+    assert 'turns:resolve-sender' in principal['scopes']
+    assert principal['allow_unscoped_api'] is False
+    assert 'api:access' not in principal['scopes']
+    owner_id = principal['viewer_person_id']
+
+    async def exercise():
+        store = SQLiteContactStore(ContactsConfig(sqlite_path=str(state/'contacts.db')))
+        await store.connect()
+        monkeypatch.setattr(host, '_contacts_store', store)
+        try:
+            handles = await store.get_handles(owner_id)
+            assert len(handles) == 2 and all(row.verified and row.source == 'wizard' for row in handles)
+            guest = await store.create(display_name='Other person')
+            await store.add_handle(guest.contact_id, 'telegram', '987654321', verified=True)
+            await store.add_handle(owner_id, 'telegram', '111111111', verified=False)
+            before = (await store.list(), await store.get_handles(owner_id))
+            app = FastAPI()
+            app.add_middleware(ApiKeyMiddleware, keyring_path=str(state/'api-keyring.json'))
+            app.include_router(host.router)
+            headers = {'Authorization': 'Bearer ' + principal['credentials'][0]['secret']}
+            async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url='http://setup') as client:
+                for gateway, address, create, status in [
+                    ('telegram', '123456789', False, 200),
+                    ('telegram', '123456789', True, 200),  # Memory provider's existing read call.
+                    ('sms', '+1 (202) 555-0198', True, 200),
+                    ('telegram', 'unknown', True, 404),
+                    ('telegram', '987654321', False, 404),
+                    ('telegram', '111111111', False, 404),
+                    ('telegram', '+12025550198', False, 404),  # No inferred cross-channel authority.
+                    ('whatsapp', '123456789', False, 403),
+                ]:
+                    response = await client.get('/v1/host/contacts/resolve', headers=headers,
+                        params={'gateway': gateway, 'address': address, 'create': str(create).lower()})
+                    assert response.status_code == status, response.text
+                    if status == 200:
+                        assert response.json()['contact_id'] == owner_id
+                denied = await client.get('/v1/host/contacts/resolve',
+                    params={'gateway': 'telegram', 'address': '123456789'})
+                assert denied.status_code == 401
+            assert before == (await store.list(), await store.get_handles(owner_id))
+        finally:
+            await store.close()
+    asyncio.run(exercise())
+
+    retained = ((state/'api-keyring.json').read_bytes(), (home/'config.yaml').read_bytes(),
+                (state/'contacts.db').read_bytes())
+    assert setup.run_init(None, args) == 1  # Enrollment arguments are never silently ignored on rerun.
+    assert retained == ((state/'api-keyring.json').read_bytes(), (home/'config.yaml').read_bytes(),
+                        (state/'contacts.db').read_bytes())
+    args.owner_handle = None
+    assert setup.run_init(None, args) == 0
+    assert retained == ((state/'api-keyring.json').read_bytes(), (home/'config.yaml').read_bytes(),
+                        (state/'contacts.db').read_bytes())
+
+
+@pytest.mark.parametrize('handle', ['telegram', '=123', 'telegram=', 'sms=letters',
+    'cli=owner', 'telegram=abc\n123', 'telegram=' + 'x' * 513])
+def test_bad_owner_enrollment_stops_before_probe_or_state(args, handle, monkeypatch):
+    args.owner_handle = [handle]
+    probe = Mock(side_effect=AssertionError('Invalid enrollment must precede model probing'))
+    monkeypatch.setattr(setup_hermes, '_verify_local_endpoint', probe)
+    assert setup.run_init(None, args) == 1
+    probe.assert_not_called()
+    assert not Path(args.hermes_home).exists()
+
+
+def test_guided_owner_enrollment_uses_the_same_normalized_bindings():
+    answers = iter(['email=Owner@Example.org', 'rcs=+1 (202) 555-0198', ''])
+    handles, platforms = setup_hermes._owner_handles(SimpleNamespace(), lambda *a: next(answers), False)
+    assert handles == [('email', 'owner@example.org'), ('sms', '+12025550198')]
+    assert platforms == ['email', 'rcs']
+
+
 def test_writable_ancestor_stops_before_endpoint_probe_or_attachment(args, tmp_path, monkeypatch, capsys):
     shared = tmp_path/'shared-parent'
     shared.mkdir(mode=0o775)

{apsimo-1.3.0 → apsimo-1.3.1}/tests/test_scoped_api_authority.py

@@ -545,11 +545,13 @@ async def test_turn_contact_is_validated_before_idempotent_ingestion(tmp_path, g
 
 
 @pytest.mark.asyncio
-async def test_sender_resolving_adapter_discards_initial_contact_claim(tmp_path, graph):
+async def test_sender_resolving_adapter_cannot_inherit_viewer_without_contact_store(tmp_path, graph):
     keyring = tmp_path / "keys.json"
-    _write_keyring(keyring, [_principal(scopes=[
+    principal = _principal(scopes=[
         "turns:write", "turns:resolve-sender"
-    ])])
+    ])
+    principal['turn_ingress_platforms'] = ['example-chat']
+    _write_keyring(keyring, [principal])
     app = _app(keyring)
     payload = _turn_payload("body-claim", "sender-turn")
     payload["sender"] = {
@@ -563,10 +565,10 @@ async def test_sender_resolving_adapter_discards_initial_contact_claim(tmp_path,
             json=payload,
         )
 
-    assert response.status_code == 200
-    # No contacts store is wired in this focused test, so the resolver cannot
-    # map the sender further. The untrusted body claim is still gone.
-    assert graph.turn_calls[0]["contact_id"] == "contact-owner"
+    assert response.status_code == 503
+    # Unavailable identity resolution cannot turn an unknown sender into the
+    # credential's default viewer or run ordinary conversation effects.
+    assert graph.turn_calls == []
 
 
 @pytest.mark.asyncio
@@ -930,8 +932,8 @@ async def test_resolved_sender_in_static_grant_needs_no_dynamic_platform_grant(
     from apsimo.events import journal as event_journal
 
     class Contacts:
-        async def resolve_messaging_handle(self, platform, user_id):
-            assert (platform, user_id) == ("voice", "owner-voice-handle")
+        async def resolve_verified_handles(self, platform, user_ids):
+            assert (platform, user_ids) == ("voice", ["owner-voice-handle"])
             return SimpleNamespace(contact_id="contact-owner")
 
         async def record_interaction(self, _contact_id):

apsimo-1.3.1/tests/test_scoped_contact_resolution.py

@@ -0,0 +1,48 @@
+"""The focused sender resolver preserves explicitly broad legacy clients."""
+import json
+
+from fastapi import FastAPI
+import httpx
+import pytest
+
+from apsimo.api.middleware import ApiKeyMiddleware
+from apsimo.api.routers import host
+from apsimo.contacts.config import ContactsConfig
+from apsimo.contacts.store import SQLiteContactStore
+
+
+@pytest.mark.asyncio
+async def test_legacy_resolver_scope_compatibility_is_explicit(tmp_path, monkeypatch):
+    store = SQLiteContactStore(ContactsConfig(sqlite_path=str(tmp_path/'contacts.db')))
+    await store.connect()
+    monkeypatch.setattr(host, '_contacts_store', store)
+    try:
+        owner = await store.create(display_name='Owner')
+        await store.add_handle(owner.contact_id, 'telegram', '123456789', verified=True)
+        keyring = tmp_path/'keyring.json'
+        keyring.write_text(json.dumps({'version': 1, 'principals': [{
+            'principal': name, 'status': 'active', 'viewer_person_id': owner.contact_id,
+            'audiences': ['viewer'], 'allow_unscoped_api': broad, 'scopes': ['api:access'],
+            'credentials': [{'id': 'test', 'status': 'active', 'secret': name + '-secret'}],
+        } for name, broad in [('broad', True), ('restricted', False)]]}))
+        keyring.chmod(0o600)
+        app = FastAPI()
+        app.add_middleware(ApiKeyMiddleware, keyring_path=str(keyring), api_key='legacy-secret')
+        app.include_router(host.router)
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url='http://test') as client:
+            for secret, status in [('legacy-secret', 200), ('broad-secret', 200), ('restricted-secret', 403)]:
+                response = await client.get('/v1/host/contacts/resolve',
+                    headers={'Authorization': 'Bearer ' + secret},
+                    params={'gateway': 'telegram', 'address': '123456789'})
+                assert response.status_code == status, response.text
+                if status == 200:
+                    assert response.json()['contact_id'] == owner.contact_id
+            # Retain the previously explicit broad provisioning behavior.
+            response = await client.get('/v1/host/contacts/resolve',
+                headers={'Authorization': 'Bearer broad-secret'},
+                params={'gateway': 'telegram', 'address': '987654321', 'create': 'true'})
+            assert response.status_code == 200, response.text
+            assert response.json()['contact_id'] != owner.contact_id
+            assert response.json()['interaction_allowed'] is False
+    finally:
+        await store.close()