Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
fix(memory): retain same-Session delegated read access (#2023)
rkrkrkk59bd474a75b6
diff --git a/core/caller_context.py b/core/caller_context.pyindex c152fbc8c..fe7de3fae 100644--- a/core/caller_context.py+++ b/core/caller_context.py@@ -4,9 +4,42 @@ from __future__ import annotationsfrom dataclasses import dataclass, replaceimport json+import hashlib+import hmac+import secretsimport osfrom typing import Any, Mapping, Optional+AVIBE_CALLER_SESSION_PROOF_ENV = "AVIBE_CALLER_SESSION_PROOF"+_SESSION_PROOF_KEY = secrets.token_bytes(32)+++def _session_owner_proof(session_id: str, owner: Mapping[str, Any]) -> str:+ identity = json.dumps([session_id, owner["platform"], owner["user_id"]], separators=(",", ":"))+ return hmac.new(_SESSION_PROOF_KEY, identity.encode(), hashlib.sha256).hexdigest()+++def issue_caller_session_proof(session_id: str, *, turn_id: str | None = None) -> str | None:+ """Host-only proof of the exact execution's owner, stable across its turns."""+ from storage.message_deliveries import current_delivery_memory_owner++ from sqlalchemy.exc import SQLAlchemyError++ try:+ owner = current_delivery_memory_owner(session_id, turn_id=turn_id)+ except SQLAlchemyError:+ # Missing/unavailable durable execution identity must not interrupt an+ # ordinary Agent launch, and cannot authorize Memory delegation.+ return None+ return _session_owner_proof(session_id, owner) if owner else None+++def verify_caller_session_proof(session_id: str, proof: str, owner: Mapping[str, Any] | None) -> bool:+ return bool(session_id and proof and owner) and hmac.compare_digest(+ _session_owner_proof(session_id, owner).encode(), proof.encode()+ )++AVIBE_SESSION_ID_ENV = "AVIBE_SESSION_ID"AVIBE_RUN_ID_ENV = "AVIBE_RUN_ID"AVIBE_CALLER_SOURCE_ENV = "AVIBE_CALLER_SOURCE"@@ -408,14 +441,20 @@ def caller_context_from_platform_payload()workspace_id = _origin_workspace_id(platform, payload)- is_remote = platform == "avibe" and user_id.startswith("remote:")- resource_user_context: Optional[dict[str, Any]] = Nonemessage_metadata = payload.get("message_metadata")+ owner = message_metadata.get("delegated_memory_owner") if isinstance(message_metadata, Mapping) else None+ authorization_user_id = (+ _clean(owner.get("user_id"))+ if isinstance(owner, Mapping) and owner.get("platform") == platform+ else user_id+ )+ is_remote = platform == "avibe" and authorization_user_id.startswith("remote:")+ resource_user_context: Optional[dict[str, Any]] = Noneif is_remote and isinstance(message_metadata, Mapping):raw_resource_context = message_metadata.get(_RESOURCE_USER_CONTEXT_METADATA_KEY)if isinstance(raw_resource_context, Mapping):subject = _clean(raw_resource_context.get("sub"))- if subject and user_id == f"remote:{subject}":+ if subject and authorization_user_id == f"remote:{subject}":resource_user_context = dict(raw_resource_context)return CallerContext(@@ -458,4 +497,8 @@ def caller_env_for_platform_payload(return {}if session_stable_only:context = context.session_stable()- return context.to_env()+ env = context.to_env()+ proof = issue_caller_session_proof(context.session_id, turn_id=_clean((payload or {}).get("turn_token")) or None)+ if proof:+ env[AVIBE_CALLER_SESSION_PROOF_ENV] = proof+ return envdiff --git a/core/controller.py b/core/controller.pyindex 3f0d99c87..0b16c702c 100644--- a/core/controller.py+++ b/core/controller.py@@ -297,6 +297,7 @@ class Controller:self._removed_im_clients: Dict[str, BaseIMClient] = {}self._memory_scopes_by_session: Dict[str, tuple[str, str]] = {}self._memory_cli_facts_by_session: Dict[str, InboundTurnFacts] = {}+ self._memory_cli_read_contexts: Dict[str, dict[str, Any]] = {}self._memory_implementation_cli_sessions: set[str] = set()# Session tracking (must be initialized before handlers)@@ -3381,7 +3382,7 @@ class Controller:)def configure_memory_cli_session(self, context: MessageContext, *, admitted: bool) -> bool:- """Associate an admitted Agent session with its Memory read/write scope."""+ """Associate a turn with its ordinary or delegated read-only Memory scope."""if not bool(getattr(getattr(self.config, "memory", None), "enabled", False)):return False@@ -3395,6 +3396,31 @@ class Controller:if not isinstance(facts_by_session, dict):facts_by_session = {}self._memory_cli_facts_by_session = facts_by_session+ read_contexts = getattr(self, "_memory_cli_read_contexts", None)+ if not isinstance(read_contexts, dict):+ read_contexts = self._memory_cli_read_contexts = {}+ read_contexts.pop(caller.session_id, None)+ delegated_facts = None+ metadata = payload.get("message_metadata") or {}+ from storage.message_deliveries import delegated_memory_owner++ owner = delegated_memory_owner(metadata.get("delegated_memory_owner")) if isinstance(metadata, dict) else None+ trigger = payload.get("task_trigger_kind")+ if not admitted and owner and payload.get("delivery_source") == "harness" and isinstance(trigger, str) and trigger.strip():+ from avibe_memory.admission import InboundTurnFacts+ from storage.resource_access_service import metadata_allows_harness_runtime++ delegated_facts = InboundTurnFacts(+ platform=owner.get("platform"),+ user_id=owner.get("user_id"),+ is_dm=owner.get("is_dm") is True,+ )+ admitted = bool(+ metadata_allows_harness_runtime(metadata)+ and self._memory_admission().admits(delegated_facts)+ )+ if admitted:+ read_contexts[caller.session_id] = metadataimplementation_error = getattr(self, "_memory_implementation_error", None)implementation_sessions = getattr(self, "_memory_implementation_cli_sessions", None)if implementation_error is not None:@@ -3412,7 +3438,7 @@ class Controller:facts_by_session.pop(caller.session_id, None)return Falseadmission = self._memory_admission()- facts = self._memory_turn_facts(context)+ facts = delegated_facts or self._memory_turn_facts(context)principal_id = admission.principal_for(facts) if admitted else Noneproject_id = admission.project_for(facts) if admitted else Noneif principal_id is None or project_id is None:@@ -3429,7 +3455,19 @@ class Controller:return Truedef memory_scope_for_cli_session(self, session_id: str) -> Optional[tuple[str, str]]:- """Return the principal and project owned by an admitted Agent session."""+ """Keep explicit Agent writes behind their existing human-turn admission."""+ if session_id in getattr(self, "_memory_cli_read_contexts", {}):+ return None+ return self.memory_read_scope_for_cli_session(session_id)++ def memory_read_scope_for_cli_session(self, session_id: str) -> Optional[tuple[str, str]]:+ """Resolve reads using current identity/binding authorization."""+ metadata = getattr(self, "_memory_cli_read_contexts", {}).get(session_id)+ if metadata is not None:+ from storage.resource_access_service import metadata_allows_harness_runtime++ if not metadata_allows_harness_runtime(metadata):+ return Noneif not bool(getattr(getattr(self.config, "memory", None), "enabled", False)):return None@@ -3481,6 +3519,9 @@ class Controller:facts = getattr(self, "_memory_cli_facts_by_session", None)if isinstance(facts, dict):facts.pop(session_id, None)+ read_contexts = getattr(self, "_memory_cli_read_contexts", None)+ if isinstance(read_contexts, dict):+ read_contexts.pop(session_id, None)implementation_sessions = getattr(self, "_memory_implementation_cli_sessions", None)if isinstance(implementation_sessions, set):implementation_sessions.discard(session_id)diff --git a/core/internal_server.py b/core/internal_server.pyindex 52bb319dd..e17302e09 100644--- a/core/internal_server.py+++ b/core/internal_server.py@@ -484,6 +484,7 @@ def create_app(message_type="harness",text=text,metadata={+ **dict(submission_spec.get("message_metadata") or {}),SCHEDULED_PROVENANCE_KEY: capture_scheduled_provenance(context)@@ -1308,13 +1309,15 @@ def create_app(logger.exception("internal memory preflight failed")return JSONResponse(status_code=503, content={"ok": False, "error": "memory_processing_failed"})- def _memory_cli_scope(request: Request) -> tuple[str, str] | None:+ def _memory_cli_scope(request: Request, *, read_only: bool = False) -> tuple[str, str] | None:from vibe.memory_http_headers import CALLER_SESSION_HEADERsession_id = str(request.headers.get(CALLER_SESSION_HEADER) or "").strip()if not session_id:return Noneresolve = getattr(controller, "memory_scope_for_cli_session", None)+ if read_only:+ resolve = getattr(controller, "memory_read_scope_for_cli_session", resolve)scope = resolve(session_id) if callable(resolve) else Noneif not bool(getattr(getattr(getattr(controller, "config", None), "memory", None), "enabled", False)):return None@@ -1435,7 +1438,7 @@ def create_app(if user_key is None:return Nonereturn user_key, None- scope = _memory_cli_scope(request)+ scope = _memory_cli_scope(request, read_only=True)return (None, scope) if scope is not None else None@app.get("/internal/memory/status")@@ -1674,6 +1677,20 @@ def create_app(content={"status": "failed", "error": "memory_store_unavailable"},)+ @app.post("/internal/memory/delegated-owner")+ async def _delegated_memory_owner(request: Request) -> Any:+ from core.caller_context import verify_caller_session_proof+ from storage.message_deliveries import current_delivery_memory_owner++ body = await request.json()+ session_id, proof = body.get("session_id"), body.get("proof")+ if not isinstance(session_id, str) or not isinstance(proof, str):+ return JSONResponse(status_code=403, content={"owner": None})+ owner = current_delivery_memory_owner(session_id)+ if not verify_caller_session_proof(session_id, proof, owner):+ return JSONResponse(status_code=403, content={"owner": None})+ return {"owner": owner}+@app.post("/internal/memory/search")async def _memory_search(request: Request) -> Any:owner = _memory_read_owner(request)diff --git a/core/scheduled_tasks.py b/core/scheduled_tasks.pyindex cea25cb0f..7c8225346 100644--- a/core/scheduled_tasks.py+++ b/core/scheduled_tasks.py@@ -1618,6 +1618,11 @@ class ScheduledTaskStore:ensure_harness_definition_write(user_context)ensure_agent_name_access(agent_name, user_context=user_context)+ from storage.message_deliveries import metadata_with_delegated_memory_owner++ metadata = metadata_with_delegated_memory_owner(+ metadata_with_resource_user_context(metadata, user_context), session_id=session_id+ )task = ScheduledTask(id=uuid4().hex[:12],name=name,@@ -1633,7 +1638,7 @@ class ScheduledTaskStore:cron=cron,run_at=run_at,timezone=timezone_name,- metadata=metadata_with_resource_user_context(metadata, user_context),+ metadata=metadata,shell_command=shell_command,command=command,timeout_seconds=timeout_seconds,@@ -1690,6 +1695,16 @@ class ScheduledTaskStore:raise DefinitionWriteConflict(task_id, definition_type="scheduled task")return task+ @_serialize_task_mirror+ def rebind_session(self, task_id: str, session_id: str) -> None:+ """Host recovery changes only the binding, retaining authenticated metadata."""+ task = self._tasks[task_id]+ expect = self._read_state(task)+ task.session_id = session_id+ task.updated_at = _utc_now_iso()+ if not self._write_task(task, expect):+ raise DefinitionWriteConflict(task_id, definition_type="scheduled task")+@_serialize_task_mirrordef update_task(self,@@ -1764,6 +1779,11 @@ class ScheduledTaskStore:metadata if metadata is not None else task.metadata,user_context,)+ from storage.message_deliveries import metadata_with_delegated_memory_owner++ task.metadata = metadata_with_delegated_memory_owner(+ task.metadata, session_id=session_id+ )task.updated_at = _utc_now_iso()if not self._write_task(task,@@ -10008,24 +10028,7 @@ class ScheduledTaskService:return Truedef _write_task_session_id(self, task: ScheduledTask, session_id: str) -> None:- self.store.update_task(- task.id,- name=task.name,- session_key=task.session_key,- session_id=session_id,- prompt=task.prompt,- schedule_type=task.schedule_type,- agent_name=task.agent_name,- session_policy=task.session_policy,- post_to=task.post_to,- deliver_key=task.deliver_key,- cron=task.cron,- run_at=task.run_at,- timezone_name=task.timezone,- cwd=task.cwd,- update_cwd=False,- metadata=task.metadata,- )+ self.store.rebind_session(task.id, session_id)def _pause_task(self, task: ScheduledTask) -> None:try:@@ -10842,6 +10845,10 @@ class ScheduledTaskService:platform_specific={"platform": platform,"is_dm": target.is_dm,+ "message_metadata": {+ key: value for key, value in (metadata or {}).items()+ if key in {"delegated_memory_owner", "resource_user_context"}+ },"turn_source": "scheduled","agent_session_id": session_id,"session_key_external": target.to_key(),diff --git a/core/session_turns.py b/core/session_turns.pyindex 8a1a536bf..6c659dea9 100644--- a/core/session_turns.py+++ b/core/session_turns.py@@ -179,8 +179,8 @@ def _as_backend_activity_item(item: dict[str, Any]) -> dict[str, Any]:# context.platform_specific provenance that the gate must restore when the row is# finally flushed — so a scheduled run enqueued behind an active turn keeps its# delivery override / suppression / task attribution + runs as SOURCE_SCHEDULED, not-# a plain human turn (#84). Its PRESENCE also marks the row as a scheduled segment-# (vs a user send) for flush_queue.+# a plain human turn (#84). Only immutable source=harness makes this host+# provenance; user metadata cannot establish it.SCHEDULED_PROVENANCE_KEY = "scheduled_provenance"SCHEDULED_QUEUE_MERGE_WINDOW_SECONDS = 60SCHEDULED_QUEUE_BURST_HINT_THRESHOLD = 3@@ -196,7 +196,7 @@ _TERMINAL_RESULT_LATCH_KEY = "_avibe_terminal_result_latch"# ``MessageDispatcher._get_target_context`` actually redirects delivery on — can't be# silently omitted (Codex P1 #3338692433)._FLUSH_REBUILT_KEYS = frozenset(- {"platform", "is_dm", "workbench_session_id", "agent_session_id", "agent_session_target", "turn_token"}+ {"platform", "is_dm", "workbench_session_id", "agent_session_id", "agent_session_target", "turn_token", "delivery_source"})_EXECUTION_ROUTING_KEYS = _FLUSH_REBUILT_KEYS | frozenset({@@ -331,9 +331,7 @@ def _parse_queue_timestamp(value: Any) -> Optional[datetime]:def _scheduled_provenance(row: dict[str, Any]) -> Optional[dict[str, Any]]:- metadata = row.get("metadata") or {}- provenance = metadata.get(SCHEDULED_PROVENANCE_KEY)- return provenance if isinstance(provenance, dict) else None+ return delivery_store.scheduled_delivery_provenance(row)def _agent_run_merge_definition_id(spec: dict[str, Any]) -> str:@@ -1257,13 +1255,14 @@ class SessionTurnManager:self._restore_scheduled_dispatch_context(context, deliveries[0])return await prepare(context, human=not scheduled)- @staticmethoddef _restore_scheduled_dispatch_context(+ self,context: "MessageContext",delivery: dict[str, Any],) -> None:- payload = delivery_store.delivery_payload(delivery)- provenance = (payload.get("metadata") or {}).get(SCHEDULED_PROVENANCE_KEY)+ with self._sqlite_engine().connect() as conn:+ payload = delivery_store.execution_delivery_payload(conn, delivery)+ provenance = delivery_store.scheduled_delivery_provenance(payload)preserved = (provenance.get("platform_specific")if isinstance(provenance, dict)@@ -1287,7 +1286,7 @@ class SessionTurnManager:delivery: dict[str, Any],) -> "MessageContext":"""Overlay only the exact queued Delivery's routing provenance."""- provenance = (delivery_store.delivery_payload(delivery).get("metadata") or {}).get(SCHEDULED_PROVENANCE_KEY)+ provenance = delivery_store.scheduled_delivery_provenance(delivery_store.delivery_payload(delivery))preserved = provenance.get("platform_specific") if isinstance(provenance, dict) else Noneif not isinstance(preserved, dict):return context@@ -2341,6 +2340,24 @@ class SessionTurnManager:continuereturn None+ def restore_memory_context(self, session_id: str, turn_id: str) -> Optional["MessageContext"]:+ """Reconstruct only this still-live execution, never a later Session turn."""+ with self._sqlite_engine().connect() as conn:+ turn = delivery_store.get_turn(conn, turn_id)+ if not turn or turn["session_id"] != session_id or turn["state"] not in delivery_store.TURN_OWNER_STATES:+ return None+ delivery = delivery_store.delivery_for_turn(conn, turn_id)+ if delivery is None:+ return None+ context = self._delivery_context(session_id)+ self._hydrate_delivery_context(context, delivery)+ self._restore_scheduled_dispatch_context(context, delivery)+ context.platform_specific["turn_token"] = turn_id+ context.platform_specific["turn_source"] = (+ SOURCE_SCHEDULED if context.platform_specific.get("delivery_source") == "harness" else SOURCE_HUMAN+ )+ return context+def _hydrate_delivery_context(self,context: "MessageContext",@@ -2348,7 +2365,8 @@ class SessionTurnManager:) -> dict[str, Any]:"""Restore dispatch inputs only from the durable Delivery snapshot."""- payload = delivery_store.delivery_payload(delivery)+ with self._sqlite_engine().connect() as conn:+ payload = delivery_store.execution_delivery_payload(conn, delivery)context.platform = str(payload.get("platform") or context.platform or "avibe")native_message_id = str(payload.get("native_message_id") or "").strip()context.message_id = (@@ -2359,12 +2377,16 @@ class SessionTurnManager:if context.platform_specific is None:context.platform_specific = {}metadata = payload.get("metadata") or {}+ if payload.get("source") != "harness":+ metadata = delivery_store.metadata_without_delegated_owner(metadata)+ metadata.pop(SCHEDULED_PROVENANCE_KEY, None)+ payload["metadata"] = metadataraw_snapshot = delivery.get("snapshot_json")try:snapshot = json.loads(raw_snapshot) if isinstance(raw_snapshot, str) else {}except (TypeError, ValueError):snapshot = {}- legacy_workbench = context.platform == "avibe" and (+ legacy_workbench = not delivery.get("message_id") and context.platform == "avibe" and (not isinstance(snapshot, dict) or "message_kind" not in snapshot)author_id = payload.get("author_id")@@ -2383,6 +2405,7 @@ class SessionTurnManager:)memory_cli_admitted = bool(context.platform == "avibe"+ and payload.get("source") == "user"and memory_enabledand author_idand (@@ -2397,6 +2420,7 @@ class SessionTurnManager:context.platform_specific.update({"delivery_id": str(delivery["id"]),+ "delivery_source": payload.get("source"),"scope_id": payload.get("scope_id"),"display_text": payload.get("text") or "","message_content": dict(payload.get("content") or {}),@@ -2666,6 +2690,27 @@ class SessionTurnManager:error_type=type(exc).__name__,)+ def _compatible_steer_memory_authority(self, turn_id: str, deliveries: list[dict[str, Any]]) -> bool:+ if not bool(getattr(getattr(self.controller.config, "memory", None), "enabled", False)):+ return True+ from avibe_memory.admission import InboundTurnFacts++ with self._sqlite_engine().connect() as conn:+ initial = delivery_store.delivery_for_turn(conn, turn_id)+ active = delivery_store.execution_delivery_payload(conn, initial) if initial else {}+ incoming = [delivery_store.execution_delivery_payload(conn, row) for row in deliveries]+ payloads = [active, *incoming]+ admission = self.controller._memory_admission()+ delegated = [delivery_store.memory_owner_from_payload(payload)+ for payload in payloads if payload.get("source") == "harness"]+ # Revoking a binding must not let foreign input enter a native Turn whose+ # existing scope could become readable again when access is restored.+ has_scope = active.get("session_id") in getattr(self.controller, "_memory_scopes_by_session", {})+ if not any(owner and (has_scope or admission.admits(InboundTurnFacts(**owner))) for owner in delegated):+ return True # Human-only and Memory-ineligible group steering keep their policy.+ authority = delivery_store.memory_authority_for_payload(active)+ return all(delivery_store.memory_authority_for_payload(payload) == authority for payload in incoming)+async def _dispatch_steer_batch(self,backend: str,@@ -2677,6 +2722,10 @@ class SessionTurnManager:context: "MessageContext",) -> DeliveryResult:delivery_id = str(deliveries[0]["id"])+ if not self._compatible_steer_memory_authority(logical_turn_id, deliveries):+ return await self._finish_steer(+ delivery_id, steer_result(SteerOutcome.REFUSED, reason="memory_authority_changed"), context=context+ )try:metadata = await self._steer_input_metadata(deliveries)request = SteerRequest(@@ -4338,7 +4387,7 @@ class SessionTurnManager:resolved.platform_specific["turn_token"] = turn_idresolved.platform_specific["delivery_start_attempt_id"] = attempt_idmetadata = delivery_payload.get("metadata") or {}- provenance = metadata.get(SCHEDULED_PROVENANCE_KEY)+ provenance = delivery_store.scheduled_delivery_provenance(delivery_payload)source = SOURCE_HUMANif isinstance(provenance, dict):source = SOURCE_SCHEDULED@@ -7636,9 +7685,7 @@ class SessionTurnManager:if head is None:continuehead_payload = delivery_store.delivery_payload(head)- provenance = (head_payload.get("metadata") or {}).get(- SCHEDULED_PROVENANCE_KEY- )+ provenance = delivery_store.scheduled_delivery_provenance(head_payload)spec = (provenance.get("platform_specific")if isinstance(provenance, dict)@@ -7766,7 +7813,7 @@ class SessionTurnManager:if message is not None:record = messagemetadata = record.get("metadata") or {}- provenance = metadata.get(SCHEDULED_PROVENANCE_KEY)+ provenance = delivery_store.scheduled_delivery_provenance(record)restored_spec = (provenance.get("platform_specific")if isinstance(provenance, dict)diff --git a/core/watches.py b/core/watches.pyindex c101b36ef..e4f0ac545 100644--- a/core/watches.py+++ b/core/watches.py@@ -670,6 +670,11 @@ class ManagedWatchStore:ensure_harness_definition_write(user_context)ensure_agent_name_access(agent_name, user_context=user_context)+ from storage.message_deliveries import metadata_with_delegated_memory_owner++ metadata = metadata_with_delegated_memory_owner(+ metadata_with_resource_user_context(metadata, user_context), session_id=session_id+ )watch = ManagedWatch(id=uuid4().hex[:12],name=name,@@ -689,7 +694,7 @@ class ManagedWatchStore:retry_delay_seconds=retry_delay_seconds,post_to=post_to,deliver_key=deliver_key,- metadata=metadata_with_resource_user_context(metadata, user_context),+ metadata=metadata,)watch.metadata[LIFETIME_STARTED_AT_METADATA_KEY] = watch.created_atreturn self.upsert_watch(@@ -824,6 +829,11 @@ class ManagedWatchStore:if waiter_lifecycle_changed:watch.metadata = dict(watch.metadata)watch.metadata.pop(RECENT_EVENT_TIMESTAMPS_METADATA_KEY, None)+ from storage.message_deliveries import metadata_with_delegated_memory_owner++ watch.metadata = metadata_with_delegated_memory_owner(+ watch.metadata, session_id=session_id+ )watch.updated_at = _utc_now_iso()if not self._write_watch(watch,diff --git a/docs/MEMORY.md b/docs/MEMORY.mdindex 8ed29850e..d3a7e7c6a 100644--- a/docs/MEMORY.md+++ b/docs/MEMORY.md@@ -155,6 +155,19 @@ delivery remains process-local; pending Agent-owner work may be lost across restor runtime replacement and is never replayed from an older queue. Alreadysubmitted provider outcomes are never replayed by this path.+## Delegated reads++A Task or Watch created during an authorized turn can keep reading the same+user's default or named Memory project when it resumes that same Session,+including after a controller restart. The definition carries the authenticated+owner from the creating turn; a Task can pass that identity to a Watch it creates.+Current binding and resource authorization still apply. Missing owner identity+(including older definitions without this fact) stays denied.++Background events remain synthetic and are not automatically captured as user+input. This read capability does not enable `remember`, configuration, or+administrative operations. Arbitrary cross-Session delegation is not covered.+## IM attachment captureMemory can extract supported attachments from bound one-to-one conversations ondiff --git a/docs/investigations/issue-2019-background-memory-analysis.md b/docs/investigations/issue-2019-background-memory-analysis.mdnew file mode 100644index 000000000..7eb8baa6a--- /dev/null+++ b/docs/investigations/issue-2019-background-memory-analysis.md@@ -0,0 +1,75 @@+# Issue 2019: background Memory access++Analysis only; no product implementation, deployment, service restart, or GitHub write.++## Evidence baseline++- Issue: https://github.com/avibe-bot/avibe/issues/2019+- Original contract: https://github.com/avibe-bot/avibe/issues/983+- GitHub master inspected on 2026-09-17: `0e5a672ad183ac56f5ee8df7bcb770754840b3d9`.+- Local checkout is older (`199cccf958349881209c00b20124b82726f3ce0c`) and has unrelated user changes. Even local `origin/master` is stale. Findings below use a downloaded immutable snapshot of the GitHub SHA.++## Confirmed mechanism++1. `core/memory_cli_access.py:18` requires a human turn without a task trigger before inspecting identity admission.+2. `Controller.configure_memory_cli_session` clears both the scope and identity-facts entries when admission fails (`core/controller.py:3414`). This is an actual authorization failure, not merely missing prompt guidance.+3. `/internal/memory/search` resolves the registered scope first and returns HTTP 403 / `memory_access_denied` before invoking the search service if none exists.+4. Background Workbench contexts use a synthetic routing user (`core/scheduled_tasks.py:10943`). Their context constructor does not supply authenticated human author facts. Workbench hydration and `_memory_turn_facts` depend on the durable author identity; routing identity alone is deliberately insufficient.+5. Scope and facts are process-local dictionaries. Retaining an earlier allowed scope cannot solve restart recovery and could retain outdated authority.+6. The same scope helper also gates explicit Agent `remember`. Changing it has a read/write impact that must be addressed explicitly.++The prompt refactor moved the original gate into `memory_cli_access.py`; it did not remove it. Earlier interpretation based on the old local checkout was incorrect.++## Isolated behavioral evidence++Temporary probes extract the unchanged access function, Controller registration/lookup methods, and internal search route/helpers from the immutable snapshot using Python AST. They use a fake identity directory and a fake search service; supporting imports come from the existing local Python environment. No live controller, personal Memory, credential, or external model is contacted. This verifies the authorization seam, not a full managed continuation.++Command: `.venv/bin/python /tmp/issue2019_probe.py`++| Sequence | HTTP status | Search service call count |+| --- | --- | --- |+| Human | 200 | 1 |+| Task | 403 | 1 |+| Watch | 403 | 1 |+| Human again | 200 | 2 |++The probe expects four successful reads and fails on the background turns.++Diagnostic-only removal of the trigger condition, with otherwise identical authenticated facts: four HTTP 200 results. Command: `.venv/bin/python /tmp/issue2019_probe_gate_only.py`.++The same diagnostic removal without human author/admission facts on background turns: 200, 403, 403, 200 again. Command: `.venv/bin/python /tmp/issue2019_probe_missing_owner.py`.++These variants alter only temporary in-memory function definitions, not repository source. They demonstrate why gate deletion alone is insufficient for Workbench continuation.++## Owner-confirmed product direction++On 2026-09-17, the owner confirmed that tasks they dispatch should be able to query Memory while carrying out their delegation. Background triggering must not itself remove this capability. Authority follows the verified user delegation and its existing scope, rather than requiring a fresh human message for each continuation.++The target is the delegating user's Memory. This is not a grant to read another user's Memory, and synthetic task input remains distinct from human-authored input. The identity connection must be established from trusted execution and ownership records; dispatch into a Session alone is not proof of personal Memory ownership.++This records agreement on product behavior. The conversation so far requested analysis and confirmed this direction; implementation and deployment have not been reported as authorized or performed.++## Recommended smallest complete change++Separate the identity under which execution is authorized from the authorship of its triggering event.++- Remove trigger type as an independent Memory read authorization requirement.+- At the shared trusted dispatch boundary, resolve the existing execution owner against its target Session and current access policy, then derive the same Memory principal and project semantics used by an interactive invocation.+- Reconstruct that identity after restart from existing authoritative Session/Run/Task/Watch ownership and admission records. Do not persist an extra Memory permission store or a per-task access toggle.+- Preserve fail-closed behavior for missing, ambiguous, inconsistent, revoked, or cross-user ownership. A Session ID, arbitrary metadata, caller-supplied user ID, or access to a shared resource does not by itself identify the personal Memory owner. Existing `created_by.caller` and resource-context fields are candidate inputs to validate, not new trusted grants by declaration.+- Keep the trigger event synthetic: do not rewrite `turn_source`, `message_kind`, or human author attribution to obtain access. Automatic capture must continue to reject synthetic input.+- Keep explicit Agent writes session-user-scoped with `provenance=agent`, and keep configuration/destructive operations outside that capability. Audit the shared scope change against this existing write contract; do not silently introduce a second permission system or broaden unrelated authority.+- Implement in shared authorization/dispatch logic, inherited by Claude, Codex, and OpenCode. Leave EverOS search and stable prompt composition unchanged unless evidence requires changes there.++An implementation design must name the exact authoritative owner record for each supported continuation path and how it is revalidated. The current Memory adapter does not already supply this complete background resolver; passing a synthetic user through existing capture admission is not a substitute. Never choose the latest human speaker or a resource owner as a personal Memory principal without an established ownership contract.++## Acceptance evidence required for implementation++- Human -> Task -> Watch -> human in the same authorized Session, including fresh controller/restart recovery.+- Two users with identical named-project slugs remain isolated; another Session ID or forged caller metadata cannot select the other user's Memory.+- Missing owner, malformed owner, disabled/revoked binding, archived Session, and Memory-disabled cases stay denied.+- Task/Watch notifications, tool output, and Agent messages never become automatic user-input captures.+- Explicit remember preserves Agent provenance and its existing scope; configuration/destructive boundaries remain enforced.+- Backend coverage proves each supported backend invokes the shared access configuration path.+- Add continuation scenarios to `tests/scenarios/memory_search/catalog.yaml` alongside focused access and durable-dispatch tests.+- A real managed Task and Watch in the local Incus regression environment invoke normal `vibe memory search` without environment overrides or copied credentials. Repeat after the regression controller restarts. This end-to-end acceptance has not been run during this source-analysis request.diff --git a/docs/plans/issue-2019-delegated-memory-reads.md b/docs/plans/issue-2019-delegated-memory-reads.mdnew file mode 100644index 000000000..a62516b1a--- /dev/null+++ b/docs/plans/issue-2019-delegated-memory-reads.md@@ -0,0 +1,324 @@+# Issue 2019: delegated Memory reads — simplified proposal++Status: simplified implementation authorized by the owner on 2026-09-17. One implementation lane; no merge or deployment authorization.++## Problem and outcome++A task the user delegated cannot search their Memory when a Task or Watch resumes it, even though a direct human turn can. After an upgrade/restart this forces the user to send another message before verification can use Memory.++Desired behavior: the same authorized delegation keeps the same user's Memory read access during managed continuation, including after restart. Synthetic notifications remain synthetic input.++Evidence baseline: GitHub master `0e5a672ad183ac56f5ee8df7bcb770754840b3d9`; see `docs/investigations/issue-2019-background-memory-analysis.md`.++## Smallest complete solution++1. **Carry the existing user identity into continuation.** Reuse the owner identity already validated by the shared Harness/session admission path. Connect it to the existing Memory scope calculation. Keep it separate from the event's author: a background `author_id` can be a Task ID. If the existing persisted execution context drops the validated identity, preserve only that missing fact in its existing metadata and restore it through the ordinary restart path.+2. **Remove the extra human-trigger requirement for reads.** A Task/Watch trigger must not invalidate an otherwise authorized user's Memory read scope. Keep the existing user/project isolation and existing binding/access checks; do not duplicate them inside Memory.+3. **Keep capture and write semantics intact.** Do not relabel background messages as human input. The shared read/write scope helper needs a focused adjustment so this read fix does not accidentally expand `remember` or administrative capabilities. Prefer a small read-specific helper or local call-site distinction if needed; do not introduce a permissions model, operation matrix, or separate grant store.++The implementation should be ordinary identity propagation plus removal of one redundant condition, with the minimum read/write call-site adjustment warranted by the current shared helper.++## One implementation question still to resolve++Identify the existing host-validated owner value used by the Task/Watch execution path and its persistence location. Source inspection confirms related caller/resource/admission records exist, but does not establish that one currently supplies all the facts Memory needs.++Resolve this concrete connection before editing the affected path. Do not turn it into a prerequisite to redesign every Harness origin or Session ownership model. Caller-supplied metadata is not made authoritative merely because it is persisted. If the identity really is absent, return the existing access-denied result; do not guess local ownership, use the latest speaker, or build historical recovery machinery.++## Design limits++### Identity source audit (implementation lane, 2026-09-17)++- Direct Workbench identity is `Delivery.author_id`, produced by+ `vibe.ui_server._workbench_author_id()` from strict `memory_ui_user_key()`+ admission. Generic local resource Owner admission is broader (for example,+ LAN setup access) and cannot substitute for this identity.+- Task/Watch creation calls `metadata_with_resource_user_context()`. Remote+ subjects survive in `metadata.resource_user_context` and existing execution+ checks restore/revalidate them. Local contexts are deliberately omitted;+ `instance_owner_context()` has an Owner role but no subject.+- `created_by.caller` records CLI environment provenance, not independently+ validated personal identity. Claude's session-stable caller also omits+ `user_id` and `message_id`. These fields cannot be promoted into owner grants.+- Scheduled dispatch stores/restores `scheduled_provenance` in the immutable+ Delivery snapshot, but its author is the definition ID, not the delegator.+ This is a usable persistence path once a trusted owner has been established.++Decision confirmed by the orchestrator: definition creation resolves the creating+Session's current `active_turn` and `delivery_for_turn` in the existing database+(and its exact accepted Message FK once native acceptance clears the snapshot);+creator and target Session must match. The owner value comes only from that+Delivery's authenticated author or its existing host-stamped continuation+metadata, never caller `user_id`. Store `delegated_memory_owner` (platform,+user ID, private-message fact) in Task/Watch metadata; pass it in scheduled+`message_metadata`, which the ordinary Delivery snapshot restores after restart.+Existing resource metadata and IM bindings remain the current authorization+checks. No historical search is needed. Synthetic read scopes+are excluded from the existing write accessor; capture classification is unchanged.++### Review-discovered creator binding correction++PR #2023's first review exposed a normal CLI override: changing+`AVIBE_SESSION_ID` could stamp another active IM user's owner. Session equality+alone is not authentication. The orchestrator approved this bounded correction:++- Shared `caller_env_for_platform_payload` issues `AVIBE_CALLER_SESSION_PROOF`,+ an HMAC-SHA256 of canonical `[session_id, platform, user_id]` using one+ random controller-process key (strengthened after the third review).+ The deterministic proof is stable for Claude's session-cached environment.+- Definition creation sends the proof and same target Session to the existing+ Unix transport's `/internal/memory/delegated-owner` accessor. Constant-time+ verification binds the current exact-Delivery owner candidate before returning+ that same owner object. There is no signing API.+ Missing/bad proof or unavailable controller leaves ordinary definitions usable+ but grants no delegated Memory identity. In-process event-loop creation does+ not call its own socket synchronously and likewise leaves identity absent.+- Only owner facts persist in definitions and scheduled Delivery provenance.+ The key stays in memory. Proofs travel in existing execution transport (including+ Codex shell scripts and OpenCode binding files); they are excluded from caller+ metadata and OpenCode durable processing snapshots. OpenCode restores a fresh+ proof from its host-owned poll Session and exact logical Turn identity. No registry, schema, per-task+ credential, or backend-specific authorization policy is introduced.+- Threat boundary: documented CLI locator overrides are untrusted; a same-UID+ process editing host SQLite, transport files, or process memory is outside this+ focused correction. Existing resource and Memory revocation checks still apply.+- Public queued Delivery and accepted Message projections strip the internal+ owner both directly and under the known scheduled provenance shape, preserving+ raw stored values for continuation. Task/Watch public API and CLI projections+ hide the new owner marker using an explicit display-only store option; default+ runtime store reads preserve owner and existing resource context. Pause/resume+ reads raw stored metadata, never the redacted display projection.++- First delivery covers the issue's same-Session Task and Watch continuations. Shared code may naturally benefit other managed paths, but arbitrary cross-Session delegation, group Memory, and general Agent delegation redesign are not acceptance requirements for this fix.+- Reuse existing current authorization and revocation checks. Do not recursively traverse execution ancestry on each search, build a parallel authorization service, or add extra per-stage checks for the same fact.+- Reuse existing persisted execution context for restart. No new Memory permission database, task toggle, approval step, long-lived credential, or cached last-successful grant.+- Do not add a standalone compatibility subsystem to infer owners for unresolvable historical tasks.+- Do not modify EverOS, prompt composition, UI, or individual backend authorization rules for this issue.+- Do not add defensive branches for hypothetical inconsistent combinations unless the real call path or a focused reproduction demonstrates the need.++## Focused verification++1. An authorized direct turn, Task continuation, and Watch continuation query the same user's default/named Memory project successfully. Exercise the real shared dispatch-to-read boundary rather than fabricating the missing identity at the final gate.+2. A persisted continuation still works with a fresh controller after restart. This is the reported use case, not an optional edge case.+3. Representative existing isolation/denial coverage still passes: two users remain separate; missing identity and revoked access remain denied. Reuse existing tests for other unaffected authorization behavior rather than multiplying a full platform/backend/queue-state matrix.+4. A synthetic Task/Watch event does not enter automatic user-input capture. Existing Agent-write provenance and access behavior do not expand as a side effect.++Add the relevant continuation cases to the existing Memory scenario catalog. Use one real local Incus acceptance flow with a Task, a Watch, and regression-controller restart. Do not restart the user's running host or copy another turn's credentials for verification.++## Delivery++One focused implementation PR using shared code and the existing repository CI/review requirements. No mandatory new module hierarchy or line-count target: minimize mechanisms while completing the ordinary Task/Watch and restart behavior.++Owner acceptance: delegate a task that needs a known non-sensitive Memory fixture, allow it to resume automatically, and confirm correct retrieval without another human message.++## Implementation evidence++- `MEMORY-SEARCH-021` / `022`: real durable turn admission, definition creation+ and reload, scheduled submission, persisted queue, fresh controller/turn manager+ recovery, internal HTTP search in default/named projects, and Task -> Watch+ identity propagation. Native backend and provider execution are test doubles.+- `MEMORY-SEARCH-023` / `024`: absent/forged identity denial, two remote owners+ querying the same named project without sharing scope, and current binding+ revocation denying registered delegated reads. The continuation tests also+ exercise capture admission (synthetic input is skipped) and remember HTTP 403.+- Local Incus doctor passed after starting the existing Lima VM. Isolated runner+ `up --target worktree --slug memory-reads-2019 --reset-mode none --env-file /dev/null`+ stopped before provisioning because dedicated LLM/IM seed credentials are absent.+ The orchestrator confirmed no dedicated `.env.regression` fixture exists. Real+ Task/Watch/backend/controller-restart acceptance remains unverified; no host+ service restart, production credential borrowing, or master update is authorized.+- Verification before first PR: 4 new continuation contracts passed; 639 existing+ Task/Watch/Caller tests passed (643 including new tests); 106 existing Memory+ internal/capture/disabled tests passed; 23 additional prompt/durable Memory+ checks passed (27 including new tests). Changed Python files pass Ruff.+- Cleanup: runner delete found no project/instance (up never provisioned one);+ runner reconcile confirmed no local worktree regression environments remain.++- First-review correction evidence: `MEMORY-SEARCH-025` exercises the actual+ client/accessor/verifier/creation boundary for valid, missing, tampered and+ another Session's proof. `026` checks public definition output, SQLite runtime+ store reload and public pause/resume; queued/accepted Message consumer tests+ cover nested provenance redaction. OpenCode transport/snapshot/restore and+ Claude stable environment contracts reuse existing backend fixtures.+- Final first-review focused run: 1,073 passed (1,060 existing cases and 13 new+ continuation/proof/projection cases). Public API list/page/pause/resume tests+ and SQLite runtime reload checks pass. Changed Python Ruff passes. Definitions+ retain their existing public resource-context shape; only the new owner marker+ is hidden there. Message/Delivery projections retain their prior private-field+ filtering and additionally hide the owner at both known locations.++### Second-review class closure (orchestrator decision, 2026-09-17)++The public-projection class recurred at `606de20`: the first correction missed+Run output even though definitions copy their metadata into executions. This is+an incomplete consumer inventory, not a defect requiring another ownership model.+One narrow projection normalizes optional non-object metadata and removes only+`delegated_memory_owner` at the root and the known scheduled provenance path.+Message/Delivery retain their existing other-private-field filtering; Harness+records retain their legacy resource-context output. Internal reads remain raw.++| Record | Producer / runtime consumer | Public boundary |+| --- | --- | --- |+| Task | definition store -> scheduled enqueue -> runtime reload | display-only `_enrich_definitions`; CLI fallback |+| Watch | definition store -> hook request -> runtime reload | display-only `_enrich_definitions`; CLI fallback |+| Run | task enqueue / watch hook -> request store execution | display-only `_enrich_runs`; full CLI `_run_payload` and audited direct outputs |+| queued Delivery | scheduled submission -> durable turn recovery | `public_delivery_payload` |+| accepted Message | native acceptance -> exact Delivery FK lookup | `_row_to_payload` public metadata projection |++The OpenCode initial bind and ordinary retry must share one merged caller/skills+environment snapshot. Restored initial/retry already share the refreshed host+proof. No proof, token, authorization, or persistence mechanism is added.+The circuit breaker paused edits after the repeated class; the orchestrator+approved this finite closure. Any third findings-bearing head after the proof+change stops edits/push for another complete inventory, even for a new class.++CLI bypass audit: `cmd_task_run`, hook-send, and asynchronous Agent Run replies+build explicit field lists without metadata. Synchronous Agent Run and run-cancel+outputs use `_run_payload`; run lists use its brief field list. There is no+separate `cmd_watch_run` command. Harness status projects Task/Watch/Run through+explicit field lists in `core/services/harness_status.py`, with no metadata.+The run lifecycle store and raw `_run_from_row` must not redact upstream.++Finite evidence enumeration: delegated-read tests cover public Delivery/Message+and SQLite Task/Watch reload; definition-to-run tests exercise real scheduled+enqueue and watch hook, full Run API/CLI output, and request-store reload.+Nonempty list/string plus empty list metadata stays readable without rewriting+stored JSON. Existing OpenCode process tests fail the initial bind once, let its+ordinary retry carry the proof, then create both Task and Watch through the real+verified accessor. Restored retry tests check a fresh proof stays out of snapshots.++Second-review focused validation: 377 passed (363 existing cases, 14 new PR+cases in this selection); changed Python Ruff and diff checks pass. This selection+covers the five families, malformed optional metadata, public Run output, native+binding retry/restore, CLI Task/Watch, and existing Harness run/status projections.+Scenario IDs `MEMORY-SEARCH-027/028` identify Run-copy and binding-retry evidence.+Run lifecycle SSE events also use a fixed field list without metadata.++### Third-review owner-binding correction (orchestrator decision, 2026-09-17)++The retained Session-only proof could authorize a later Workbench owner's+Delivery when the caller changed an unsigned resource-context subject. A hermetic+creation/dispatch/HTTP-read reproduction confirmed unchanged Alice context was+denied, but replacing its ordinary JSON subject with Bob yielded Bob's scope.+The third-head circuit breaker stopped edits; the orchestrator authorized only+strengthening the existing HMAC over canonical `[session_id, platform, user_id]`.+Same-owner later turns may reuse the proof: per-turn freshness is not required.++Host issuance reuses the one Delivery-owner extractor with the context's exact+`turn_token` when present. OpenCode restoration uses its stored logical Turn and+target Session, never another current turn's owner. A missing/wrong-Session exact+Turn has no fallback. The accessor reads one current owner candidate and verifies+against that same object before returning it. Caller JSON and routing author IDs+cannot supply signed ownership. No nonce, registry, token payload, cache, or new+endpoint is added. Claude's existing env reconciliation changes clients only+when the signed owner changes; ordinary same-owner turns remain stable.++Persisted owner facts and current authorization remain unchanged; restart rotates+the process key and can reissue from the exact stored Delivery. Any further+findings-bearing head requires another PM reassessment before edits/push.++Third-review focused validation: 234 cases passed, including the new full+create/dispatch/read cross-owner replay contract (`MEMORY-SEARCH-029`), exact-Turn+missing/mismatched Session denial, and restored old-owner OpenCode poll coverage.+The selection retains Claude cached-client, Task/Watch persistence/key rotation,+OpenCode retry/snapshot, and public projection tests. Changed Python Ruff passes.+Unavailable durable storage omits the optional proof so ordinary Agent launch+remains usable without granting delegated Memory. Real Incus acceptance remains+unverified for the previously documented missing dedicated seed credentials.++### Fourth-review execution-authority boundaries (PM decision, 2026-09-17)++The fourth findings-bearing head stopped edits for whole-invariant diagnosis.+The owner marker is execution authority: it must originate in host scheduling,+have a usable shape, and remain constant across a merged Turn. Owner-bound HMAC+continues to protect creation; no further credential mechanism is needed.++Use one owner parser (nonempty string platform/user_id, normalized is_dm) and one+source-aware known scheduled-provenance reader. Shared user snapshot intake strips+reserved owner and scheduled provenance before persistence; hydration also strips+old user-row injections. Hydration transports immutable Delivery.source as+`delivery_source`, excluded from captured/restored metadata overlays. Delegated+admission requires that host source and a scheduled trigger. Provenance presence+alone never converts ordinary input into scheduled execution.++One canonical authority component in `message_merge_identity` compares owner and+resource_user_context at root and the known scheduled nested path. The existing+queue collector and immutable acceptance both consume it: differing/absent+identity separates Turns while equal authority remains batchable. No arbitrary+metadata comparison, new permission database, or backend-specific policy is added.++Fourth-review validation: 518 focused cases pass (503 cases already present on+`abcb0147b`, plus 15 new parameter cases). `MEMORY-SEARCH-030` covers malformed+raw nested metadata and owner fields through durable dispatch and host env+issuance. `031` covers both Task and Watch batches: differing owner, absent owner,+or resource snapshot separates execution; compatible authority still merges,+normal native acceptance checks immutable identity, and HTTP reads retain the+correct scope or denial. `032` drives actual UI POST through shared snapshot+persistence and durable dispatch with strict author None, plus a valid historical+user-row injection: both remain human and never call the Memory provider.+Existing authenticated UI, stable proof/replay, persisted restart, OpenCode+retry/restore, Claude caching, and public projections remain in the selection.+Changed Python Ruff passes. Real Incus acceptance remains unverified.++### CI lifecycle compatibility correction (PM decision, 2026-09-17)++The clean-reviewed head `cef490d11` failed an existing scheduled-gate lifecycle+contract: explicit `submit_scheduled` without a task trigger still means scheduled+execution. Separate execution classification from Memory eligibility. The shared+provenance reader requires host harness source and structured provenance only;+owner extraction/signing and delegated admission retain the nonempty string+trigger requirement. Keep the existing lifecycle assertion unchanged and prove+no-trigger scheduled execution grants neither proof nor Memory reads, even with+owner metadata. No new mechanism or identity exception is introduced.++Validation: all 410 cases in full `test_internal_server.py`, durable lifecycle+`test_session_delivery_fsm.py`, and delegated contracts pass. The original failing+scheduled lifecycle test is unchanged. New `MEMORY-SEARCH-033` exercises the real+shared scheduled gate with owner metadata but no trigger: dispatch remains+scheduled, host issuance omits proof, and HTTP reads deny without provider calls.+Changed Python Ruff passes. A new head requires fresh Codex review and CI.++### Active lifecycle closure (PM decision, 2026-09-17)++At `a8a79660e`, the required pause preceded five hermetic diagnostic cases:+authenticated same-Session creation produced an accepted delegated Task Turn;+local, different-owner, and ownerless Workbench P1 inputs all steered under its+scope; internal rebinding removed its owner; active OpenCode revival reissued a+valid proof but fresh-controller HTTP reads denied. The latter two are host+continuations, while different-owner steering is new authority.++| Lifecycle | Existing seam | Required authority behavior |+| --- | --- | --- |+| Definition creation / CLI edit | owner-bound proof accessor | same-Session re-admission; no caller grants |+| Host same-definition rebind | guarded store binding-only write | preserve owner/resource metadata and CAS/deletion/repoint guards |+| Queued/new Turn | durable hydration and batch identity | existing admission; one authority per batch |+| Active OpenCode revival | exact Session + live logical Turn/initial Delivery or accepted Message | shared context hydration + current admission before binding; no fallback to another Turn |+| P1 / pending P1 / send-now / restored steering | shared pre-native `_dispatch_steer_batch` | compare effective human/delegated owner/resource identity; refuse to existing queue fallback on mismatch |++Same-owner human continuation remains steerable. Comparison ignores resource+credential-refresh timestamps, not role/membership/instance identity. Human-only+steering remains outside this delegated boundary change. Ordinary CLI edits still+re-admit; no public trust flag, credential registry, or cross-Session creation is+introduced. Watch internal runtime writes already use separate guarded methods;+there is no automatic update_watch rebind caller. Only OpenCode revives active+native polls; Claude/Codex use fresh durable dispatch after restart.++Active-lifecycle evidence: the new contract file has 18 cases. `034` revives actual+Task/Watch polls with fresh controllers and HTTP reads, and denies missing,+wrong-Session, terminal, and currently revoked identity before publishing a proof.+While the revived poll remains active, incompatible P1 input queues without a+native write. `035` creates and authentically updates a task to `create_once`,+performs host binding recovery, reloads it, and dispatches an HTTP read under its+retained owner; ordinary proofless edits still remove delegation. Existing full+scheduled-task tests retain concurrent SQLite reclaim/CAS evidence. `036` covers+direct P1, pending P1, and queued send-now: different/no owner waits then receives+fresh scope/denial; the same local owner and refreshed remote owner still steer.+An ineligible IM group remains denied Memory and keeps its prior steering policy.+A previously established scope continues fencing input even if its binding is+revoked temporarily; current read checks still enforce revocation.++Validation layers: 1,026 combined focused cases passed before the final small+steering eligibility adjustment; 431 affected lifecycle/internal/restore cases+passed after the admission check, and final 223 delegated-lifecycle/durable-FSM+cases passed after retaining the established-scope fence (18 new cases, 205+existing FSM cases). Changed Python Ruff passes. These counts overlap and are+not additive. No real Incus/backend acceptance is claimed.diff --git a/modules/agents/opencode/agent.py b/modules/agents/opencode/agent.pyindex 3b793ba8e..a31945420 100644--- a/modules/agents/opencode/agent.py+++ b/modules/agents/opencode/agent.py@@ -26,6 +26,8 @@ from core.caller_context import (AVIBE_SESSION_ID_ENV,caller_env_for_platform_payload,validated_caller_env_snapshot,+ AVIBE_CALLER_SESSION_PROOF_ENV,+ issue_caller_session_proof,)from core.message_output import stop_output_for, terminal_output_forfrom core.memory_cli_access import configure_memory_cli_access@@ -1519,6 +1521,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):getattr(getattr(self, "controller", None), "config", None)),)+ binding_extra_env = {**caller_context_env, **managed_skills_env}binding_token = secrets.token_hex(16)binding_payload = request.context.platform_specific or {}binding_bound = False@@ -1529,7 +1532,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):binding_payload,base_env=os.environ,working_dir=request.working_path,- extra_env=managed_skills_env,+ extra_env=binding_extra_env,binding_token=binding_token,**_binding_path_kwargs(caller_context_binding_path),# The creation origin travels with the identity: an OpenCode shell@@ -1553,7 +1556,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):caller_context_binding_path,payload=binding_payload,working_directory=request.working_path,- extra_env=managed_skills_env,+ extra_env=binding_extra_env,initially_bound=bool(binding_bound),message=request.context,fallback_platform=platform,@@ -1592,7 +1595,7 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):request)if caller_context_env:- processing_indicator[_CALLER_CONTEXT_ENV_SNAPSHOT_KEY] = caller_context_env+ processing_indicator[_CALLER_CONTEXT_ENV_SNAPSHOT_KEY] = validated_caller_env_snapshot(caller_context_env)if project_base:processing_indicator[_MANAGED_SKILL_PROJECT_BASE_SNAPSHOT_KEY] = project_baseif BUILTIN_SKILLS_SNAPSHOT_ENV in managed_skills_env:@@ -2618,6 +2621,16 @@ class OpenCodeAgent(OpenCodeMessageProcessorMixin, BaseAgent):processing_snapshot.get(_CALLER_CONTEXT_ENV_SNAPSHOT_KEY))restored_context = restored_context_from_poll_info(poll_info)+ restored_session_id = str(+ (steering_snapshot.get("target_session_id") if isinstance(steering_snapshot, dict) else None)+ or poll_info.base_session_id or ""+ )+ if logical_turn_id and restored_session_id and restored_caller_env.get(AVIBE_SESSION_ID_ENV) == restored_session_id:+ memory_context = self.controller.session_turns.restore_memory_context(restored_session_id, logical_turn_id)+ admitted = memory_context is not None and configure_memory_cli_access(self.controller, memory_context)+ proof = issue_caller_session_proof(restored_session_id, turn_id=logical_turn_id) if admitted else None+ if proof:+ restored_caller_env[AVIBE_CALLER_SESSION_PROOF_ENV] = proofif (poll_platform == "avibe"and str(restored_context.user_id or "").startswith("remote:")diff --git a/storage/background.py b/storage/background.pyindex 2f0b2429d..3a19b00be 100644--- a/storage/background.py+++ b/storage/background.py@@ -3258,7 +3258,8 @@ def enqueue_run_in_connection(conn: Any, values: dict[str, Any]) -> None:class SQLiteBackgroundTaskStore:- def __init__(self, db_path: Optional[Path] = None):+ def __init__(self, db_path: Optional[Path] = None, *, include_private_metadata: bool = True):+ self._include_private_metadata = include_private_metadataself.db_path = db_path or paths.get_sqlite_state_path()guard_source_checkout_default_state_migration(self.db_path)self.db_path.parent.mkdir(parents=True, exist_ok=True)@@ -9125,6 +9126,11 @@ class SQLiteBackgroundTaskStore:# exit — and the row must not claim a waiter is dead on the# strength of never having looked.row["process_alive"] = None if runtime is None else bool(runtime.get("running"))+ if not self._include_private_metadata:+ from storage.message_deliveries import metadata_without_delegated_owner++ for row in rows:+ row["metadata"] = metadata_without_delegated_owner(row.get("metadata"))return rows@staticmethod@@ -9293,6 +9299,11 @@ class SQLiteBackgroundTaskStore:continuefor field, blank in blanks[site.source]().items():run.setdefault(field, blank)+ if not self._include_private_metadata:+ from storage.message_deliveries import metadata_without_delegated_owner++ for run in runs:+ run["metadata"] = metadata_without_delegated_owner(run.get("metadata"))return runs@staticmethoddiff --git a/storage/message_deliveries.py b/storage/message_deliveries.pyindex 6e364e19d..74008ec39 100644--- a/storage/message_deliveries.py+++ b/storage/message_deliveries.py@@ -4,6 +4,7 @@ import hashlibimport jsonimport timeimport uuid+from collections.abc import Mappingfrom datetime import datetime, timezonefrom typing import Any, Iterable, Literal@@ -206,6 +207,9 @@ def message_snapshot(if source == "harness" and author == "user" and resolved_type == "user":author = "harness"resolved_type = "harness"+ if source == "user":+ metadata = metadata_without_delegated_owner(metadata)+ metadata.pop("scheduled_provenance", None)filtered_metadata = {key: valuefor key, value in (metadata or {}).items()@@ -506,6 +510,169 @@ def delivery_has_remote_resource_context(row: dict[str, Any]) -> bool:)+def metadata_with_delegated_memory_owner(+ metadata: dict[str, Any], *, session_id: str | None+) -> dict[str, Any]:+ """Stamp same-Session delegation from its current host-owned Delivery.++ Caller identifiers locate the execution; caller-supplied owner values never+ authorize it. A continuation carries its already stamped owner without an+ ancestry lookup. Missing identity leaves ordinary Memory denial intact.+ """+ result = dict(metadata)+ result.pop("delegated_memory_owner", None)+ created_by = result.get("created_by")+ caller = created_by.get("caller") if isinstance(created_by, dict) else None+ if not session_id or not isinstance(caller, dict) or caller.get("session_id") != session_id:+ return result+ import asyncio+ import os+ from core.caller_context import AVIBE_CALLER_SESSION_PROOF_ENV+ from vibe.internal_client import delegated_memory_owner_sync, InternalServerUnavailable++ proof = os.environ.get(AVIBE_CALLER_SESSION_PROOF_ENV, "")+ if not proof:+ return result+ # Definition creation in a controller event loop must not synchronously+ # call its own socket. Agent CLI creation runs outside that loop.+ try:+ asyncio.get_running_loop()+ except RuntimeError:+ pass+ else:+ return result+ try:+ owner = delegated_memory_owner_sync(session_id, proof)+ except InternalServerUnavailable:+ return result+ if not owner:+ return result+ # Resource Owner is not itself a Memory identity. In particular a caller+ # cannot borrow another remote user's admitted Delivery by naming its Session.+ if owner.get("platform") == "avibe":+ remote = result.get("resource_user_context")+ expected = f"remote:{remote.get('sub')}" if isinstance(remote, dict) and remote.get("sub") else "local"+ if owner["user_id"] != expected:+ return result+ result["delegated_memory_owner"] = dict(owner)+ return result+++def current_delivery_memory_owner(session_id: str, *, turn_id: str | None = None) -> dict[str, Any] | None:+ """Host owner from an exact same-Session Turn, or the current candidate."""+ from storage.db import get_cached_sqlite_engine++ with get_cached_sqlite_engine().connect() as conn:+ turn = get_turn(conn, turn_id) if turn_id is not None else active_turn(conn, session_id)+ if not turn or turn["session_id"] != session_id:+ return None+ delivery = delivery_for_turn(conn, turn["id"])+ if delivery is None:+ return None+ payload = execution_delivery_payload(conn, delivery)+ return memory_owner_from_payload(payload)+++def execution_delivery_payload(conn: Connection, delivery: dict[str, Any]) -> dict[str, Any]:+ """Read this exact Delivery's immutable content, including after acceptance."""+ snapshot = message_for_delivery(conn, delivery) if delivery.get("message_id") else None+ return _delivery_payload_from_snapshot(delivery, snapshot) if snapshot else delivery_payload(delivery)+++def memory_owner_from_payload(payload: Mapping[str, Any]) -> dict[str, Any] | None:+ """One owner representation for authenticated humans and host continuations."""+ source_metadata = payload.get("metadata") or {}+ if payload.get("author") == "user" and payload.get("source") == "user":+ user_id = payload.get("author_id")+ if not user_id:+ user_id = legacy_admitted_user_id(source_metadata) if legacy_is_cli_admitted(source_metadata) else None+ owner = {+ "platform": payload.get("platform"),+ "user_id": user_id,+ "is_dm": "::user::" in str(payload.get("scope_id") or ""),+ }+ elif payload.get("source") == "harness":+ provenance = scheduled_delivery_provenance(payload)+ spec = provenance["platform_specific"] if provenance else {}+ trigger = spec.get("task_trigger_kind")+ metadata = spec.get("message_metadata")+ owner = (metadata.get("delegated_memory_owner")+ if isinstance(trigger, str) and trigger.strip() and isinstance(metadata, Mapping) else None)+ else:+ owner = None+ return delegated_memory_owner(owner)+++def delegated_memory_owner(value: object) -> dict[str, Any] | None:+ """Normalize the optional host owner fact; admission owns platform policy."""+ if not isinstance(value, Mapping):+ return None+ platform, user_id = value.get("platform"), value.get("user_id")+ if not all(isinstance(field, str) and field.strip() for field in (platform, user_id)):+ return None+ return {"platform": platform, "user_id": user_id, "is_dm": value.get("is_dm") is True}+++def scheduled_delivery_provenance(payload: Mapping[str, Any]) -> dict[str, Any] | None:+ """Only a host harness Delivery can restore scheduling authority."""+ if payload.get("source") != "harness":+ return None+ metadata = payload.get("metadata")+ provenance = metadata.get("scheduled_provenance") if isinstance(metadata, Mapping) else None+ spec = provenance.get("platform_specific") if isinstance(provenance, dict) else None+ return provenance if isinstance(spec, Mapping) else None+++def memory_authority_for_payload(payload: Mapping[str, Any]) -> str:+ """Compare human and delegated authority without credential-refresh noise."""+ owner = memory_owner_from_payload(payload)+ provenance = scheduled_delivery_provenance(payload)+ metadata = provenance["platform_specific"].get("message_metadata") if provenance else payload.get("metadata")+ resource = metadata.get("resource_user_context") if isinstance(metadata, Mapping) else None+ if isinstance(resource, Mapping):+ # Refreshing the same credential does not change its resource authority.+ resource = {key: value for key, value in resource.items()+ if key not in {"claims_issued_at", "authorization_expires_at"}}+ return _canonical_json([owner, resource])+++def metadata_without_delegated_owner(metadata: object) -> dict[str, Any]:+ """Project the two known owner locations without changing stored metadata."""+ result = dict(metadata) if isinstance(metadata, dict) else {}+ result.pop("delegated_memory_owner", None)+ provenance = result.get("scheduled_provenance")+ spec = provenance.get("platform_specific") if isinstance(provenance, dict) else None+ nested = spec.get("message_metadata") if isinstance(spec, dict) else None+ if isinstance(nested, dict):+ public_nested = dict(nested)+ public_nested.pop("delegated_memory_owner", None)+ result["scheduled_provenance"] = {+ **provenance, "platform_specific": {**spec, "message_metadata": public_nested},+ }+ return result+++def public_message_metadata(metadata: dict[str, Any]) -> dict[str, Any]:+ """Hide execution identity in both queued and accepted public messages."""+ def without_private_fields(value: dict[str, Any]) -> dict[str, Any]:+ return {+ key: item for key, item in value.items()+ if key != "resource_user_context"+ and not str(key).startswith(("_web_push_", "_memory_"))+ }++ result = without_private_fields(metadata_without_delegated_owner(metadata))+ provenance = result.get("scheduled_provenance")+ spec = provenance.get("platform_specific") if isinstance(provenance, dict) else None+ nested = spec.get("message_metadata") if isinstance(spec, dict) else None+ if isinstance(nested, dict):+ result["scheduled_provenance"] = {+ **provenance,+ "platform_specific": {**spec, "message_metadata": without_private_fields(nested)},+ }+ return result++def public_delivery_payload(row: dict[str, Any]) -> dict[str, Any]:"""Return a Delivery payload without server-owned identity metadata."""@@ -516,12 +683,7 @@ def public_delivery_payload(row: dict[str, Any]) -> dict[str, Any]:)metadata = payload.get("metadata")if isinstance(metadata, dict):- payload["metadata"] = {- key: value- for key, value in metadata.items()- if key != "resource_user_context"- and not str(key).startswith(("_web_push_", "_memory_"))- }+ payload["metadata"] = public_message_metadata(metadata)return payload@@ -538,6 +700,19 @@ _MESSAGE_MERGE_IDENTITY_FIELDS = ()+def _delegated_authority_merge_identity(metadata: Mapping[str, Any]) -> str:+ provenance = metadata.get("scheduled_provenance")+ spec = provenance.get("platform_specific") if isinstance(provenance, Mapping) else None+ nested = spec.get("message_metadata") if isinstance(spec, Mapping) else None+ # Compare raw authority, including absent/malformed values, before batching.+ # Execution IDs and unrelated metadata must not disable normal coalescing.+ return _canonical_json([+ {key: value.get(key) for key in ("delegated_memory_owner", "resource_user_context")}+ if isinstance(value, Mapping) else None+ for value in (metadata, nested)+ ])++def message_merge_identity(value: dict[str, Any]) -> tuple[Any, ...]:"""Return the Message fields that must stay singular after batching."""@@ -552,6 +727,7 @@ def message_merge_identity(value: dict[str, Any]) -> tuple[Any, ...]:return (*(value.get(field) for field in _MESSAGE_MERGE_IDENTITY_FIELDS[:-1]),kind,+ _delegated_authority_merge_identity(metadata),legacy_memory_merge_identity(metadata),)diff --git a/storage/messages_service.py b/storage/messages_service.pyindex 323b8e729..623cc5754 100644--- a/storage/messages_service.py+++ b/storage/messages_service.py@@ -87,10 +87,6 @@ def _new_message_id() -> str:return f"msg_{int(time.time() * 1_000_000):015x}{uuid.uuid4().hex[:8]}"-_PRIVATE_WEB_PUSH_METADATA_PREFIX = "_web_push_"-_PRIVATE_RESOURCE_USER_CONTEXT_KEY = "resource_user_context"--def _row_to_payload(row: dict[str, Any],*,@@ -121,12 +117,9 @@ def _row_to_payload(if not isinstance(metadata, dict):metadata = {}elif not include_private_metadata:- metadata = {- key: value- for key, value in metadata.items()- if key != _PRIVATE_RESOURCE_USER_CONTEXT_KEY- and not str(key).startswith(_PRIVATE_WEB_PUSH_METADATA_PREFIX)- }+ from storage.message_deliveries import public_message_metadata++ metadata = public_message_metadata(metadata)return {"id": row["id"],"scope_id": row.get("scope_id"),diff --git a/tests/conftest.py b/tests/conftest.pyindex 079ac0189..9ed23a52e 100644--- a/tests/conftest.py+++ b/tests/conftest.py@@ -199,6 +199,7 @@ def _isolate_vibe_remote_home(request, tmp_path, monkeypatch):# Harness/session assertions can bind themselves to the live Agent session.for name in ("AVIBE_SESSION_ID",+ "AVIBE_CALLER_SESSION_PROOF","AVIBE_RUN_ID","AVIBE_NATIVE_SESSION_ID","AVIBE_CALLER_SOURCE",diff --git a/tests/scenarios/memory_search/catalog.yaml b/tests/scenarios/memory_search/catalog.yamlindex f0d530b6a..087f286cc 100644--- a/tests/scenarios/memory_search/catalog.yaml+++ b/tests/scenarios/memory_search/catalog.yaml@@ -134,3 +134,100 @@ scenarios:kind: lifecyclelayer: contracttest: tests/test_memory_adapter.py::test_sender_name_snapshot_survives_rename_before_async_admission++ - id: MEMORY-SEARCH-021+ name: Same-Session Task and Watch retain default and named Memory reads+ status: covered+ kind: happy_path+ layer: scenario+ test: tests/test_memory_delegated_reads.py::test_delegated_read_survives_definition_and_controller_restart+ - id: MEMORY-SEARCH-022+ name: Persisted continuation restores read identity after controller restart without capture or write expansion+ status: covered+ kind: lifecycle+ layer: scenario+ test: tests/test_memory_delegated_reads.py::test_delegated_read_survives_definition_and_controller_restart+ - id: MEMORY-SEARCH-023+ name: Missing or caller-forged delegated owner cannot authorize Memory+ status: covered+ kind: authorization+ layer: contract+ test: tests/test_memory_delegated_reads.py::test_missing_and_forged_owner_stay_denied+ - id: MEMORY-SEARCH-024+ name: Delegated remote reads remain user-isolated and obey current binding revocation+ status: covered+ kind: authorization+ layer: scenario+ test: tests/test_memory_delegated_reads.py::test_remote_delegations_isolate_users_and_recheck_revoked_binding+ - id: MEMORY-SEARCH-025+ name: Session locator overrides cannot copy another IM user's delegated Memory owner+ status: covered+ kind: authorization+ layer: contract+ test: tests/test_memory_delegated_reads.py::test_im_session_override_rejected+ - id: MEMORY-SEARCH-026+ name: Public continuation and definition payloads hide owner without erasing runtime identity+ status: covered+ kind: boundary+ layer: contract+ test: tests/test_memory_delegated_reads.py::test_public_definition_projection_preserves_sqlite_runtime_owner+ - id: MEMORY-SEARCH-027+ name: Task and Watch execution Runs hide delegated owners in public output but retain runtime identity+ status: covered+ kind: boundary+ layer: scenario+ test: tests/test_cli_definition_read_projection.py::test_definition_to_run_public_projection_keeps_raw_execution_owner+ - id: MEMORY-SEARCH-028+ name: OpenCode initial binding failure retries with Session proof and preserves Task and Watch admission+ status: covered+ kind: lifecycle+ layer: scenario+ test: tests/test_agent_steering.py::test_opencode_coordinator_error_aborts_through_steering_owner+ - id: MEMORY-SEARCH-029+ name: Same-Session owner changes reject retained proofs even with caller subject override+ status: covered+ kind: authorization+ layer: scenario+ test: tests/test_memory_delegated_reads.py::test_owner_bound_proof_rejects_later_owner_and_subject_override+ - id: MEMORY-SEARCH-030+ name: Malformed persisted delegated owners omit execution proof without aborting launch+ status: covered+ kind: boundary+ layer: contract+ test: tests/test_memory_delegated_reads.py::test_malformed_persisted_owner_omits_proof+ - id: MEMORY-SEARCH-031+ name: Task and Watch batches preserve one owner and resource authorization per Turn+ status: covered+ kind: authorization+ layer: scenario+ test: tests/test_memory_delegated_reads.py::test_queued_authority_remains_singular+ - id: MEMORY-SEARCH-032+ name: Ordinary UI and preexisting user deliveries cannot inject scheduled Memory authority+ status: covered+ kind: authorization+ layer: scenario+ test: tests/test_memory_delegated_reads.py::test_ordinary_ui_injection_never_becomes_scheduled+ - id: MEMORY-SEARCH-033+ name: Explicit no-trigger harness dispatch stays scheduled without granting Memory authority+ status: covered+ kind: lifecycle+ layer: contract+ test: tests/test_memory_delegated_reads.py::test_no_trigger_harness_retains_scheduling_without_memory+ - id: MEMORY-SEARCH-034+ name: Active Task and Watch polls restore exact live authority through current admission+ status: covered+ kind: lifecycle+ layer: scenario+ test: tests/test_memory_delegated_lifecycle.py::test_active_poll_restores_proof_and_read_scope+ - id: MEMORY-SEARCH-035+ name: Host same-definition recovery preserves owner while ordinary edits re-admit+ status: covered+ kind: lifecycle+ layer: scenario+ test: tests/test_memory_delegated_lifecycle.py::test_internal_rebind_preserves_owner+ - id: MEMORY-SEARCH-036+ name: Direct pending promoted and restored steering cannot mix delegated authorities+ status: covered+ kind: authorization+ layer: scenario+ test: tests/test_memory_delegated_lifecycle.py::test_steering_preserves_effective_memory_authoritydiff --git a/tests/test_agent_steering.py b/tests/test_agent_steering.pyindex dd9358928..006a25216 100644--- a/tests/test_agent_steering.py+++ b/tests/test_agent_steering.py@@ -32,6 +32,15 @@ from modules.agents.opencode.poll_loop import OpenCodePollLoopfrom modules.agents.opencode.server import OpenCodePromptRejectedErrorfrom modules.im import MessageContext+from tests.test_memory_delegated_reads import (+ _create_definition,+ delegated_owner_transport, # noqa: F401 -- fixture with real internal accessor+)+from tests.test_session_delivery_fsm import (+ _context, _seed_session,+ _fsm_schema_template, managers, # noqa: F401 -- hermetic durable delivery fixtures+)+STEER_TEXT = "补充:**不要改写**\n```python\nprint('λ')\n```"ATTEMPT_ID = "atm_1234567890abcdef1234567890abcdef"@@ -959,10 +968,25 @@ async def test_opencode_replacement_waits_for_in_flight_steering_write() -> None@pytest.mark.anyioasync def test_opencode_coordinator_error_aborts_through_steering_owner(- monkeypatch, native_input,+ monkeypatch, native_input, managers, delegated_owner_transport, tmp_path,) -> None:+ """MEMORY-SEARCH-028: failed initial bind retries before delegated definitions."""+ from core.session_turns import DeliveryRequest++ manager, _fresh, engine, _other, _starts = managers+ _seed_session(engine, "avibe-session")+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ durable = await manager.deliver(+ DeliveryRequest(session_id="avibe-session", priority="p3", content="delegate", author_id="local"),+ context=_context("avibe-session"),+ )+ attempts = 0+ retry_succeeded = asyncio.Event()+ loop = asyncio.get_running_loop()+ monkeypatch.setattr("modules.agents.opencode.agent._CALLER_CONTEXT_BINDING_RETRY_SECONDS", 0)metadata, prefix = native_inputprimary = _primary_request(backend="opencode")+ primary.context.platform_specific["turn_token"] = durable.turn_idprimary.input_metadata = metadatapoll_started = asyncio.Event()fail_poll = asyncio.Event()@@ -1037,6 +1061,9 @@ async def test_opencode_coordinator_error_aborts_through_steering_owner(class _Sessions:def add_active_poll(self, **kwargs):+ snapshot = kwargs["processing_indicator"]["opencode_caller_context_env"]+ assert "AVIBE_SESSION_ID" in snapshot+ assert "AVIBE_CALLER_SESSION_PROOF" not in snapshotreturn Nonedef remove_active_poll(self, session_id):@@ -1088,6 +1115,20 @@ async def test_opencode_coordinator_error_aborts_through_steering_owner(binding_paths: list[str] = []def bind_caller_context(*args, **kwargs):+ nonlocal attempts+ attempts += 1+ if attempts == 1:+ raise OSError("initial binding write failed")+ from core.caller_context import verify_caller_session_proof++ env = kwargs["extra_env"]+ assert verify_caller_session_proof(env["AVIBE_SESSION_ID"], env["AVIBE_CALLER_SESSION_PROOF"], {"platform": "avibe", "user_id": "local"})+ for key, value in env.items():+ monkeypatch.setenv(key, value)+ for kind in ("scheduled", "watch"):+ definition = _create_definition(kind, tmp_path / f"retry-{kind}.json", session_id="avibe-session")+ assert definition.metadata["delegated_memory_owner"]["user_id"] == "local"+ loop.call_soon_threadsafe(retry_succeeded.set)binding_tokens.append(kwargs["binding_token"])binding_paths.append(kwargs["path"])return True@@ -1112,6 +1153,7 @@ async def test_opencode_coordinator_error_aborts_through_steering_owner(process_task = asyncio.create_task(agent._process_message(primary))agent._active_requests[primary.base_session_id] = process_taskawait poll_started.wait()+ await asyncio.wait_for(retry_succeeded.wait(), timeout=5)state = agent._steering_states[primary.base_session_id]assert state.awaiting_user_text == prefix + primary.messageassert state.awaiting_prompt_accepted is True@@ -1120,7 +1162,7 @@ async def test_opencode_coordinator_error_aborts_through_steering_owner(assert state.awaiting_active_status_observed is Falsetarget = ActiveSteerTarget(runtime_key=primary.base_session_id,- logical_turn_id="logical-turn",+ logical_turn_id=durable.turn_id,context=primary.context,agent_request=primary,agent=agent,@@ -1138,6 +1180,7 @@ async def test_opencode_coordinator_error_aborts_through_steering_owner(assert receipt.outcome is SteerOutcome.ACCEPTEDassert events == ["primary", "steer", "abort"]+ assert attempts == 2assert len(binding_tokens) == 1assert binding_paths == ["/old-avibe-home/runtime/opencode_caller_context.json"]assert unbound == [diff --git a/tests/test_caller_context.py b/tests/test_caller_context.pyindex 9db2d1530..178bdf778 100644--- a/tests/test_caller_context.py+++ b/tests/test_caller_context.py@@ -446,6 +446,14 @@ def test_a_session_scoped_caller_env_drops_only_the_per_turn_origin() -> None:session_stable_only=True,)assert set(full) - set(scoped) == {AVIBE_CALLER_USER_ID_ENV, AVIBE_CALLER_MESSAGE_ID_ENV}+ from core.caller_context import AVIBE_CALLER_SESSION_PROOF_ENV, validated_caller_env_snapshot++ # No durable execution owner in this pure caller-shape fixture.+ assert AVIBE_CALLER_SESSION_PROOF_ENV not in full+ assert AVIBE_CALLER_SESSION_PROOF_ENV not in scoped+ assert AVIBE_CALLER_SESSION_PROOF_ENV not in validated_caller_env_snapshot(full)+ assert AVIBE_CALLER_SESSION_PROOF_ENV not in caller_context_from_env(full).to_metadata()+def test_remote_workbench_caller_context_survives_env_and_claude_stable_form() -> None:@@ -536,3 +544,13 @@ def test_a_dm_loses_nothing_to_the_session_scoped_form() -> None:)assert captured is not Noneassert captured.session_stable().session_key == "slack::user::U0AUTHOR"+++def test_processing_indicator_projection_excludes_execution_env():+ from core.processing_indicator import ProcessingIndicatorHandle++ handle = ProcessingIndicatorHandle.from_snapshot({+ "platform": "slack", "user_id": "fixture",+ "opencode_caller_context_env": {"AVIBE_CALLER_SESSION_PROOF": "private-proof"},+ })+ assert "opencode_caller_context_env" not in handle.to_snapshot()diff --git a/tests/test_cli_definition_read_projection.py b/tests/test_cli_definition_read_projection.pyindex 7d1ae8c0c..2df40ba04 100644--- a/tests/test_cli_definition_read_projection.py+++ b/tests/test_cli_definition_read_projection.py@@ -2,6 +2,7 @@ from __future__ import annotationsimport jsonfrom datetime import datetime, timedelta, timezone+from types import SimpleNamespacefrom sqlalchemy import select, update@@ -387,3 +388,109 @@ def test_task_list_and_show_keep_unverifiable_retirements_unknown(capsys) -> Nonassert (shown["lifecycle_detail"], shown["state"]) == ("normal", "completed")finally:store.close()+++def test_public_definition_routes_hide_owner_without_changing_runtime_metadata():+ from tests.ui_server_test_helpers import csrf_headers++ private = {"delegated_memory_owner": {"platform": "slack", "user_id": "fixture", "is_dm": True},+ "resource_user_context": {"sub": "fixture"}}+ store = SQLiteBackgroundTaskStore()+ try:+ _task(store, "private-task", metadata=private)+ _watch(store, "private-watch", metadata=private)+ client = app.test_client()+ for plural, identifier, field, read in (+ ("tasks", "private-task", "task", store.get_scheduled_task),+ ("watches", "private-watch", "watch", store.get_watch),+ ):+ for query in ("", "?page=1&limit=20"):+ response = client.get(f"/api/harness/{plural}{query}")+ assert response.status_code == 200+ row = next(item for item in response.get_json()[plural] if item["id"] == identifier)+ assert "delegated_memory_owner" not in row["metadata"]+ for enabled in (False, True):+ response = client.patch(+ f"/api/harness/{plural}/{identifier}", json={"enabled": enabled},+ headers=csrf_headers(client),+ )+ assert response.status_code == 200+ assert "delegated_memory_owner" not in response.get_json()[field]["metadata"]+ assert all(read(identifier)["metadata"][key] == value for key, value in private.items())+ finally:+ store.close()+++def test_definition_to_run_public_projection_keeps_raw_execution_owner(capsys):+ """MEMORY-SEARCH-027: Task/Watch -> Run; Delivery/Message covered in delegated tests."""+ from core.scheduled_tasks import ScheduledTaskStore, TaskExecutionStore+ from core.watches import ManagedWatchService, ManagedWatchStore++ owner = {"platform": "slack", "user_id": "fixture", "is_dm": True}+ metadata = {"delegated_memory_owner": owner, "resource_user_context": {"sub": "fixture"},+ "scheduled_provenance": {"platform_specific": {"message_metadata": {+ "delegated_memory_owner": owner, "visible": "retained",+ }}}}+ store = SQLiteBackgroundTaskStore()+ requests = TaskExecutionStore()+ try:+ _task(store, "owner-task", metadata=metadata)+ _watch(store, "owner-watch", metadata=metadata)+ task = ScheduledTaskStore().get_task("owner-task")+ watch = ManagedWatchStore().get_watch("owner-watch")+ scheduled = requests.enqueue_task_run(task.id, task=task)+ service = ManagedWatchService.__new__(ManagedWatchService)+ service.request_store = requests+ hook = service._hook_request(watch, prompt="fixture", event_detected=True)+ requests.enqueue(hook)+ client = app.test_client()+ for run in (scheduled, hook):+ assert requests.get_run(run.id)["metadata"]["delegated_memory_owner"] == owner+ shown = client.get(f"/api/harness/runs/{run.id}").get_json()["run"]+ listed = next(row for row in client.get("/api/harness/runs?page=1&limit=20").get_json()["runs"]+ if row["id"] == run.id)+ assert cli.cmd_runs_show(SimpleNamespace(run_id=run.id)) == 0+ cli_run = json.loads(capsys.readouterr().out)["run"]+ for output in (shown, listed, cli_run):+ public = output["metadata"]+ assert "delegated_memory_owner" not in public+ assert public["resource_user_context"] == metadata["resource_user_context"]+ assert public["scheduled_provenance"]["platform_specific"]["message_metadata"] == {"visible": "retained"}+ reloaded = TaskExecutionStore().get_run(run.id)+ assert reloaded["metadata"]["delegated_memory_owner"] == owner+ assert reloaded["metadata"]["resource_user_context"] == metadata["resource_user_context"]+ finally:+ requests.sqlite_backend.close()+ store.close()+++def test_public_metadata_nonobjects_degrade_without_rewriting_rows(capsys):+ from sqlalchemy import select++ store = SQLiteBackgroundTaskStore()+ try:+ _task(store, "shape-task")+ _watch(store, "shape-watch")+ store.enqueue_run({"id": "shape-run", "request_type": "scheduled", "status": "queued",+ "created_at": NOW, "updated_at": NOW})+ client = app.test_client()+ for shape in (["legacy"], "legacy", []):+ encoded = json.dumps(shape)+ with store.engine.begin() as conn:+ conn.execute(update(run_definitions).values(metadata_json=encoded))+ conn.execute(update(agent_runs).values(metadata_json=encoded))+ for plural, identifier, field, command in (+ ("tasks", "shape-task", "definition", cli.cmd_task_show),+ ("watches", "shape-watch", "definition", cli.cmd_watch_show),+ ("runs", "shape-run", "run", lambda identifier: cli.cmd_runs_show(SimpleNamespace(run_id=identifier))),+ ):+ response = client.get(f"/api/harness/{plural}?page=1&limit=20")+ assert response.status_code == 200+ assert response.get_json()[plural][0]["metadata"] == {}+ assert command(identifier) == 0+ assert json.loads(capsys.readouterr().out)[field]["metadata"] == {}+ with store.engine.connect() as conn:+ assert conn.execute(select(run_definitions.c.metadata_json)).scalars().all() == [encoded, encoded]+ assert conn.execute(select(agent_runs.c.metadata_json)).scalar_one() == encoded+ finally:+ store.close()diff --git a/tests/test_internal_server.py b/tests/test_internal_server.pyindex 68e389ff8..e26e64063 100644--- a/tests/test_internal_server.py+++ b/tests/test_internal_server.py@@ -286,6 +286,7 @@ def _build_controller_double(handler=None):"""controller = MagicMock()+ controller.memory_read_scope_for_cli_session = lambda session_id: controller.memory_scope_for_cli_session(session_id)controller.message_handler = MagicMock()async def _handle_user_message(diff --git a/tests/test_memory_delegated_lifecycle.py b/tests/test_memory_delegated_lifecycle.pynew file mode 100644index 000000000..d0ab73566--- /dev/null+++ b/tests/test_memory_delegated_lifecycle.py@@ -0,0 +1,468 @@+"""Active native continuation, binding recovery, and steering authority contracts."""++import asyncio+from types import SimpleNamespace+from unittest.mock import AsyncMock+import pytest+from tests.test_session_delivery_fsm import managers, _fsm_schema_template, _context # noqa: F401+from tests.test_memory_delegated_reads import (+ delegated_owner_transport,+ _memory_controller,+ _publish_caller_env,+ _create_definition,+ _search,+) # noqa: F401+from core.session_turns import DeliveryRequest, capture_scheduled_provenance+from core.scheduled_tasks import ScheduledTaskService, ScheduledTaskStore, parse_session_key+from core.memory_cli_access import configure_memory_cli_access+from core.services.agent_steering import SteerOutcome+from core.services.agent_steering import result as steer_result+++def active_delegated(managers, delegated_owner_transport, monkeypatch, tmp_path, request):+ manager, fresh, engine, _, _ = managers+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ monkeypatch.setattr("core.internal_server.get_cached_sqlite_engine", lambda: engine)+ kind = getattr(request, "param", "scheduled")+ remote = kind == "remote"+ create_once = kind == "create_once"+ kind = "scheduled" if remote or create_once else kind+ resource = None+ if remote:+ from config.v2_config import V2Config+ from storage import remote_access_authorization_service as auth+ from storage.resource_access_service import ResourceUserContext++ monkeypatch.setattr(auth, "get_cached_sqlite_engine", lambda: engine)+ config = V2Config.default()+ config.remote_access.vibe_cloud.enabled = True+ config.remote_access.vibe_cloud.instance_id = "fixture-instance"+ config.remote_access.vibe_cloud.instance_kind = "personal"+ config.remote_access.vibe_cloud.instance_secret = "fixture-not-real"+ config.save()+ transition = auth.begin_instance_binding_transition(instance_id="fixture-instance", instance_kind="personal")+ auth.complete_instance_binding_transition(+ instance_id="fixture-instance", instance_kind="personal", generation=transition["generation"]+ )+ resource = ResourceUserContext(+ subject="alice",+ instance_role="owner",+ instance_access_source="owner",+ instance_id="fixture-instance",+ instance_kind="personal",+ is_remote=True,+ )+ owner = "remote:alice" if remote else "local"+ controller = _memory_controller()+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ manager.controller._memory_admission = controller._memory_admission+ manager.controller._memory_scopes_by_session = controller._memory_scopes_by_session+ definitions = []++ def context(sid="ses_fsm"):+ ctx = _context(sid)+ ctx.platform_specific["agent_session_target"]["agent_backend"] = "opencode"+ return ctx++ manager._build_context = context++ def accept(ctx):+ token = ctx.platform_specific["turn_token"]+ manager._active_identity = lambda _b, _s, logical: (logical, "opencode:oc-1:1")+ manager.on_native_start(ctx, backend="opencode", runtime_key="oc-1", runtime_turn_id="1")++ async def direct(_s, ctx, _t, **kw):+ accept(ctx)+ _publish_caller_env(monkeypatch, ctx)+ if resource:+ task = await asyncio.to_thread(+ ScheduledTaskStore(tmp_path / "task.json").add_task,+ session_key="avibe::channel::ses_fsm",+ session_id="ses_fsm",+ prompt="recall",+ schedule_type="at",+ timezone_name="UTC",+ run_at="2099-01-01T00:00:00+00:00",+ metadata={"created_by": {"caller": {"session_id": "ses_fsm"}}},+ user_context=resource,+ )+ else:+ task = await asyncio.to_thread(_create_definition, kind, tmp_path / "task.json")+ if create_once:+ store = ScheduledTaskStore(tmp_path / "task.json")+ task = await asyncio.to_thread(+ store.update_task,+ task.id,+ name=task.name,+ session_key=task.session_key,+ session_id=task.session_id,+ prompt=task.prompt,+ schedule_type=task.schedule_type,+ post_to=task.post_to,+ deliver_key=task.deliver_key,+ cron=task.cron,+ run_at=task.run_at,+ timezone_name=task.timezone,+ session_policy="create_once",+ metadata=task.metadata,+ )+ assert task.metadata["delegated_memory_owner"]["user_id"] == owner+ definitions.append(task)++ manager._run = direct+ from storage.resource_access_service import metadata_with_resource_user_context++ first = asyncio.run(+ manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p3",+ content="delegate",+ author_id=owner,+ metadata=metadata_with_resource_user_context({}, resource),+ ),+ context=context(),+ )+ )+ manager._terminalize_durable_turn(+ first.turn_id, "completed", settled_by="terminal_result", evidence_kind="fixture", resume_successors=False+ )++ async def task_start(_s, ctx, _t, **kw):+ accept(ctx)+ assert configure_memory_cli_access(controller, ctx)++ manager._run = task_start++ async def start():+ task = definitions[0]+ ctx = await ScheduledTaskService(+ controller=controller, store=ScheduledTaskStore(tmp_path / "task.json")+ )._build_context(+ parse_session_key("avibe::channel::ses_fsm"),+ session_id="ses_fsm",+ execution_id="",+ task_id=task.id,+ trigger_kind=kind,+ metadata=task.metadata,+ )+ return await manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p3",+ content="Alice delegated prompt",+ source="harness",+ author="harness",+ author_id=task.id,+ metadata={**task.metadata, "scheduled_provenance": capture_scheduled_provenance(ctx)},+ ),+ context=ctx,+ )++ active = asyncio.run(start())+ assert active.turn_id+ asyncio.run(_search(controller))+ return manager, fresh, engine, controller, definitions[0], active, tmp_path++[email protected]("mode", ["direct", "promote", "pending"])[email protected]("user", ["local", "remote:bob", None])+def test_steering_preserves_effective_memory_authority(active_delegated, user, mode):+ """MEMORY-SEARCH-036: native steering never mixes delegated authorities."""+ manager, _, engine, controller, task, active, tmp = active_delegated+ manager._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))+ scope = asyncio.run(_search(controller))+ result = asyncio.run(+ manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p1" if mode == "direct" else "p3",+ content="incoming request",+ author_id=user,+ message_kind="original",+ ),+ context=_context(),+ )+ )+ from storage import message_deliveries++ if mode == "promote":+ asyncio.run(manager.send_now("ses_fsm"))+ elif mode == "pending":+ with engine.begin() as conn:+ message_deliveries.open_pending_steer_batch(+ conn,+ deliveries=[message_deliveries.get_delivery(conn, result.delivery_id)],+ turn_id=active.turn_id,+ attempt_id=message_deliveries.new_attempt_id(),+ )+ asyncio.run(manager._run_pending_steers("ses_fsm", active.turn_id, _context()))+ with engine.connect() as conn:+ state = message_deliveries.get_delivery(conn, result.delivery_id)["state"]+ assert asyncio.run(_search(controller)) == scope+ if user == "local":+ assert state == "accepted"+ manager._steer.assert_awaited_once()+ else:+ assert state == "queued"+ manager._steer.assert_not_called()+ next_scopes = []++ async def following(_s, ctx, _text, **_kw):+ admitted = configure_memory_cli_access(controller, ctx)+ next_scopes.append(await _search(controller, status=200 if admitted else 403))++ manager._run = following+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ asyncio.run(manager.terminalize_turn(active.turn_id))+ assert len(next_scopes) == 1 and next_scopes[0] != scope++[email protected]("active_delegated", ["create_once"], indirect=True)+def test_internal_rebind_preserves_owner(active_delegated, monkeypatch):+ """MEMORY-SEARCH-035: host rebind preserves identity, CLI edit re-admits."""+ manager, _, engine, controller, task, active, tmp = active_delegated+ store = ScheduledTaskStore(tmp / "task.json")+ task = store.get_task(task.id)+ assert task.metadata["delegated_memory_owner"]["user_id"] == "local"+ monkeypatch.delenv("AVIBE_CALLER_SESSION_PROOF", raising=False)+ service = ScheduledTaskService(controller=controller, store=store)+ assert task.session_policy == "create_once"+ assert service._persist_task_session_id(task, "replacement-session")+ restored = ScheduledTaskStore(tmp / "task.json").get_task(task.id)+ assert restored.metadata["delegated_memory_owner"] == task.metadata["delegated_memory_owner"]+ assert restored.session_id == "replacement-session"+ from tests.test_session_delivery_fsm import _seed_session+ from core.internal_server import create_app+ from vibe.memory_http_headers import CALLER_SESSION_HEADER+ import httpx++ _seed_session(engine, "replacement-session")+ old_scope = asyncio.run(_search(controller))+ reads = []++ async def rebound_dispatch(_session, ctx, _text, **_kw):+ assert configure_memory_cli_access(controller, ctx)+ async with httpx.AsyncClient(+ transport=httpx.ASGITransport(app=create_app(controller)), base_url="http://test"+ ) as client:+ response = await client.post(+ "/internal/memory/search",+ headers={CALLER_SESSION_HEADER: "replacement-session"},+ json={"query": "fixture", "policy": {"mode": "keyword"}},+ )+ assert response.status_code == 200+ reads.append(controller.memory_search_payload.call_args.kwargs["cli_scope"])++ manager._run = rebound_dispatch++ async def dispatch_rebound():+ ctx = await service._build_context(+ parse_session_key(restored.session_key),+ session_id=restored.session_id,+ execution_id="",+ task_id=restored.id,+ trigger_kind="scheduled",+ metadata=restored.metadata,+ )+ await manager.deliver(+ DeliveryRequest(+ session_id=restored.session_id,+ priority="p3",+ content="rebound prompt",+ source="harness",+ author="harness",+ author_id=restored.id,+ metadata={**restored.metadata, "scheduled_provenance": capture_scheduled_provenance(ctx)},+ ),+ context=ctx,+ )++ asyncio.run(dispatch_rebound())+ assert reads == [old_scope]+ # Ordinary caller editing without its proof still loses delegation.+ service.store.update_task(+ restored.id,+ name=restored.name,+ session_key=restored.session_key,+ session_id=restored.session_id,+ prompt=restored.prompt,+ schedule_type=restored.schedule_type,+ post_to=restored.post_to,+ deliver_key=restored.deliver_key,+ cron=restored.cron,+ run_at=restored.run_at,+ timezone_name=restored.timezone,+ metadata=restored.metadata,+ )+ assert "delegated_memory_owner" not in service.store.get_task(restored.id).metadata+++ "active_delegated, denial",+ [+ ("scheduled", None),+ ("watch", None),+ ("scheduled", "missing"),+ ("scheduled", "mismatched"),+ ("scheduled", "terminal"),+ ("remote", "revoked"),+ ],+ indirect=["active_delegated"],+)+def test_active_poll_restores_proof_and_read_scope(active_delegated, monkeypatch, denial):+ """MEMORY-SEARCH-034: revive exact live native work through current admission."""+ from tests.test_opencode_restore_polls import _make_poll, _build_agent+ from core.caller_context import verify_caller_session_proof++ manager, fresh, engine, old, task, active, tmp = active_delegated+ poll = _make_poll(platform="avibe", base_session_id="ses_fsm", opencode_session_id="oc-1")+ poll.processing_indicator = {+ "platform": "avibe",+ "user_id": task.id,+ "opencode_native_steering": {"target_session_id": "ses_fsm", "logical_turn_id": active.turn_id},+ "opencode_caller_context_env": {"AVIBE_SESSION_ID": "ses_fsm", "AVIBE_CALLER_PLATFORM": "avibe"},+ }+ if denial == "missing":+ poll.processing_indicator["opencode_native_steering"]["logical_turn_id"] = "missing"+ elif denial == "mismatched":+ poll.processing_indicator["opencode_native_steering"]["target_session_id"] = "other-session"+ poll.processing_indicator["opencode_caller_context_env"]["AVIBE_SESSION_ID"] = "other-session"+ elif denial == "terminal":+ manager._terminalize_durable_turn(+ active.turn_id, "completed", settled_by="terminal_result", evidence_kind="fixture", resume_successors=False+ )+ elif denial == "revoked":+ from storage import remote_access_authorization_service as auth++ auth.begin_instance_binding_transition(instance_id="replacement-instance", instance_kind="personal")+ agent, *_ = _build_agent({"oc-1": poll})+ new = _memory_controller()+ new.processing_indicator = agent.controller.processing_indicator+ new.session_turns = agent.controller.session_turns+ new.session_turns.controller = new+ new.session_turns._engine = engine+ new.session_turns._build_context = _context+ new.set_agent_status = lambda *args: None+ new.agent_service = agent.controller.agent_service+ agent.controller = new+ bound = []+ monkeypatch.setattr(+ "modules.agents.opencode.agent.bind_caller_context_session", lambda *args, **kw: bound.append(kw) or True+ )+ monkeypatch.setattr("modules.agents.opencode.agent.unbind_caller_context_session", lambda *args, **kw: True)++ async def run():+ release = asyncio.Event()++ async def active_poll(_poll):+ await release.wait()+ return True++ agent._poll_loop.run_restored_poll_loop = active_poll+ assert await agent.restore_active_polls() == 1+ await _search(new, status=403 if denial else 200)+ if not denial:+ new.session_turns._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))+ result = await new.session_turns.deliver(+ DeliveryRequest(+ session_id="ses_fsm", priority="p1", content="different user's follow-up", author_id="remote:bob"+ ),+ context=_context(),+ )+ assert result.state == "queued"+ new.session_turns._steer.assert_not_called()+ await _search(new)+ release.set()+ await asyncio.gather(*agent._active_requests.values())++ asyncio.run(run())+ if denial:+ assert "AVIBE_CALLER_SESSION_PROOF" not in bound[0]["extra_env"]+ new.memory_search_payload.assert_not_called()+ else:+ assert verify_caller_session_proof(+ "ses_fsm", bound[0]["extra_env"]["AVIBE_CALLER_SESSION_PROOF"], {"platform": "avibe", "user_id": "local"}+ )+ assert new.memory_search_payload.await_count == 2++[email protected]("active_delegated", ["remote"], indirect=True)+def test_same_remote_owner_refresh_remains_steerable(active_delegated):+ """A credential refresh preserves the same owner's resource authority."""+ from dataclasses import replace+ from storage.resource_access_service import metadata_with_resource_user_context, resource_user_context_from_metadata++ manager, _, _, controller, task, active, _ = active_delegated+ resource = resource_user_context_from_metadata(task.metadata)+ refreshed = replace(resource, claims_issued_at=(resource.claims_issued_at or 0) + 1)+ manager._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))+ before = asyncio.run(_search(controller))+ result = asyncio.run(+ manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p1",+ content="same owner's follow-up",+ author_id="remote:alice",+ metadata=metadata_with_resource_user_context({}, refreshed),+ ),+ context=_context(),+ )+ )+ assert result.state == "accepted"+ manager._steer.assert_awaited_once()+ assert asyncio.run(_search(controller)) == before+++def test_memory_ineligible_group_does_not_change_steering_policy(managers):+ """Denied group Memory is not an active delegated authority to fence."""+ manager, _, _, _, _ = managers+ controller = _memory_controller()+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ manager.controller._memory_admission = controller._memory_admission+ owner = {"platform": "slack", "user_id": "U1", "is_dm": False}+ metadata = {"delegated_memory_owner": owner}+ starts = []++ async def start(_s, ctx, _text, **_kw):+ token = ctx.platform_specific["turn_token"]+ manager._active_identity = lambda _b, _s, logical: (logical, f"native-{logical}")+ manager.on_native_start(ctx, backend="codex", runtime_key="fixture", runtime_turn_id=token)+ assert not configure_memory_cli_access(controller, ctx)+ starts.append(token)++ manager._run = start+ asyncio.run(+ manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p3",+ content="group task",+ source="harness",+ author="harness",+ metadata={+ **metadata,+ "scheduled_provenance": {+ "platform_specific": {"task_trigger_kind": "scheduled", "message_metadata": metadata}+ },+ },+ ),+ context=_context(),+ )+ )+ assert starts+ manager._steer = AsyncMock(return_value=steer_result(SteerOutcome.ACCEPTED))+ result = asyncio.run(+ manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm", priority="p1", content="group follow-up", platform="slack", author_id="U2"+ ),+ context=_context(),+ )+ )+ assert result.state == "accepted"+ manager._steer.assert_awaited_once()+ asyncio.run(_search(controller, status=403))+ controller.memory_search_payload.assert_not_called()diff --git a/tests/test_memory_delegated_reads.py b/tests/test_memory_delegated_reads.pynew file mode 100644index 000000000..5d562a8d8--- /dev/null+++ b/tests/test_memory_delegated_reads.py@@ -0,0 +1,832 @@+"""Creation -> durable dispatch -> Memory read contracts, with test-owned state."""++from __future__ import annotations++import asyncio+import hashlib+from types import SimpleNamespace+from pathlib import Path+from unittest.mock import AsyncMock++import httpx+import pytest++from core.controller import Controller+from core.internal_server import create_app+from core.memory_cli_access import configure_memory_cli_access+from core.scheduled_tasks import ScheduledTaskService, ScheduledTaskStore, parse_session_key+from core.session_turns import DeliveryRequest+from core.watches import ManagedWatchStore+from storage import message_deliveries+from tests.test_session_delivery_fsm import (+ _context,+ _fsm_schema_template, # noqa: F401 -- imported pytest fixture+ managers, # noqa: F401 -- imported pytest fixture+)+from vibe.memory_http_headers import CALLER_SESSION_HEADER+++pytestmark = pytest.mark.usefixtures("delegated_owner_transport")+++def delegated_owner_transport(monkeypatch, tmp_path):+ """Real client serialization + ASGI endpoint + verifier, no admitted flag."""+ app = create_app(_memory_controller())++ class InternalTransport(httpx.BaseTransport):+ def handle_request(self, request):+ async def dispatch():+ async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test") as client:+ response = await client.request(request.method, str(request.url),+ headers=request.headers, content=request.read())+ return httpx.Response(response.status_code, headers=response.headers, content=response.content)+ return asyncio.run(dispatch())++ monkeypatch.setattr("vibe.internal_client._verified_socket_path", lambda _path: tmp_path / "test.sock")+ monkeypatch.setattr("vibe.internal_client.httpx.HTTPTransport", lambda **_kwargs: InternalTransport())+++def memory_owner_turn(managers, monkeypatch):+ """Host-owned accepted Delivery for backend proof lifecycle tests."""+ from tests.test_session_delivery_fsm import _seed_session++ manager, _fresh, engine, _other, _starts = managers+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ sessions = {"ses_fsm"}++ def create(session_id="ses_wb", owner="remote:user-1", *, terminal=True):+ if session_id not in sessions:+ _seed_session(engine, session_id)+ sessions.add(session_id)++ async def accept(_session, ctx, _text, **_kwargs):+ token = ctx.platform_specific["turn_token"]+ manager._active_identity = lambda _backend, _session, logical: (logical, f"native-{logical}")+ manager.on_native_start(ctx, backend="codex", runtime_key=f"runtime-{token}", runtime_turn_id=token)++ manager._run = accept+ result = asyncio.run(manager.deliver(+ DeliveryRequest(session_id=session_id, priority="p3", content="fixture", author_id=owner),+ context=_context(session_id),+ ))+ if terminal:+ manager._terminalize_durable_turn(result.turn_id, "completed", settled_by="terminal_result",+ evidence_kind="fixture", resume_successors=False)+ return result.turn_id++ return create+++def _publish_caller_env(monkeypatch, context):+ from core.caller_context import caller_env_for_platform_payload++ env = caller_env_for_platform_payload(context.platform_specific, message=context)+ for key, value in env.items():+ monkeypatch.setenv(key, value)+ return env+++def _memory_controller():+ controller = Controller.__new__(Controller)+ controller.config = SimpleNamespace(platform="avibe", memory=SimpleNamespace(enabled=True))+ controller.platform_settings_managers = {}+ controller.im_clients = {"avibe": SimpleNamespace(should_use_thread_for_reply=lambda: False)}+ controller.get_im_client_for_context = lambda _ctx: controller.im_clients["avibe"]+ controller._memory_scopes_by_session = {}+ controller._memory_cli_facts_by_session = {}+ controller.memory_runtime = SimpleNamespace(+ principal_for_user_key=lambda key: "u-" + hashlib.md5(key.encode()).hexdigest(),+ )+ controller.memory_search_payload = AsyncMock(return_value={"status": "ok", "items": []})+ return controller+++async def _search(controller, *, project="default", status=200):+ app = create_app(controller)+ async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test") as client:+ response = await client.post(+ "/internal/memory/search",+ headers={CALLER_SESSION_HEADER: "ses_fsm"},+ json={"query": "non-sensitive fixture", "policy": {"mode": "keyword"}, "project": project},+ )+ assert response.status_code == status, response.text+ if status == 200:+ call = controller.memory_search_payload.call_args.kwargs+ assert call["project_id"] == project+ return call["cli_scope"]+++async def _persist_and_hydrate_scheduled(manager, controller, context):+ """Use shared scheduled ingress and hydrate its actual durable snapshot."""+ from core.session_turns import capture_scheduled_provenance++ receipt = await manager.deliver(DeliveryRequest(session_id="ses_fsm", priority="p3", content="fixture",+ source="harness", author="harness", metadata={+ **context.platform_specific["message_metadata"],+ "scheduled_provenance": capture_scheduled_provenance(context),+ }), context=_context())+ with manager._sqlite_engine().connect() as conn:+ row = message_deliveries.get_delivery(conn, receipt.delivery_id)+ manager._hydrate_delivery_context(context, row)+ manager._restore_scheduled_dispatch_context(context, row)+ with manager._sqlite_engine().begin() as conn:+ assert message_deliveries.retire_queued(conn, "ses_fsm", row["id"])+ return context+++def _create_definition(kind, path, *, owner_metadata=None, session_id="ses_fsm"):+ metadata = owner_metadata or {"created_by": {"caller": {"session_id": session_id, "user_id": "FORGED"}}}+ if kind == "scheduled":+ store = ScheduledTaskStore(path)+ definition = store.add_task(+ session_key=f"avibe::channel::{session_id}",+ session_id=session_id,+ prompt="find fixture",+ schedule_type="at",+ timezone_name="UTC",+ run_at="2099-01-01T00:00:00+00:00",+ metadata=metadata,+ )+ return ScheduledTaskStore(path).get_task(definition.id)+ store = ManagedWatchStore(path)+ definition = store.add_watch(+ name="fixture watch",+ session_key=f"avibe::channel::{session_id}",+ session_id=session_id,+ command=["true"],+ shell_command=None,+ prefix="find fixture",+ cwd=None,+ mode="once",+ timeout_seconds=0,+ lifetime_timeout_seconds=0,+ retry_exit_codes=[75],+ retry_delay_seconds=1,+ post_to=None,+ deliver_key=None,+ metadata=metadata,+ )+ return ManagedWatchStore(path).get_watch(definition.id)++[email protected]("kind", ["scheduled", "watch"])+def test_delegated_read_survives_definition_and_controller_restart(managers, monkeypatch, tmp_path, kind):+ """MEMORY-SEARCH-021/022: real admission and persisted Task/Watch, fresh dispatch."""+ manager, fresh, engine, _other_engine, _starts = managers+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ monkeypatch.setattr("core.internal_server.get_cached_sqlite_engine", lambda: engine)+ direct = _memory_controller()+ direct.session_turns = manager+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ observed = []+ completed = []++ def accept(manager, context):+ token = context.platform_specific["turn_token"]+ manager._active_identity = lambda _backend, _session, logical: (logical, f"native-{logical}")+ manager.on_native_start(context, backend="codex", runtime_key=f"runtime-{token}", runtime_turn_id=token)++ definitions = []++ async def direct_start(_session, context, _text, **_kwargs):+ accept(manager, context)+ _publish_caller_env(monkeypatch, context)+ assert configure_memory_cli_access(direct, context)+ observed.append(await _search(direct))+ assert await _search(direct, project="notes") == observed[0]+ assert direct.memory_scope_for_cli_session("ses_fsm") == observed[0]+ definition = await asyncio.to_thread(_create_definition, kind, tmp_path / f"{kind}.json")+ definitions.append(definition)+ assert definition.metadata["delegated_memory_owner"]["user_id"] == "local"+ scheduler = ScheduledTaskService(controller=direct, store=ScheduledTaskStore(tmp_path / "dispatch.json"))+ scheduled = await scheduler._build_context(+ parse_session_key("avibe::channel::ses_fsm"),+ session_id="ses_fsm",+ execution_id="",+ task_id=definition.id,+ trigger_kind=kind,+ metadata=definition.metadata,+ )+ result = await direct.session_turn_gate.submit_scheduled(+ "ses_fsm", scheduled, "find fixture", delivery_intent="queue"+ )+ assert result.queue_persisted++ manager._run = direct_start++ async def exercise():+ first = await manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p3",+ content="delegate fixture lookup",+ author_id="local",+ message_kind="original",+ ),+ context=_context(),+ )+ definition = definitions[0]+ manager._terminalize_durable_turn(+ first.turn_id, "completed", settled_by="terminal_result", evidence_kind="fixture", resume_successors=False+ )+ # Restart drops the ephemeral process key; persisted owner facts alone+ # restore read scope, and a new shell receives a fresh Session proof.+ import secrets+ from core.caller_context import caller_env_for_platform_payload++ monkeypatch.setattr("core.caller_context._SESSION_PROOF_KEY", secrets.token_bytes(32))+ restarted = _memory_controller()+ fresh.controller.config.memory = SimpleNamespace(enabled=True)++ async def resumed(_session, ctx, _text, **_kwargs):+ accept(fresh, ctx)+ assert ctx.is_original_human_text is False+ from dataclasses import replace+ from avibe_memory.types import CaptureSkipped++ capture = restarted._memory_admission().decide(+ replace(+ restarted._memory_turn_facts(ctx),+ session_id="ses_fsm",+ text="synthetic fixture",+ )+ )+ assert isinstance(capture, CaptureSkipped)+ assert ctx.platform_specific["author_id"] == definition.id+ assert configure_memory_cli_access(restarted, ctx)+ assert await _search(restarted) == observed[0]+ assert await _search(restarted, project="notes") == observed[0]+ assert restarted.memory_scope_for_cli_session("ses_fsm") is None+ app = create_app(restarted)+ async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test") as client:+ response = await client.post(+ "/internal/memory/remember",+ headers={CALLER_SESSION_HEADER: "ses_fsm"},+ json={"text": "synthetic input"},+ )+ assert response.status_code == 403+ # Task -> Watch must use the stamped owner, not the synthetic author.+ for key, value in caller_env_for_platform_payload(ctx.platform_specific, message=ctx).items():+ monkeypatch.setenv(key, value)+ chained = await asyncio.to_thread(_create_definition, "watch", tmp_path / "chained.json")+ assert chained.metadata["delegated_memory_owner"] == definition.metadata["delegated_memory_owner"]+ completed.append(True)++ fresh._run = resumed+ await fresh.recover_durable_delivery_state(service_restart=True)+ assert restarted.memory_search_payload.call_count == 2+ assert completed == [True]++ asyncio.run(exercise())+++def test_missing_and_forged_owner_stay_denied(managers, monkeypatch, tmp_path):+ """MEMORY-SEARCH-023: caller identity fields cannot manufacture a grant."""+ manager, _fresh, engine, _other_engine, _starts = managers+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ monkeypatch.setattr("core.internal_server.get_cached_sqlite_engine", lambda: engine)+ definition = _create_definition(+ "scheduled",+ tmp_path / "missing.json",+ owner_metadata={+ "created_by": {"caller": {"session_id": "ses_fsm", "user_id": "local"}},+ "delegated_memory_owner": {"platform": "avibe", "user_id": "local"},+ },+ )+ assert "delegated_memory_owner" not in definition.metadata+ controller = _memory_controller()+ context = _context()+ context.platform_specific.update(turn_source="scheduled", task_trigger_kind="scheduled", author_id=definition.id)+ assert not configure_memory_cli_access(controller, context)+ asyncio.run(_search(controller, status=403))+ controller.memory_search_payload.assert_not_called()+++def test_remote_delegations_isolate_users_and_recheck_revoked_binding(managers, monkeypatch, tmp_path):+ """MEMORY-SEARCH-024: same project names retain user isolation; revocation wins."""+ from config.v2_config import V2Config+ from storage import remote_access_authorization_service as auth+ from storage.resource_access_service import ResourceUserContext++ manager, _fresh, engine, _other_engine, _starts = managers+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ monkeypatch.setattr("core.internal_server.get_cached_sqlite_engine", lambda: engine)+ monkeypatch.setattr(auth, "get_cached_sqlite_engine", lambda: engine)+ config = V2Config.default()+ config.remote_access.vibe_cloud.enabled = True+ config.remote_access.vibe_cloud.instance_id = "fixture-instance"+ config.remote_access.vibe_cloud.instance_kind = "personal"+ config.remote_access.vibe_cloud.instance_secret = "fixture-not-a-real-credential"+ config.save()+ transition = auth.begin_instance_binding_transition(instance_id="fixture-instance", instance_kind="personal")+ auth.complete_instance_binding_transition(+ instance_id="fixture-instance", instance_kind="personal", generation=transition["generation"]+ )+ results = []+ controllers = []+ manager.controller.config.memory = SimpleNamespace(enabled=True)++ async def exercise():+ for user in ("alice", "bob"):+ resource = ResourceUserContext(+ subject=user,+ instance_role="owner",+ instance_access_source="owner",+ instance_id="fixture-instance",+ instance_kind="personal",+ is_remote=True,+ )+ controller = _memory_controller()+ controllers.append(controller)++ async def creating(_session, ctx, _text, **_kwargs):+ token = ctx.platform_specific["turn_token"]+ manager._active_identity = lambda _backend, _session, logical: (logical, f"native-{logical}")+ manager.on_native_start(ctx, backend="codex", runtime_key=f"runtime-{token}", runtime_turn_id=token)+ _publish_caller_env(monkeypatch, ctx)+ store = ScheduledTaskStore(tmp_path / f"{user}.json")+ args = dict(+ session_key="avibe::channel::ses_fsm",+ session_id="ses_fsm",+ prompt="recall",+ schedule_type="at",+ timezone_name="UTC",+ run_at="2099-01-01T00:00:00+00:00",+ )+ metadata = {"created_by": {"caller": {"session_id": "ses_fsm", "user_id": "remote:other"}}}+ task = await asyncio.to_thread(store.add_task, **args, metadata=metadata, user_context=resource)+ # A different subject cannot take the current Delivery's owner.+ from dataclasses import replace++ forged = await asyncio.to_thread(store.add_task, **args, metadata=metadata, user_context=replace(resource, subject="other"))+ assert "delegated_memory_owner" not in forged.metadata+ scheduler = ScheduledTaskService(controller=controller, store=store)+ continued = await scheduler._build_context(+ parse_session_key(args["session_key"]),+ session_id="ses_fsm",+ execution_id=f"run-{user}",+ task_id=task.id,+ metadata=task.metadata,+ trigger_kind="scheduled",+ )+ await _persist_and_hydrate_scheduled(manager, controller, continued)+ assert configure_memory_cli_access(controller, continued)+ scope = await _search(controller, project="notes")+ assert controller.memory_scope_for_cli_session("ses_fsm") is None+ from core.caller_context import caller_context_from_platform_payload, caller_resource_user_context++ caller = caller_context_from_platform_payload(continued.platform_specific, message=continued)+ assert caller_resource_user_context(caller)["sub"] == user+ results.append(scope)++ manager._run = creating+ first = await manager.deliver(+ DeliveryRequest(+ session_id="ses_fsm",+ priority="p3",+ content="delegate",+ author_id=f"remote:{user}",+ message_kind="original",+ ),+ context=_context(),+ )+ manager._terminalize_durable_turn(+ first.turn_id,+ "completed",+ settled_by="terminal_result",+ evidence_kind="fixture",+ resume_successors=False,+ )+ assert len(results) == 2 and results[0] != results[1]+ auth.begin_instance_binding_transition(instance_id="replacement-instance", instance_kind="personal")+ for controller in controllers:+ await _search(controller, project="notes", status=403)+ assert controller.memory_search_payload.call_count == 1++ asyncio.run(exercise())++[email protected]("proof_kind", ["other_session", "missing", "tampered", "valid"])+def test_im_session_override_rejected(managers, monkeypatch, tmp_path, proof_kind):+ """MEMORY-SEARCH-025: actual IM owner resists ordinary CLI locator overrides."""+ from core.caller_context import caller_context_from_env, caller_env_for_platform_payload, AVIBE_CALLER_SESSION_PROOF_ENV++ manager, _fresh, engine, _other_engine, _starts = managers+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ from tests.test_session_delivery_fsm import _seed_session+ _seed_session(engine, "attacker_session")+ attacker_proofs = []++ async def attacker_active(_session, context, _text, **_kwargs):+ attacker_proofs.append(caller_env_for_platform_payload(context.platform_specific, message=context)[AVIBE_CALLER_SESSION_PROOF_ENV])++ manager._run = attacker_active+ asyncio.run(manager.deliver(DeliveryRequest(session_id="attacker_session", priority="p3", content="attacker", author_id="local"), context=_context("attacker_session")))+ observed = []++ async def victim_active(_session, context, _text, **_kwargs):+ proof = caller_env_for_platform_payload(context.platform_specific, message=context)[AVIBE_CALLER_SESSION_PROOF_ENV] if proof_kind == "valid" else attacker_proofs[0]+ monkeypatch.setenv(AVIBE_CALLER_SESSION_PROOF_ENV, {"missing": "", "tampered": "伪造"}.get(proof_kind, proof))+ # A different Agent can replace these ordinary CLI environment locators.+ monkeypatch.setenv("AVIBE_SESSION_ID", "ses_fsm")+ monkeypatch.setenv("AVIBE_CALLER_PLATFORM", "slack")+ monkeypatch.setenv("AVIBE_CALLER_USER_ID", "attacker")+ caller = caller_context_from_env()+ definition = await asyncio.to_thread(+ _create_definition, "scheduled", tmp_path / "spoofed.json",+ owner_metadata={"created_by": {"caller": caller.to_metadata()}},+ )+ observed.append(definition.metadata.get("delegated_memory_owner"))++ manager._run = victim_active+ asyncio.run(manager.deliver(+ DeliveryRequest(session_id="ses_fsm", priority="p3", content="victim work",+ platform="slack", scope_id="slack::user::victim",+ author_id="victim", message_kind="original"),+ context=_context(),+ ))+ assert observed == ([{"platform": "slack", "user_id": "victim", "is_dm": True}] if proof_kind == "valid" else [None])+++def test_public_continuation_payloads_hide_owner(managers):+ """Queued Delivery and accepted Message redact both known owner locations."""+ from storage.messages_service import get_message++ manager, _fresh, engine, _other_engine, _starts = managers+ owner = {"platform": "slack", "user_id": "private-user", "is_dm": True}+ private = {"delegated_memory_owner": owner}+ metadata = {+ **private,+ "visible": "retained",+ "scheduled_provenance": {"platform_specific": {"message_metadata": {**private, "visible": "nested"}}},+ }+ observed = []++ async def accept(_session, context, _text, **_kwargs):+ with engine.connect() as conn:+ turn = message_deliveries.active_turn(conn, "ses_fsm")+ delivery = message_deliveries.delivery_for_turn(conn, turn["id"])+ raw = message_deliveries.delivery_payload(delivery)+ public = message_deliveries.public_delivery_payload(delivery)+ assert raw["metadata"]["delegated_memory_owner"] == owner+ observed.append(public["metadata"])+ token = context.platform_specific["turn_token"]+ manager._active_identity = lambda _backend, _session, logical: (logical, f"native-{logical}")+ manager.on_native_start(context, backend="codex", runtime_key=f"runtime-{token}", runtime_turn_id=token)+ with engine.connect() as conn:+ delivery = message_deliveries.delivery_for_turn(conn, turn["id"])+ accepted = get_message(conn, delivery["message_id"])+ raw_message = message_deliveries.message_for_delivery(conn, delivery)+ assert "delegated_memory_owner" in raw_message["metadata_json"]+ observed.append(accepted["metadata"])++ manager._run = accept+ asyncio.run(manager.deliver(+ DeliveryRequest(session_id="ses_fsm", priority="p3", content="continuation", source="harness",+ author="system", metadata=metadata),+ context=_context(),+ ))+ expected = {"visible": "retained", "scheduled_provenance": {+ "platform_specific": {"message_metadata": {"visible": "nested"}},+ }}+ assert observed == [expected, expected]++[email protected]("kind", ["scheduled", "watch"])+def test_public_definition_projection_preserves_sqlite_runtime_owner(managers, monkeypatch, tmp_path, kind):+ """MEMORY-SEARCH-026: display reads and pause/resume preserve raw owners."""+ from storage.background import SQLiteBackgroundTaskStore+ from vibe.cli import _task_payload, _watch_payload++ _manager, _fresh, engine, _other_engine, _starts = managers+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ db_path = engine.url.database+ raw = SQLiteBackgroundTaskStore(db_path=Path(db_path))+ public = SQLiteBackgroundTaskStore(db_path=Path(db_path), include_private_metadata=False)+ definition = _create_definition(kind, tmp_path / f"{kind}.json")+ owner = {"platform": "slack", "user_id": "fixture", "is_dm": True}+ resource = {"sub": "fixture", "is_remote": True}+ definition.metadata.update(delegated_memory_owner=owner, resource_user_context=resource)+ try:+ if kind == "scheduled":+ raw.upsert_scheduled_task(definition.to_dict())+ shown = public.get_scheduled_task(definition.id)+ listed = public.list_scheduled_tasks()+ assert public.set_definition_enabled(definition.id, False, definition_type=kind)+ assert public.set_definition_enabled(definition.id, True, definition_type=kind)+ fallback = _task_payload(definition)+ monkeypatch.setattr("core.scheduled_tasks.SQLiteBackgroundTaskStore", lambda: raw)+ restored = ScheduledTaskStore().get_task(definition.id)+ else:+ raw.upsert_watch(definition.to_dict())+ shown = public.get_watch(definition.id)+ listed = public.list_watches()+ assert public.set_definition_enabled(definition.id, False, definition_type=kind)+ assert public.set_definition_enabled(definition.id, True, definition_type=kind)+ fallback = _watch_payload(definition, runtime_entry=None)+ monkeypatch.setattr("core.watches.SQLiteBackgroundTaskStore", lambda: raw)+ restored = ManagedWatchStore().get_watch(definition.id)+ for item in [shown, *listed, fallback]:+ assert "delegated_memory_owner" not in item["metadata"]+ assert item["metadata"]["resource_user_context"] == resource+ assert restored.metadata["delegated_memory_owner"] == owner+ assert restored.metadata["resource_user_context"] == resource+ finally:+ public.close()+ raw.close()+++def test_owner_bound_proof_rejects_later_owner_and_subject_override(managers, delegated_owner_transport, monkeypatch, tmp_path):+ """MEMORY-SEARCH-029: an old owner cannot harvest a later owner’s scope."""+ from config.v2_config import V2Config+ from core.caller_context import caller_context_from_env, caller_resource_user_context, caller_env_for_platform_payload+ from storage import remote_access_authorization_service as auth+ from storage.resource_access_service import ResourceUserContext, metadata_with_resource_user_context+ import json+ import time+ issued_at = int(time.time())++ manager, _fresh, engine, _other, _starts = managers+ monkeypatch.setattr('storage.db.get_cached_sqlite_engine', lambda: engine)+ monkeypatch.setattr(auth, 'get_cached_sqlite_engine', lambda: engine)+ monkeypatch.setattr('core.internal_server.get_cached_sqlite_engine', lambda: engine)+ config = V2Config.default()+ config.remote_access.vibe_cloud.enabled = True+ config.remote_access.vibe_cloud.instance_id = 'fixture-instance'+ config.remote_access.vibe_cloud.instance_kind = 'personal'+ config.remote_access.vibe_cloud.instance_secret = 'fixture-not-real'+ config.save()+ transition = auth.begin_instance_binding_transition(instance_id='fixture-instance', instance_kind='personal')+ auth.complete_instance_binding_transition(instance_id='fixture-instance', instance_kind='personal', generation=transition['generation'])+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ retained = {}+ outcomes = []++ async def run():+ for user in ('alice', 'alice', 'bob'):+ async def active(_session, ctx, _text, **_kwargs):+ token = ctx.platform_specific['turn_token']+ manager._active_identity = lambda _backend, _session, logical: (logical, f'native-{logical}')+ manager.on_native_start(ctx, backend='codex', runtime_key=f'runtime-{token}', runtime_turn_id=token)+ if user == 'alice':+ # Host creates Alice's normal authenticated execution context.+ alice = ResourceUserContext(subject='alice', instance_role='editor',+ instance_access_source='email', instance_id='fixture-instance',+ instance_kind='personal', is_remote=True, claims_issued_at=issued_at)+ ctx.user_id = 'remote:alice'+ ctx.platform_specific['message_metadata'] = metadata_with_resource_user_context({}, alice)+ issued = caller_env_for_platform_payload(ctx.platform_specific, message=ctx, session_stable_only=True)+ if retained:+ assert issued == retained # Same owner across distinct durable Turns.+ retained.update(issued)+ return+ for mode in ('unchanged', 'ordinary_env_sub_override', 'rightful_owner'):+ env = dict(retained)+ if mode != 'unchanged':+ # Only mutate the ordinary JSON env field. No Bob credential,+ # signed authorization, host DB change, or new HMAC is supplied.+ resource = json.loads(env['AVIBE_CALLER_RESOURCE_CONTEXT'])+ resource['sub'] = 'bob'+ env['AVIBE_CALLER_RESOURCE_CONTEXT'] = json.dumps(resource)+ if mode == 'rightful_owner':+ bob = ResourceUserContext(subject='bob', instance_role='editor',+ instance_access_source='email', instance_id='fixture-instance',+ instance_kind='personal', is_remote=True, claims_issued_at=issued_at)+ ctx.user_id = 'remote:bob'+ ctx.platform_specific['message_metadata'] = metadata_with_resource_user_context({}, bob)+ env = caller_env_for_platform_payload(ctx.platform_specific, message=ctx, session_stable_only=True)+ assert env['AVIBE_CALLER_SESSION_PROOF'] != retained['AVIBE_CALLER_SESSION_PROOF']+ for key, value in env.items():+ monkeypatch.setenv(key, value)+ caller = caller_context_from_env()+ store = ScheduledTaskStore(tmp_path / f'{mode}.json')+ task = await asyncio.to_thread(store.add_task,+ session_key='avibe::channel::ses_fsm', session_id='ses_fsm', prompt='recall',+ schedule_type='at', timezone_name='UTC', run_at='2099-01-01T00:00:00+00:00',+ metadata={'created_by': {'caller': caller.to_metadata()}},+ user_context=caller_resource_user_context(caller))+ controller = _memory_controller()+ scheduled = await ScheduledTaskService(controller=controller, store=store)._build_context(+ parse_session_key('avibe::channel::ses_fsm'), session_id='ses_fsm', execution_id='',+ task_id=task.id, trigger_kind='scheduled', metadata=task.metadata)+ await _persist_and_hydrate_scheduled(manager, controller, scheduled)+ admitted = configure_memory_cli_access(controller, scheduled)+ await _search(controller, status=200 if admitted else 403)+ outcomes.append((mode, task.metadata.get('delegated_memory_owner'), admitted))+ manager._run = active+ result = await manager.deliver(DeliveryRequest(session_id='ses_fsm', priority='p3',+ content='fixture', author_id=f'remote:{user}', message_kind='original'), context=_context())+ manager._terminalize_durable_turn(result.turn_id, 'completed', settled_by='terminal_result',+ evidence_kind='fixture', resume_successors=False)+ asyncio.run(run())+ assert outcomes == [('unchanged', None, False), ('ordinary_env_sub_override', None, False),+ ('rightful_owner', {'platform': 'avibe', 'user_id': 'remote:bob', 'is_dm': False}, True)]+++def test_exact_owner_turn_never_falls_back(memory_owner_turn):+ from core.caller_context import issue_caller_session_proof, verify_caller_session_proof++ old = memory_owner_turn(owner="remote:alice")+ memory_owner_turn(owner="remote:bob", terminal=False)+ alice = issue_caller_session_proof("ses_wb", turn_id=old)+ assert verify_caller_session_proof("ses_wb", alice, {"platform": "avibe", "user_id": "remote:alice"})+ assert not verify_caller_session_proof("ses_wb", alice, {"platform": "avibe", "user_id": "remote:bob"})+ assert issue_caller_session_proof("ses_wb", turn_id="missing") is None+ assert issue_caller_session_proof("other-session", turn_id=old) is None++[email protected]("metadata", [+ {"scheduled_provenance": ["invalid"]},+ {"scheduled_provenance": {"platform_specific": "invalid"}},+ {"scheduled_provenance": {"platform_specific": {"task_trigger_kind": "watch", "message_metadata": [1]}}},+ {"scheduled_provenance": {"platform_specific": {"task_trigger_kind": "watch", "message_metadata": {"delegated_memory_owner": {"user_id": "local"}}}}},+ {"scheduled_provenance": {"platform_specific": {"task_trigger_kind": "watch", "message_metadata": {"delegated_memory_owner": {"platform": "avibe", "user_id": 7}}}}},+])+def test_malformed_persisted_owner_omits_proof(managers, monkeypatch, metadata):+ """MEMORY-SEARCH-030: optional raw identity never aborts ordinary launch."""+ from core.caller_context import caller_env_for_platform_payload++ manager, _fresh, engine, _other, _starts = managers+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ seen = []++ async def run(_session, ctx, _text, **_kwargs):+ env = caller_env_for_platform_payload(ctx.platform_specific, message=ctx)+ assert "AVIBE_CALLER_SESSION_PROOF" not in env+ assert not configure_memory_cli_access(_memory_controller(), ctx)+ seen.append(True)++ manager._run = run+ asyncio.run(manager.deliver(DeliveryRequest(session_id="ses_fsm", priority="p3", content="fixture",+ source="harness", author="harness", metadata=metadata), context=_context()))+ assert seen == [True]++[email protected]("change", ["owner", "absent", "resource", "same"])[email protected]("trigger", ["scheduled", "watch"])+def test_queued_authority_remains_singular(managers, monkeypatch, change, trigger):+ """MEMORY-SEARCH-031: queue batching and acceptance retain each prompt's scope."""+ from copy import deepcopy+ from tests.test_session_delivery_fsm import _activate, _row++ manager, _fresh, engine, _other, _starts = managers+ controller = _memory_controller()+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ active, _ = asyncio.run(_activate(manager))+ authority = {"delegated_memory_owner": {"platform": "avibe", "user_id": "local", "is_dm": False}}+ second = deepcopy(authority)+ if change == "owner":+ second["delegated_memory_owner"]["user_id"] = "remote:bob"+ elif change == "absent":+ second = {}+ elif change == "resource":+ # An invalid/revoked authorization must not inherit the older local grant.+ second["resource_user_context"] = {"sub": "revoked", "vibe_instance_role": "viewer"}+ queued = []+ for text, metadata in (("Alice prompt", authority), ("next prompt", second)):+ queued.append(asyncio.run(manager.deliver(DeliveryRequest(+ session_id="ses_fsm", priority="p3", content=text, source="harness", author="harness",+ author_id="same-definition", metadata={**metadata, "scheduled_provenance": {"platform_specific": {+ "task_trigger_kind": trigger, "task_definition_id": "same-definition", "message_metadata": metadata,+ }}}), context=_context())))+ observed = []++ async def dispatched(_session, ctx, text, **_kwargs):+ token = ctx.platform_specific["turn_token"]+ manager._active_identity = lambda _backend, _session, logical: (logical, f"native-{logical}")+ # Normal native acceptance runs the storage batch-identity assertion.+ manager.on_native_start(ctx, backend="codex", runtime_key=f"runtime-{token}", runtime_turn_id=token)+ admitted = configure_memory_cli_access(controller, ctx)+ scope = await _search(controller, status=200 if admitted else 403)+ observed.append((token, text, scope))++ manager._run = dispatched+ asyncio.run(manager.terminalize_turn(active))+ assert len(observed) == 1+ first_turn, first_text, first_scope = observed[0]+ assert first_scope is not None+ if change == "same":+ assert "Alice prompt" in first_text and "next prompt" in first_text+ assert _row(engine, queued[1].delivery_id)["turn_id"] == first_turn+ else:+ assert first_text == "Alice prompt"+ assert _row(engine, queued[1].delivery_id)["turn_id"] is None+ asyncio.run(manager.terminalize_turn(first_turn))+ if change == "resource":+ assert len(observed) == 1 # Current runtime authorization rejects it before native input.+ assert _row(engine, queued[1].delivery_id)["state"] in {"retired", "cancelled"}+ else:+ assert len(observed) == 2 and observed[1][0] != first_turn+ assert observed[1][1] == "next prompt"+ assert observed[1][2] != first_scope++[email protected]("preexisting", [False, True])+def test_ordinary_ui_injection_never_becomes_scheduled(managers, monkeypatch, tmp_path, preexisting):+ """MEMORY-SEARCH-032: real UI persistence -> durable dispatch rejects reserved authority."""+ import json+ from sqlalchemy import update+ from storage.models import message_deliveries as delivery_table+ from tests.test_ui_session_stream import _make_session+ from tests.ui_server_test_helpers import csrf_headers+ from vibe.ui_server import app++ manager, _fresh, _engine, _other, _starts = managers+ # UI and controller consume the same test-owned database.+ from storage.db import create_sqlite_engine+ from storage.importer import ensure_sqlite_state+ ensure_sqlite_state()+ engine = create_sqlite_engine()+ manager._engine = engine+ manager.controller.config.memory = SimpleNamespace(enabled=True)+ _, session_id = _make_session(tmp_path)+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ monkeypatch.setattr("vibe.ui_server._web_push_user_key", lambda: "local")+ monkeypatch.setattr("vibe.ui_server.is_direct_loopback_memory_request", lambda: False)+ monkeypatch.setattr("vibe.ui_server._load_remote_access_config", lambda: None)+ owner = {"platform": "avibe", "user_id": "local", "is_dm": False}+ injected = {"delegated_memory_owner": owner, "scheduled_provenance": {"platform_specific": {+ "task_trigger_kind": "watch", "delivery_source": "harness", "turn_source": "scheduled",+ "message_metadata": {"delegated_memory_owner": owner},+ }}}+ controller = _memory_controller()+ seen = []++ async def dispatched(_session, ctx, _text, **kwargs):+ token = ctx.platform_specific["turn_token"]+ manager._active_identity = lambda _backend, _session, logical: (logical, f"native-{logical}")+ manager.on_native_start(ctx, backend="codex", runtime_key=f"runtime-{token}", runtime_turn_id=token)+ from core.caller_context import caller_env_for_platform_payload+ assert "AVIBE_CALLER_SESSION_PROOF" not in caller_env_for_platform_payload(ctx.platform_specific, message=ctx)+ assert kwargs["source"] == "human"+ assert ctx.platform_specific["delivery_source"] == "user"+ assert not ctx.platform_specific.get("task_trigger_kind")+ assert "delegated_memory_owner" not in ctx.platform_specific["message_metadata"]+ assert not configure_memory_cli_access(controller, ctx)+ async with httpx.AsyncClient(transport=httpx.ASGITransport(app=create_app(controller)), base_url="http://test") as client:+ response = await client.post("/internal/memory/search", headers={CALLER_SESSION_HEADER: session_id},+ json={"query": "fixture", "policy": {"mode": "keyword"}})+ assert response.status_code == 403+ controller.memory_search_payload.assert_not_called()+ seen.append(True)++ manager._run = dispatched++ async def dispatch(payload):+ with engine.begin() as conn:+ row = message_deliveries.get_delivery(conn, payload["user_message_id"])+ snapshot = json.loads(row["snapshot_json"])+ assert "delegated_memory_owner" not in json.loads(snapshot["metadata_json"])+ assert "scheduled_provenance" not in json.loads(snapshot["metadata_json"])+ if preexisting:+ # Simulate a row written before reserved-field intake sanitation.+ snapshot["metadata_json"] = json.dumps(injected)+ conn.execute(update(delivery_table).where(delivery_table.c.id == row["id"]).values(+ snapshot_json=json.dumps(snapshot),+ snapshot_sha256=hashlib.sha256(json.dumps(snapshot).encode()).hexdigest()))+ result = await manager.deliver(DeliveryRequest(session_id=session_id, priority="p3",+ delivery_id=row["id"], content="LAN fixture"), context=_context(session_id))+ assert result.turn_id+ return {"status_code": 202, "body": {"ok": True, "session_id": session_id, "delivery_state": "accepted"}}++ monkeypatch.setattr("vibe.internal_client.dispatch_async", dispatch)+ client = app.test_client()+ response = client.post(f"/api/sessions/{session_id}/messages",+ json={"text": "LAN fixture", "metadata": injected}, headers=csrf_headers(client))+ assert response.status_code == 201, response.get_json()+ assert response.get_json()["author_id"] is None+ assert seen == [True]+ engine.dispose()+++def test_no_trigger_harness_retains_scheduling_without_memory(managers, monkeypatch):+ """MEMORY-SEARCH-033: execution classification does not grant Memory eligibility."""+ from core.caller_context import caller_env_for_platform_payload++ manager, _fresh, engine, _other, _starts = managers+ controller = _memory_controller()+ controller.session_turns = manager+ monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)+ monkeypatch.setattr("core.internal_server.get_cached_sqlite_engine", lambda: engine)+ create_app(controller)+ manager._build_context = _context+ observed = []++ async def dispatched(_session, ctx, _text, **kwargs):+ assert kwargs["source"] == "scheduled"+ assert ctx.platform_specific["delivery_source"] == "harness"+ assert ctx.platform_specific["message_metadata"]["delegated_memory_owner"]["user_id"] == "local"+ assert "AVIBE_CALLER_SESSION_PROOF" not in caller_env_for_platform_payload(ctx.platform_specific, message=ctx)+ assert not configure_memory_cli_access(controller, ctx)+ await _search(controller, status=403)+ controller.memory_search_payload.assert_not_called()+ observed.append(True)++ manager._run = dispatched+ context = _context()+ context.platform_specific["message_metadata"] = {+ "delegated_memory_owner": {"platform": "avibe", "user_id": "local", "is_dm": False}}+ asyncio.run(controller.session_turn_gate.submit_scheduled("ses_fsm", context, "fixture", delivery_intent="queue"))+ assert observed == [True]diff --git a/tests/test_opencode_restore_polls.py b/tests/test_opencode_restore_polls.pyindex b3aa16618..69a8fbbc0 100644--- a/tests/test_opencode_restore_polls.py+++ b/tests/test_opencode_restore_polls.py@@ -29,6 +29,9 @@ from modules.agents.opencode.agent import OpenCodeAgent # noqa: E402ATTEMPT_ID = "atm_1234567890abcdef1234567890abcdef"NATIVE_PART_ID = "prt_1234567890abcdef1234567890abcdef"+from tests.test_memory_delegated_reads import memory_owner_turn # noqa: F401 -- durable owner fixture+from tests.test_session_delivery_fsm import managers, _fsm_schema_template # noqa: F401 -- fixture dependencies+def _make_poll(*, platform: str, base_session_id: str, opencode_session_id: str) -> ActivePollInfo:return ActivePollInfo(@@ -156,9 +159,29 @@ def _build_agent(active_polls: dict[str, ActivePollInfo], *, language: str = "enreturn agent, status_writes, removed, request_sessions-def test_restore_rebinds_persisted_remote_caller_context(monkeypatch) -> None:+def _enable_memory_restoration(agent, managers):+ from tests.test_memory_delegated_reads import _memory_controller+ from tests.test_session_delivery_fsm import _context++ controller = _memory_controller()+ controller.processing_indicator = agent.controller.processing_indicator+ controller.session_turns = agent.controller.session_turns+ controller.session_turns.controller = controller+ controller.session_turns._engine = managers[2]+ controller.session_turns._build_context = _context+ controller.set_agent_status = agent.controller.set_agent_status+ controller.agent_service = agent.controller.agent_service+ agent.controller = controller++[email protected]("later_owner", [False, True])+def test_restore_rebinds_persisted_remote_caller_context(monkeypatch, memory_owner_turn, managers, later_owner) -> None:poll = _make_poll(platform="avibe", base_session_id="ses_wb", opencode_session_id="oc-1")+ turn_id = memory_owner_turn(terminal=later_owner)+ if later_owner:+ memory_owner_turn(owner="remote:user-2", terminal=False)poll.processing_indicator = {+ "opencode_native_steering": {"target_session_id": "ses_wb", "logical_turn_id": turn_id},"platform": "avibe","user_id": "remote:user-1","opencode_caller_context_env": {@@ -168,6 +191,7 @@ def test_restore_rebinds_persisted_remote_caller_context(monkeypatch) -> None:"AVIBE_CALLER_REMOTE": "1","AVIBE_CALLER_RESOURCE_CONTEXT": '{"sub":"user-1"}',"IGNORED_ENV": "must-not-pass",+ "AVIBE_CALLER_SESSION_PROOF": "stale-process-proof",},"opencode_managed_skill_project_base": "/tmp","opencode_managed_skill_builtin_snapshot": {@@ -176,6 +200,7 @@ def test_restore_rebinds_persisted_remote_caller_context(monkeypatch) -> None:},}agent, _, _, _ = _build_agent({"oc-1": poll})+ _enable_memory_restoration(agent, managers)binding_path = "/old-avibe-home/runtime/opencode_caller_context.json"agent._test_server.caller_context_binding_path = lambda: binding_pathbound: list[dict] = []@@ -209,6 +234,13 @@ def test_restore_rebinds_persisted_remote_caller_context(monkeypatch) -> None:"/old-avibe-home/builtin-skills/" + "d" * 64)assert "IGNORED_ENV" not in bound[0]["extra_env"]+ from core.caller_context import verify_caller_session_proof++ if later_owner:+ assert "AVIBE_CALLER_SESSION_PROOF" not in bound[0]["extra_env"]+ return+ assert verify_caller_session_proof("ses_wb", bound[0]["extra_env"]["AVIBE_CALLER_SESSION_PROOF"], {"platform": "avibe", "user_id": "remote:user-1"})+ assert not verify_caller_session_proof("ses_wb", bound[0]["extra_env"]["AVIBE_CALLER_SESSION_PROOF"], {"platform": "avibe", "user_id": "remote:user-2"})assert unbound == [("oc-1", bound[0]["binding_token"], binding_path)]@@ -237,14 +269,25 @@ def test_restore_binding_failure_does_not_strand_durable_poll(monkeypatch) -> Noassert removed == ["oc-1"]-def test_restore_retries_binding_for_the_active_poll_lifetime(monkeypatch) -> None:+def test_restore_retries_binding_for_the_active_poll_lifetime(monkeypatch, memory_owner_turn, managers) -> None:poll = _make_poll(platform="avibe", base_session_id="ses_wb", opencode_session_id="oc-1")+ turn_id = memory_owner_turn(terminal=False)+ poll.processing_indicator = {+ "opencode_native_steering": {"target_session_id": "ses_wb", "logical_turn_id": turn_id},+ "opencode_caller_context_env": {"AVIBE_SESSION_ID": "ses_wb"},+ }agent, _, _, _ = _build_agent({"oc-1": poll})+ _enable_memory_restoration(agent, managers)attempts = 0unbound: list[str] = []def bind(*_args, **_kwargs):nonlocal attempts+ from core.caller_context import verify_caller_session_proof++ assert verify_caller_session_proof("ses_wb", _kwargs["extra_env"]["AVIBE_CALLER_SESSION_PROOF"], {"platform": "avibe", "user_id": "remote:user-1"})+ assert "AVIBE_CALLER_SESSION_PROOF" not in poll.processing_indicator["opencode_caller_context_env"]+attempts += 1if attempts < 4:raise OSError("temporary binding failure")diff --git a/tests/test_reply_enhancer_platform.py b/tests/test_reply_enhancer_platform.pyindex 111ffcc93..3464f6b6d 100644--- a/tests/test_reply_enhancer_platform.py+++ b/tests/test_reply_enhancer_platform.py@@ -516,6 +516,7 @@ class ReplyEnhancerPlatformTests(unittest.IsolatedAsyncioTestCase):_memory_admission=lambda: admission,)controller.configure_memory_cli_session = Controller.configure_memory_cli_session.__get__(controller)+ controller.memory_read_scope_for_cli_session = Controller.memory_read_scope_for_cli_session.__get__(controller)controller.memory_scope_for_cli_session = Controller.memory_scope_for_cli_session.__get__(controller)controller.memory_principal_for_cli_session = Controller.memory_principal_for_cli_session.__get__(controller)controller.memory_project_for_cli_session = Controller.memory_project_for_cli_session.__get__(controller)diff --git a/tests/test_session_delivery_fsm.py b/tests/test_session_delivery_fsm.pyindex 589bdd897..6f030b66c 100644--- a/tests/test_session_delivery_fsm.py+++ b/tests/test_session_delivery_fsm.py@@ -1009,6 +1009,7 @@ def test_every_released_memory_admission_fact_fences_delivery_segments(def test_scheduled_segment_key_keeps_source_sessions_separate() -> None:def row(source_session_id: str) -> dict:return {+ "source": "harness","metadata": {SCHEDULED_PROVENANCE_KEY: {"platform_specific": {@@ -2479,6 +2480,7 @@ def test_durable_workbench_turn_restores_memory_admission_facts(prompt_controller.configure_memory_cli_session = (Controller.configure_memory_cli_session.__get__(prompt_controller))+ prompt_controller.memory_read_scope_for_cli_session = Controller.memory_read_scope_for_cli_session.__get__(prompt_controller)prompt_controller.memory_scope_for_cli_session = (Controller.memory_scope_for_cli_session.__get__(prompt_controller))@@ -2684,6 +2686,7 @@ def test_dispatch_uses_current_session_route_without_mutating_delivery_provenancsession_id="ses_fsm",priority="p3",content="scheduled",+ source="harness",metadata={SCHEDULED_PROVENANCE_KEY: {"message_id": "scheduled:old",diff --git a/vibe/cli.py b/vibe/cli.pyindex 479f49358..c0ac94a1e 100644--- a/vibe/cli.py+++ b/vibe/cli.py@@ -2569,6 +2569,9 @@ def _task_payload(task, *, brief: bool = False):"enabled": task.enabled,}payload = task.to_dict()+ from storage.message_deliveries import metadata_without_delegated_owner++ payload["metadata"] = metadata_without_delegated_owner(payload.get("metadata"))payload.update(derived)return payload@@ -2695,7 +2698,7 @@ def _task_store() -> ScheduledTaskStore:def _definition_read_store():"""Own the canonical read projection store used by CLI read commands."""- store = SQLiteBackgroundTaskStore()+ store = SQLiteBackgroundTaskStore(include_private_metadata=False)try:yield storefinally:@@ -3655,6 +3658,9 @@ def _watch_payload(watch, runtime_entry: Optional[dict[str, object]], *, brief:"last_error": watch.last_error,}payload = watch.to_dict()+ from storage.message_deliveries import metadata_without_delegated_owner++ payload["metadata"] = metadata_without_delegated_owner(payload.get("metadata"))payload.update(derived)return payload@@ -3758,6 +3764,8 @@ def _agent_payload(agent, *, brief: bool = False) -> dict:def _run_payload(run: dict, *, brief: bool = False) -> dict:+ from storage.message_deliveries import metadata_without_delegated_owner+normalized = dict(run)normalized["status"] = normalize_run_status(normalized.get("status"))activity_at = normalized.get("last_activity_at") or normalized.get("started_at")@@ -3785,6 +3793,7 @@ def _run_payload(run: dict, *, brief: bool = False) -> dict:"callback_status": normalized.get("callback_status"),"callback_run_id": normalized.get("callback_run_id"),}+ normalized["metadata"] = metadata_without_delegated_owner(normalized.get("metadata"))return normalizeddiff --git a/vibe/internal_client.py b/vibe/internal_client.pyindex b14423203..e4ad39d5e 100644--- a/vibe/internal_client.py+++ b/vibe/internal_client.py@@ -1298,3 +1298,13 @@ def health_sync(return resp.status_code == 200 and (resp.json() or {}).get("ok") is Trueexcept Exception:return False+++def delegated_memory_owner_sync(session_id: str, proof: str) -> dict[str, Any] | None:+ """Resolve a delegated owner using an ephemeral host execution proof."""+ result = _memory_request_sync(+ "POST", "/internal/memory/delegated-owner",+ payload={"session_id": session_id, "proof": proof}, timeout=5.0,+ )+ owner = result["body"].get("owner") if result["status_code"] == 200 else None+ return owner if isinstance(owner, dict) else Nonediff --git a/vibe/ui_server.py b/vibe/ui_server.pyindex 3ff1914e3..c6d86f8af 100644--- a/vibe/ui_server.py+++ b/vibe/ui_server.py@@ -12260,7 +12260,7 @@ def _harness_store():# context manager makes ownership explicit at every call site.from storage.background import SQLiteBackgroundTaskStore- store = SQLiteBackgroundTaskStore()+ store = SQLiteBackgroundTaskStore(include_private_metadata=False)try:yield storefinally: