diff --git a/.github/instructions/cosmos-response-boundaries.instructions.md b/.github/instructions/cosmos-response-boundaries.instructions.md new file mode 100644 index 000000000..4e255ba76 --- /dev/null +++ b/.github/instructions/cosmos-response-boundaries.instructions.md @@ -0,0 +1,80 @@ +--- +applyTo: '**/*.py' +--- + +# Cosmos document response boundaries + +Point reads and returned create/replace/upsert/patch documents in the application's +pinned Cosmos SDK are `CosmosDict`, a mapping subclass. Query rows and nested JSON +objects are plain dictionaries. `deepcopy(CosmosDict)` preserves its subclass. + +Storage owners must normalize a point response **before copying or passing it to +an exact-dictionary/strict JSON contract**, using the bootstrap-free +`normalize_cosmos_document` in `cosmos_document_utils.py`. This helper accepts +`Mapping`, returns a plain top-level dictionary, preserves all fields and `_etag`, +and rejects invalid types with `TypeError`. Translate invalid responses through +the owner's existing failure path. Never normalize arbitrary iterables into a +document, substitute `{}`, strip ETags, or recursively repair domain values. + +Keep domain validators strict. Normalization is not authorization, sanitization, +metadata stripping, or permission to replay an uncertain external effect. Raw SDK +responses are compatible with mapping consumers; an exposed wrapper by itself is +not a product defect. Prove a strict downstream mismatch with a runtime regression +before changing otherwise-compatible production code. + +New Cosmos test containers use the **installed application's SDK `CosmosDict`** +for point reads and returned write documents by default. Query rows stay plain. +Plain point responses require an explicit compatibility mode. Preserve ETags, +partition routing, conditional updates, failure injection and transaction atomicity. +Domain-level repository mocks do not need to impersonate Cosmos. + +## Reviewed inventory and deterministic CI + +`functional_tests/cosmos_response_boundaries.json` records point/query calls, +helper references, consumer classifications and evidence by storage function. +It separately inventories Cosmos-shaped inline/shared test containers. It is a +review/change guard, not an interprocedural type checker or proof that every +external service behaves correctly. + +After adding/changing a storage boundary or double: + +1. Run `python scripts/check_cosmos_response_boundaries.py --refresh`. Changed + implementations become `review-required`; regeneration never approves them. +2. Review every changed entry's actual consumer. Classify it as + `normalized-strict`, `sdk-compatible`, `response-unused`, or `not-cosmos` + with a specific contract and runtime test reference. A `not-cosmos` entry + needs a concrete explanation of the similarly named non-Cosmos API. +3. New/changed Cosmos doubles must use `sdk-default`; `legacy-inline` records + document unchanged pre-migration doubles, not permission to introduce another. + Add a real SDK runtime regression to the inventory's `tests` evidence for + changed owners. The gate automatically executes owner-runtime and SDK-default + evidence, in addition to its core contracts, so references are not merely + checked for existence. +4. Run `python scripts/check_cosmos_response_boundaries.py --run-contracts`. + This checks the inventory and runs its selected suites with + `-p test_support.cosmos_network_guard`. Set `PYTHONPATH` to the application + and functional test directories using the platform's path separator. + +Do not copy a classification blindly, point every owner at a utility-only test, +or treat a grep match/count as evidence of a defect. Reviews and references are +invalidated when their implementations disappear or change. Legacy inline +doubles remain explicitly recorded for staged, owner-specific migration. +Unchanged legacy mapping consumers distinguish source review plus SDK API +evidence from owner-runtime SDK coverage. Their source fingerprints form a +closed baseline; a new or changed owner cannot borrow that limited assurance. +Replace its baseline entry with real owner-runtime evidence, rather than +expanding the source-only baseline. +Owner-runtime evidence executes representative real-owner behavior; it does not +claim exhaustive branch coverage for every function in that storage owner. +Existing test-local compatibility seams also have a closed fingerprint baseline. +A new or changed point override needs explicit `fault-injection` runtime evidence, +which the gate executes; it cannot silently retain an old easy response override. + +The dedicated `cosmos-response-contract-check.yml` installs the existing pinned +application/test requirements, uses no cloud credentials, and blocks socket/DNS +network access before test collection. New application storage modules and test +doubles cannot bypass it by choosing a new filename. +Tokenizer data needed by the pinned application dependency is warmed during +dependency setup into a workspace-local cache, before network access is blocked. +Tests keep the real context-budget calculation; they do not download assets or +replace budget/token behavior merely to run offline. diff --git a/.github/workflows/cosmos-response-contract-check.yml b/.github/workflows/cosmos-response-contract-check.yml new file mode 100644 index 000000000..105c705c9 --- /dev/null +++ b/.github/workflows/cosmos-response-contract-check.yml @@ -0,0 +1,44 @@ +name: Cosmos Response Contracts + +on: + pull_request: + paths: + - 'application/**/*.py' + - 'scripts/**/*.py' + - 'deployers/**/*.py' + - 'functional_tests/**/*.py' + - 'functional_tests/cosmos_response_boundaries.json' + - 'ui_tests/**/*.py' + - '**/requirements*.txt' + - '.github/instructions/cosmos-response-boundaries.instructions.md' + - '.github/workflows/cosmos-response-contract-check.yml' + workflow_dispatch: + +permissions: + contents: read + +jobs: + cosmos-contracts: + runs-on: ubuntu-latest + timeout-minutes: 20 + env: + PYTHONPATH: application/single_app:functional_tests + PYTHONDONTWRITEBYTECODE: '1' + TIKTOKEN_CACHE_DIR: ${{ github.workspace }}/.cosmos-contract-assets/tiktoken + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + with: + python-version: '3.12' + cache: pip + cache-dependency-path: | + application/single_app/requirements.txt + requirements-dev.txt + - name: Install pinned application and test dependencies + run: python -m pip install -r application/single_app/requirements.txt -r requirements-dev.txt + - name: Prepare pinned tokenizer dependency assets before network blocking + run: python -c "import tiktoken; tiktoken.get_encoding('cl100k_base'); tiktoken.get_encoding('o200k_base')" + - name: Require reviewed storage owners and doubles + run: python scripts/check_cosmos_response_boundaries.py + - name: Run contracts with external network blocked before collection + run: python scripts/check_cosmos_response_boundaries.py --run-contracts diff --git a/application/single_app/config.py b/application/single_app/config.py index f6b9d2372..0cd03a65b 100644 --- a/application/single_app/config.py +++ b/application/single_app/config.py @@ -101,7 +101,7 @@ EXECUTOR_TYPE = 'thread' EXECUTOR_MAX_WORKERS = 30 SESSION_TYPE = 'filesystem' -VERSION = "0.261.323" +VERSION = "0.261.324" IS_DEVELOPMENT = is_development_env_enabled() # Opt-out for deployments where App Service Easy Auth is active but the platform diff --git a/application/single_app/cosmos_document_utils.py b/application/single_app/cosmos_document_utils.py new file mode 100644 index 000000000..bed59b68b --- /dev/null +++ b/application/single_app/cosmos_document_utils.py @@ -0,0 +1,15 @@ +# cosmos_document_utils.py +"""Bootstrap-free normalization of Cosmos point document responses.""" + +from collections.abc import Mapping + + +def normalize_cosmos_document(value): + """Return a plain top-level document, preserving fields and conditional ETags. + + Nested values belong to the domain contract and are deliberately unchanged. + This is not a JSON validator, authorization check, or metadata sanitizer. + """ + if not isinstance(value, Mapping): + raise TypeError("A Cosmos document response must be a mapping.") + return dict(value) diff --git a/application/single_app/functions_orchestration_actions.py b/application/single_app/functions_orchestration_actions.py index 9cdf90170..9fd825c78 100644 --- a/application/single_app/functions_orchestration_actions.py +++ b/application/single_app/functions_orchestration_actions.py @@ -681,7 +681,13 @@ async def guard_function(invocation, next): level=logging.ERROR, extra={'action_ref': action_ref, 'error_type': type(exc).__name__}, ) - failure = ActionExecutionError('An action function could not complete.') + journal = current_operation_journal() + failure = ( + journal.failure if journal is not None and journal.failure is not None + else ActionExecutionError('An action function could not complete.') + ) + if failure is exc: + raise raise failure from exc refusal = result_refusal(invocation.result.value) if m365_step and invocation.result is not None else None if refusal is not None: diff --git a/application/single_app/functions_orchestration_adapters.py b/application/single_app/functions_orchestration_adapters.py index 2296c735d..024f51554 100644 --- a/application/single_app/functions_orchestration_adapters.py +++ b/application/single_app/functions_orchestration_adapters.py @@ -479,6 +479,19 @@ def _m365_step_identity(step, context): return f'{root}\x00{step_id}', origin +def _m365_card_callback(step, context, emit): + def publish(reference): + if not callable(emit): + return + # The producer logs a failed callback while retaining the saved reference. + emit({ + 'type': 'm365_pending_action_reference', 'reference': reference, + 'step_id': step.get('step_id'), 'run_id': _ctx(context, 'run_id', None), + 'user_message_id': _ctx(context, 'user_message_id', None), + }) + return publish + + def _progress(step, capability_id, label, status='running'): step = step or {} return { @@ -1936,10 +1949,13 @@ def run_action_invoke(step, context, *, settings, user_id, emit, cancel_requeste from functions_orchestration_actions import invoke_action from semantic_kernel_plugins.plugin_invocation_logger import sanitize_plugin_invocation_value from functions_m365_citations import m365_display_time_zone + from functions_orchestration_m365 import orchestration_action_card_events # Microsoft 365 email and event times are shown in the turn's browser time zone. - with m365_display_time_zone(_ctx(context, 'time_zone')), operation_step_scope( - step, context, user_id, named_inputs, + with ( + orchestration_action_card_events(_m365_card_callback(step, context, emit)), + m365_display_time_zone(_ctx(context, 'time_zone')), + operation_step_scope(step, context, user_id, named_inputs), ): result = asyncio.run(invoke_action( action_ref, task, context, settings=settings, user_id=user_id, @@ -2103,7 +2119,9 @@ def run_agent_invoke(step, context, *, settings, user_id, emit, cancel_requested invocation_settings = deepcopy(settings) access('agent', settings=invocation_settings, selector=selector) from agent_delegation_runtime import delegation_citations, invoke_scoped_agent - from functions_orchestration_m365 import agent_loads_actions, agent_step_scope + from functions_orchestration_m365 import ( + agent_loads_actions, agent_step_scope, orchestration_action_card_events, + ) from semantic_kernel_plugins.plugin_invocation_logger import get_plugin_logger budget = _ctx(context, 'delegation_budget', None) @@ -2128,9 +2146,11 @@ def scope(_target): ) from functions_m365_citations import m365_display_time_zone - with m365_display_time_zone(_ctx(context, 'time_zone')), operation_step_scope( - step, context, user_id, named_inputs, - ) as journal: + with ( + orchestration_action_card_events(_m365_card_callback(step, context, emit)), + m365_display_time_zone(_ctx(context, 'time_zone')), + operation_step_scope(step, context, user_id, named_inputs) as journal, + ): async def invoke(): return await invoke_scoped_agent( agent_cfg, task, identity=execution_identity, budget=budget, diff --git a/application/single_app/functions_orchestration_bootstrap.py b/application/single_app/functions_orchestration_bootstrap.py index 9aa54abb4..00a334ce9 100644 --- a/application/single_app/functions_orchestration_bootstrap.py +++ b/application/single_app/functions_orchestration_bootstrap.py @@ -56,11 +56,12 @@ upload_generated_file_artifact_stream_for_user, ) from functions_workflow_result_store import WorkflowResultStore, _quota_bytes +from cosmos_document_utils import normalize_cosmos_document def _document_response(value): """Remove an SDK mapping wrapper; leave invalid types for the owning contract to reject.""" - return dict(value) if isinstance(value, dict) else value + return normalize_cosmos_document(value) if isinstance(value, dict) else value def read_owned_conversation(user_id, conversation_id, *, request_timeout=None): @@ -75,7 +76,7 @@ def read_owned_conversation(user_id, conversation_id, *, request_timeout=None): or conversation.get("orchestration_deleted") or conversation.get("deleted") ): raise OutputUnavailableError("output_conversation_unavailable") - return dict(conversation) + return normalize_cosmos_document(conversation) def private_external_configuration_digest(value): diff --git a/application/single_app/functions_orchestration_execution.py b/application/single_app/functions_orchestration_execution.py index ecae19a1e..9f557d67d 100644 --- a/application/single_app/functions_orchestration_execution.py +++ b/application/single_app/functions_orchestration_execution.py @@ -1101,6 +1101,9 @@ def _send(self, frame): _log_failure("Execution progress delivery stopped.", self.record, exc) def _progress(self, event): + if type(event) is dict and event.get("type") == "m365_pending_action_reference": + self._pending_action_created(event) + return if type(event) is not dict or event.get("type") != "step": return extra = { @@ -1118,6 +1121,72 @@ def _progress(self, event): event.get("step_index"), event.get("capability_id"), **extra, )) + def _pending_action_created(self, event): + # The producer runs inside a separate request. Only its exact step-owned + # reference crosses the bridge; tool/model snapshots are never published. + from functions_orchestration_m365 import step_request_id + + reference = event.get("reference") + step_id = event.get("step_id") + root = self.record.get("attempt_root_run_id") or self.record["id"] + if ( + type(reference) is not dict + or event.get("run_id") != self.record["id"] + or reference.get("user_id") != self.record["user_id"] + or reference.get("conversation_id") != self.record["conversation_id"] + or not any( + step.get("step_id") == step_id for step in self.record["plan"]["steps"] + ) + or reference.get("request_id") != step_request_id(f"{root}\x00{step_id}") + or not isinstance(reference.get("id"), str) or not reference["id"] + ): + return + with self.lease.lock: + current = self.lease.read() + action_ids = list(dict.fromkeys([ + *(current.get("m365_pending_action_ids") or []), reference["id"], + ])) + self.lease.update({"m365_pending_action_ids": action_ids}) + try: + from functions_msgraph_pending_actions import get_chat_pending_action_cards + + cards = get_chat_pending_action_cards( + self.record["user_id"], self.record["conversation_id"], + request_id=reference["request_id"], action_ids=[reference["id"]], + ) + for card in cards: + self._send(serialize_sse({ + "type": "m365_pending_action", "pending_action": card, + "conversation_id": self.record["conversation_id"], + "run_id": self.record["id"], "step_id": step_id, + "user_message_id": self.record.get("user_message_id"), + "request_id": reference["request_id"], + })) + except Exception as error: + _log_failure("A saved outgoing action could not be displayed live.", self.record, error) + + def _pending_action_payload(self): + try: + record = self._final_record or self.lease.read() + action_ids = record.get("m365_pending_action_ids") or [] + if not action_ids: + return {} + from functions_msgraph_pending_actions import get_chat_pending_action_cards + + cards = [] + for offset in range(0, len(action_ids), 100): + cards.extend(get_chat_pending_action_cards( + self.record["user_id"], self.record["conversation_id"], + action_ids=action_ids[offset:offset + 100], + )) + return {"m365_pending_actions": cards} + except Exception as error: + _log_failure("Saved outgoing actions could not be refreshed.", self.record, error) + return {"m365_pending_actions_error": { + "error": "m365_pending_actions_unavailable", + "message": "Outgoing actions could not be refreshed. Reload them; do not repeat the request.", + }} + def _persist(self, record_type, payload): if record_type == "run": try: @@ -1571,6 +1640,8 @@ def _finalize(self, result, error, *, refreshes=0): if workflow_result_reads and workflow_result_contexts else {} ), } + if current.get("m365_pending_action_ids"): + metadata["m365_pending_action_ids"] = list(current["m365_pending_action_ids"]) thread = self._regeneration_thread() if thread: metadata["thread_info"] = thread @@ -1659,6 +1730,7 @@ def _finalize(self, result, error, *, refreshes=0): payload.update({ "metadata": document.get("metadata") or {}, "role": document["role"], "replace_content": True, "blocked": blocked, + **self._pending_action_payload(), }) return [build_content_event(answer), serialize_sse(strip_private_chat_checks(payload))] @@ -1690,6 +1762,9 @@ def _finish(self, result, error): finalization_status="failed", outputs=[], ), ] + terminal = json.loads(self._frames[-1].partition("data:")[2].strip()) + terminal.update(self._pending_action_payload()) + self._frames[-1] = serialize_sse(terminal) if self.record.get("requires_fresh_review"): status = (self._final_record or {}).get("status") or "failed" state = {"completed": "completed", "failed": "failed", "cancelled": "interrupted"}.get(status) diff --git a/application/single_app/functions_orchestration_m365.py b/application/single_app/functions_orchestration_m365.py index a601509cc..03e9e409e 100644 --- a/application/single_app/functions_orchestration_m365.py +++ b/application/single_app/functions_orchestration_m365.py @@ -26,8 +26,10 @@ import logging import uuid from contextlib import contextmanager +from contextvars import ContextVar from functions_appinsights import log_event +from functions_m365_action_cards import m365_action_card_events from functions_m365_approvals import M365ApprovalRequired, M365PolicyError from functions_m365_operations import M365_ACTION_DEFINITIONS, M365_FILE_SOURCES, M365_PLUGIN_TYPES, M365_SOURCES from functions_msgraph_operations import MSGRAPH_PLUGIN_TYPE @@ -35,6 +37,7 @@ M365_STEP_ACTION_TYPES = frozenset({*M365_PLUGIN_TYPES, MSGRAPH_PLUGIN_TYPE}) +_card_callback = ContextVar('orchestration_m365_card_callback', default=None) _FILE_ACTION_SOURCES = { action_type: definition['source'] for action_type, definition in M365_ACTION_DEFINITIONS.items() if definition['source'] in M365_FILE_SOURCES @@ -219,6 +222,18 @@ def _log_stop(error, capability_id): ) +@contextmanager +def orchestration_action_card_events(callback): + """Carry the owning run's producer callback into a step's request bridge.""" + if not callable(callback): + raise TypeError('An orchestration action-card callback is required.') + token = _card_callback.set(callback) + try: + yield + finally: + _card_callback.reset(token) + + @contextmanager def _step_scope(*, user_id, conversation_id, request_key, selection, origin): # The runtime owns Cosmos, the tenant and conversation access, so it loads only for a @@ -230,7 +245,12 @@ def _step_scope(*, user_id, conversation_id, request_key, selection, origin): user_id=user_id, conversation_id=conversation_id, request_id=step_request_id(request_key), selection=selection, origin=origin, ) as context: - yield context + callback = _card_callback.get() + if callable(callback): + with m365_action_card_events(callback): + yield context + else: + yield context except OrchestrationM365Error as error: _log_stop(error, origin.get('capability_id')) raise diff --git a/application/single_app/functions_orchestration_operations.py b/application/single_app/functions_orchestration_operations.py index 8be90112e..6f1ec6368 100644 --- a/application/single_app/functions_orchestration_operations.py +++ b/application/single_app/functions_orchestration_operations.py @@ -16,6 +16,7 @@ from hashlib import sha256 from threading import RLock +from cosmos_document_utils import normalize_cosmos_document from functions_orchestration_result_contracts import ResultContractError, canonical_bytes @@ -116,9 +117,9 @@ def _caller_identity(): def operation_summary(receipts, fallback): outcomes = [] labels = { - 'sent': 'Microsoft 365 accepted the send.', - 'pending_review': 'Draft prepared; awaiting review.', - 'pending': 'Draft prepared; awaiting review.', + 'sent': 'Accepted for sending; recipient delivery is not confirmed.', + 'pending_review': 'Ready to review — not sent.', + 'pending': 'Ready to review — not sent.', 'scheduled_pending': 'Delivery scheduled; not yet sent.', 'scheduled': 'Delivery scheduled; not yet sent.', } @@ -230,7 +231,9 @@ def _change(self, mutate): self.authorize() for _ in range(8): try: - stored = self.container.read_item(self.id, partition_key=self.run_id) + stored = normalize_cosmos_document( + self.container.read_item(self.id, partition_key=self.run_id), + ) except CosmosResourceNotFoundError: stored = None if stored is not None and any(stored.get(key) != value for key, value in { @@ -285,17 +288,17 @@ def claim(body): with self.lock: try: cached = self._change(claim) - except Exception: + except Exception as error: self.failure = OperationRecoveryError() - raise + raise self.failure from error return key, cached def finish(self, key, result, *, refused=False): try: safe = self.sanitize(result) - except Exception: + except Exception as error: self.failure = OperationRecoveryError() - raise + raise self.failure from error def complete(body): prior = body['calls'].get(key) @@ -307,9 +310,9 @@ def complete(body): with self.lock: try: name = self._change(complete) - except Exception: + except Exception as error: self.failure = OperationRecoveryError() - raise + raise self.failure from error self.receipts.append({'function_name': name, 'result': deepcopy(safe)}) def call_m365(self, plugin, name, parameters, invoke): diff --git a/application/single_app/functions_orchestration_output_store.py b/application/single_app/functions_orchestration_output_store.py index f80213615..7de5d5f02 100644 --- a/application/single_app/functions_orchestration_output_store.py +++ b/application/single_app/functions_orchestration_output_store.py @@ -17,6 +17,7 @@ from azure.core.exceptions import AzureError from azure.cosmos import exceptions +from cosmos_document_utils import normalize_cosmos_document from functions_orchestration_result_contracts import ( ProducerIdentity, ResultRef, @@ -497,7 +498,7 @@ def _point(self, item_id): raise OutputStorageError() from exc if not isinstance(record, dict): raise OutputError("output_record_invalid") - return dict(record) + return normalize_cosmos_document(record) def _validate(self, record): if ( diff --git a/application/single_app/functions_orchestration_plan_revisions.py b/application/single_app/functions_orchestration_plan_revisions.py index 58372e024..ce4a50fee 100644 --- a/application/single_app/functions_orchestration_plan_revisions.py +++ b/application/single_app/functions_orchestration_plan_revisions.py @@ -22,6 +22,7 @@ from azure.core.exceptions import AzureError from azure.cosmos import exceptions +from cosmos_document_utils import normalize_cosmos_document import functions_orchestration_runs as run_store from functions_appinsights import log_event from functions_assist_references import ( @@ -293,7 +294,7 @@ def read_revision_run(run_id, user_id, conversation_id, *, follow_current=False, if not allow_legacy and is_legacy_plan(record.get('plan')): raise legacy_plan_error() # CosmosDict carries SDK metadata outside the JSON document. Keep the ETag. - return dict(record) + return normalize_cosmos_document(record) target = record['superseded_by_run_id'] if not _valid_id(target): raise _not_found() diff --git a/application/single_app/functions_orchestration_recovery.py b/application/single_app/functions_orchestration_recovery.py index 42175d33a..1d86d23c7 100644 --- a/application/single_app/functions_orchestration_recovery.py +++ b/application/single_app/functions_orchestration_recovery.py @@ -34,6 +34,7 @@ from azure.core.exceptions import HttpResponseError, ResourceNotFoundError, ServiceRequestError, ServiceResponseError from azure.cosmos import exceptions +from cosmos_document_utils import normalize_cosmos_document from content_screening.contracts import ScreeningError import functions_orchestration_runs as run_store from functions_appinsights import log_event, workflow_log_context @@ -298,7 +299,7 @@ def _replace(record, updates): ) if not isinstance(saved, dict): raise CheckpointError('checkpoint_invalid') - return dict(saved) + return normalize_cosmos_document(saved) def checkpoint_store(record, authorize, *, token=None, claim_id=None): diff --git a/application/v2_ui/src/components/approvals/PendingActionCard.tsx b/application/v2_ui/src/components/approvals/PendingActionCard.tsx index 7f29aa510..bd3d05396 100644 --- a/application/v2_ui/src/components/approvals/PendingActionCard.tsx +++ b/application/v2_ui/src/components/approvals/PendingActionCard.tsx @@ -63,6 +63,9 @@ export function PendingActionCard({ id, variant = 'detail' }: { id: string; vari const fullReview = pendingActionNeedsFullReview(action); const route = pendingActionSendRoute(action); const actionable = isActionableStatus(action.status); + const emailStatusLabel = action.graph_resource_type === 'mail' || action.operation === 'send_mail' + ? action.status === 'sent' ? 'Accepted for sending' : action.status === 'pending' ? 'Ready to review' : undefined + : undefined; const canChange = canChangeEntry(entry); const webLink = safeWebLinkUrl(action.web_link); const approvalId = (() => { @@ -242,7 +245,7 @@ export function PendingActionCard({ id, variant = 'detail' }: { id: string; vari } + badge={} > {content} @@ -262,7 +265,7 @@ export function PendingActionCard({ id, variant = 'detail' }: { id: string; vari

{actionSubject(action)}

{pendingActionHeading(action)}

- + {content} diff --git a/application/v2_ui/src/components/chat/PendingActionSlots.tsx b/application/v2_ui/src/components/chat/PendingActionSlots.tsx index 23cd2a013..5b01d248c 100644 --- a/application/v2_ui/src/components/chat/PendingActionSlots.tsx +++ b/application/v2_ui/src/components/chat/PendingActionSlots.tsx @@ -79,6 +79,7 @@ export function PendingActionPlacementProvider({ lastMessageByRequestId: lastMessageByRequestId(anchorable), streamingUserMessageId: liveStream && liveStream.conversationId === conversationId ? liveStream.userMessageId : '', + streamingAtUserTurn: liveStream?.placement === 'turn', }; const byAnchor = new Map(); for (const entry of Object.values(entries).sort((a, b) => a.order - b.order)) { diff --git a/application/v2_ui/src/lib/approvalsApi.ts b/application/v2_ui/src/lib/approvalsApi.ts index 6946e34fd..655496341 100644 --- a/application/v2_ui/src/lib/approvalsApi.ts +++ b/application/v2_ui/src/lib/approvalsApi.ts @@ -551,7 +551,9 @@ export function pendingActionHeading(action: PendingAction): string { export function pendingActionStatusText(action: PendingAction): string { const labels: Record = { - pending: 'Pending — not sent.', + pending: action.graph_resource_type === 'mail' || action.operation === 'send_mail' + ? 'Ready to review — not sent.' + : 'Pending — not sent.', scheduled: 'Scheduled — not yet sent.', review_required: 'Review required — not sent.', sending: 'Sending — the Microsoft 365 request is in progress. Do not submit it again.', diff --git a/application/v2_ui/src/lib/m365PendingActions.ts b/application/v2_ui/src/lib/m365PendingActions.ts index 3720b6baf..936f16e8f 100644 --- a/application/v2_ui/src/lib/m365PendingActions.ts +++ b/application/v2_ui/src/lib/m365PendingActions.ts @@ -298,6 +298,7 @@ export interface AnchorContext { lastMessageByRequestId: ReadonlyMap; /** The user message whose reply is still streaming, or '' when nothing is streaming. */ streamingUserMessageId: string; + streamingAtUserTurn?: boolean; } /** @@ -313,6 +314,7 @@ export function resolveAnchor( if (visible(reference.messageId)) return reference.messageId; const streaming = context.streamingUserMessageId; if (streaming && (reference.userMessageId === streaming || reference.fallbackMessageId === streaming)) { + if (context.streamingAtUserTurn && visible(streaming)) return streaming; return STREAMING_ANCHOR; } if (visible(reference.userMessageId)) return reference.userMessageId; diff --git a/application/v2_ui/src/lib/orchestration.ts b/application/v2_ui/src/lib/orchestration.ts index bf849e075..2b699838a 100644 --- a/application/v2_ui/src/lib/orchestration.ts +++ b/application/v2_ui/src/lib/orchestration.ts @@ -887,6 +887,8 @@ export interface PlanStreamResult { } export interface RunStreamHandlers { + /** A durably saved outgoing action, before the final assistant reply exists. */ + onM365PendingActions?: (event: RunStreamEvent) => void; /** A step changed status (`type: "orchestration_step"`). */ onStep?: (event: RunStreamEvent) => void; /** @@ -1442,6 +1444,16 @@ export async function runOrchestration( } const onEvent = (event: RunStreamEvent): boolean => { + if ((event.conversation_id && event.conversation_id !== body.conversation_id) + || (event.run_id && event.run_id !== body.run_id)) return false; + if (event.type === 'm365_pending_action') { + if (event.conversation_id === body.conversation_id && event.run_id === body.run_id + && typeof event.step_id === 'string' && event.step_id + && typeof event.user_message_id === 'string' && event.user_message_id) { + handlers.onM365PendingActions?.(event); + } + return false; + } if (hasPendingOrchestrationOutputs(normalizeOrchestrationAttempt(event).outputs)) { requiresExecutionOutcome = true; } diff --git a/application/v2_ui/src/lib/orchestrationController.ts b/application/v2_ui/src/lib/orchestrationController.ts index d854918f5..306cd9122 100644 --- a/application/v2_ui/src/lib/orchestrationController.ts +++ b/application/v2_ui/src/lib/orchestrationController.ts @@ -820,6 +820,33 @@ async function executeSavedPlan( activeControllers.set(conversationId, controller); activeRunIds.set(conversationId, runId); + const originalUserMessageId = useChatStore.getState().messages.find((message) => + message.conversation_id === conversationId && message.role === 'user' + && message.metadata?.orchestration_turn_id === turnId, + )?.id || context?.pendingUserMessageId || ''; + const currentPendingStream = () => activeControllers.get(conversationId) === controller + && activeRunIds.get(conversationId) === runId + && useChatStore.getState().activeConversationId === conversationId + && chatPendingActionsStore.getState().conversationId === conversationId; + if (originalUserMessageId && currentPendingStream()) { + chatPendingActionsStore.getState().setLiveStream(null); + chatPendingActionsStore.getState().setLiveStream({ + conversationId, userMessageId: originalUserMessageId, placement: 'turn', + }); + } + const ingestOutgoingActions = (event: RunStreamEvent) => { + if (!currentPendingStream() || event.blocked + || (event.conversation_id && event.conversation_id !== conversationId) + || (event.run_id && event.run_id !== runId)) return; + if (event.type === 'm365_pending_action' && ( + !plan.steps.some((step) => step.step_id === event.step_id) + || (originalUserMessageId && event.user_message_id !== originalUserMessageId) + )) return; + chatPendingActionsStore.getState().handleStreamPayload(event, { + conversationId, userMessageId: originalUserMessageId, + }); + }; + const runBody: OrchestrationRunRequest = { run_id: runId, plan_id: planId, @@ -833,6 +860,7 @@ async function executeSavedPlan( let settled = false; let conflictMessage = ''; const acknowledgeWaiting = (event: RunStreamEvent) => { + ingestOutgoingActions(event); settled = true; const current = useOrchestrationStore.getState(); const waitingPlan: OrchestrationPlan = { ...plan, status: 'waiting' }; @@ -850,6 +878,7 @@ async function executeSavedPlan( const result = await runOrchestration( runBody, { + onM365PendingActions: ingestOutgoingActions, onStep: (event) => { const current = useOrchestrationStore.getState(); current.applyStepEvent(conversationId, turnId, event); @@ -876,6 +905,7 @@ async function executeSavedPlan( useChatStore.getState().pushOrchestrationContent(conversationId, accumulated, turnId), onWaiting: acknowledgeWaiting, onDone: (event, accumulated) => { + ingestOutgoingActions(event); settled = true; const status = orchestrationTerminalStatus(event); if (status === 'waiting') { @@ -910,6 +940,7 @@ async function executeSavedPlan( } }, onCancelled: (event, accumulated) => { + ingestOutgoingActions(event); settled = true; const terminal = { ...event, run_id: runId, turn_id: turnId, status: 'cancelled' as const }; useOrchestrationStore.getState().updateRunRecovery(runId, { @@ -948,6 +979,7 @@ async function executeSavedPlan( }, controller.signal, ); + if (currentPendingStream()) chatPendingActionsStore.getState().setLiveStream(null); // A draft may have been saved even when the stream ended without its terminal frame. refreshOutgoingActions(conversationId); diff --git a/application/v2_ui/src/stores/chatStore.ts b/application/v2_ui/src/stores/chatStore.ts index 4b2cd061f..6f4f33d75 100644 --- a/application/v2_ui/src/stores/chatStore.ts +++ b/application/v2_ui/src/stores/chatStore.ts @@ -3720,6 +3720,7 @@ export const useChatStore = create((set, get) => ({ agent_citations: event.agent_citations as ChatMessage['agent_citations'], // Microsoft 365 emails, events and files the answer cites, for its chips. ...(event.blocked ? {} : { m365_citations: readM365Citations(event.m365_citations) }), + ...(event.blocked ? {} : { m365_pending_actions: event.m365_pending_actions }), metadata: { ...event.metadata, ...reasoningMetadataForEvent(event), @@ -3769,6 +3770,7 @@ export const useChatStore = create((set, get) => ({ }; }); + if (!event.blocked) chatPendingActionsStore.getState().trackMessage(finalMessage); const descriptor = outcome.status === 'completed' ? latestSavedAnalysis([finalMessage]) : null; const analysisRevision = get().analysisTurnRevision; if (descriptor && analysisRevision !== null) { diff --git a/application/v2_ui/src/stores/m365PendingActionsStore.ts b/application/v2_ui/src/stores/m365PendingActionsStore.ts index 663c22391..a4bd4d6b5 100644 --- a/application/v2_ui/src/stores/m365PendingActionsStore.ts +++ b/application/v2_ui/src/stores/m365PendingActionsStore.ts @@ -81,6 +81,8 @@ export interface PendingActionDetailState { export interface PendingActionsLiveStream { conversationId: string; userMessageId: string; + /** Orchestrated preparation stays beside its original request until the reply is saved. */ + placement?: 'turn'; } export interface PendingActionsFocusRequest { @@ -477,11 +479,12 @@ export function createPendingActionsStore( patchEntry(id, key, { auth: null, denied: false, - notice: info( - operation === 'cancel' + notice: operation !== 'cancel' && next.status === 'sent' + && (next.graph_resource_type === 'mail' || next.operation === 'send_mail') + ? null + : info(operation === 'cancel' ? 'Cancellation checked. The server status below is authoritative; this does not recall an already sent item.' - : 'Send request checked. Review the server status and delivery note below.', - ), + : 'Send request checked. Review the server status and delivery note below.'), }); } catch (error) { if (!current(id, key)) return; @@ -769,7 +772,8 @@ export function createPendingActionsStore( if (previous) set({ liveStream: null }); return; } - if (previous && previous.conversationId === stream.conversationId && previous.userMessageId === stream.userMessageId) return; + if (previous && previous.conversationId === stream.conversationId + && previous.userMessageId === stream.userMessageId && previous.placement === stream.placement) return; const renamed = previous?.conversationId === stream.conversationId ? previous.userMessageId : ''; set((state) => { if (!renamed || renamed === stream.userMessageId) return { liveStream: stream }; diff --git a/docs/explanation/features/V2_M365_PENDING_ACTION_CARDS.md b/docs/explanation/features/V2_M365_PENDING_ACTION_CARDS.md index 0f7f14faf..6c5e1c97b 100644 --- a/docs/explanation/features/V2_M365_PENDING_ACTION_CARDS.md +++ b/docs/explanation/features/V2_M365_PENDING_ACTION_CARDS.md @@ -4,6 +4,8 @@ Implemented in version: **0.261.307** +Email review flow updated in version: **0.261.324** (`application/single_app/config.py`). + Tracking issue: [#1722](https://github.com/microsoft/simplechat/issues/1722), gap 2 (Chat, "M365 pending-action card"). An agent that prepares a Microsoft 365 email or calendar invitation for review saves it as a pending action. The action waits until its owner sends or cancels it, and a notification tells the owner it is waiting. Only the classic chat page drew that card, so every such notification opened classic chat. @@ -12,7 +14,7 @@ The React V2 chat now draws the card itself, with the same controls and safeguar Dependencies: -* [Microsoft Graph Pending Actions](MSGRAPH_PENDING_ACTIONS.md): the backend this reads and writes. No route, schema, or setting changed. +* [Microsoft Graph Pending Actions](MSGRAPH_PENDING_ACTIONS.md): the backend this reads and writes. The email review repair adds orchestration stream/history references, not a new delivery policy or setting. * [V2 Terms of Use and Approval Requests](V2_TERMS_AND_APPROVALS.md): the Approvals page uses the same card. * [V2 Notification Bell and Desktop Notifications](V2_NOTIFICATIONS_BELL.md): the notices that link to the card. * [React V2 UI](REACT_V2_UI.md): the shell and chat page the card lives in. @@ -24,7 +26,7 @@ Dependencies: A card sits under the reply that saved it, as it does in classic chat. Placement is worked out once for the whole thread, in this order: 1. The message the action names, when that message is on screen. -2. While the reply that saved it is still streaming, under the streaming bubble. +2. While a new Orchestrate run prepares the email, beside its originating user turn; ordinary chat uses the streaming bubble. 3. Otherwise the user turn that caused it, when that turn is on screen. This is also where a card sits if its reply was never saved. 4. The last message of the same request, when the action carries a request id. 5. Otherwise the conversation-level section, **Microsoft 365 outgoing actions for this conversation**, so a pending send is never hidden. @@ -36,6 +38,7 @@ That section also carries the things that belong to the conversation rather than * **Opening a conversation.** The conversation's saved actions are listed with `GET /api/msgraph/pending-actions?conversation_id=&limit=30`, following the continuation token for more. The list is read again when the browser window regains focus or comes back online. * **History.** Messages loaded from history carry their cards and the ids of any that were not loaded with them. Ids without a card are fetched one at a time with `GET /api/msgraph/pending-actions/?conversation_id=`. * **A live reply.** The `m365_pending_action` stream frame puts a card on screen while the reply is still streaming. The finishing frame can carry the final cards, which then sit under the saved reply, or `m365_pending_actions_error` when the server could not attach them, in which case the list is read again. +* **A live Orchestrate run.** Creation frames identify the conversation, run, producing step, original user message and request. The run reader rejects stale or cross-conversation frames; its controller gives valid cards to the existing store immediately. Terminal cards and `metadata.m365_pending_action_ids` promote the same cards beneath the final reply. History uses those saved references, not timestamps, subjects, or the newest message. Existing unlinked records keep their fallback section; this does not relink old attempts. * **After a reply ends.** The conversation's list is read again when a reply finishes or fails, when the reader stops it (once the stop request has been sent, so an action the server saves after that shows on the next read, such as window focus or **Refresh outgoing actions**), and when a reply that was still running is picked up again. An action that the live frames did not deliver, for example after a dropped connection, is on screen before anyone repeats the request. * **A shared conversation.** Other participants are told which action ids a reply saved, and read the list again. When the server could not list them, the thread says "Microsoft 365 actions were saved, but their cards could not be loaded. Reload the conversation to recover them. Do not repeat the request." @@ -45,6 +48,8 @@ A card taken from message history is checked against the server before Send is a The same `PendingActionCard` is used inline in chat and in the Approvals detail pane, so a card behaves the same wherever it is drawn. It shows recipients, times, location, a body preview that is always plain text, and a status. Its controls match the [classic card](../../reference/chat-controls.md#microsoft-365-outgoing-action-cards): +An email awaiting review says **Ready to review — not sent**. Preparation and sending are separate outcomes: a later failed report does not discard the draft or mark it sent. After the owner sends, **Accepted for sending — recipient delivery is not confirmed** is the primary result. The original Outlook-draft warning stays visible; a redundant generic successful send-check notice is omitted. Conflict and unknown-outcome warnings remain, and nothing is sent or replayed automatically by the browser. + * **Send** or **Send now** (for a delayed action) submits the version of the action the reader reviewed, so the server can refuse it if the action changed in the meantime. * **Cancel** stops an unclaimed delivery. * **Review full message** or **Review full invitation** loads the complete content when the preview was shortened. Send stays hidden until it has loaded, and reviewing never sends. @@ -80,6 +85,7 @@ Paths are relative to `application/v2_ui/src`. * `components/chat/MessageList.tsx`: mounts the placement, the section, and a slot under each bubble. * `lib/approvalsApi.ts`: `fetchConversationPendingActions` is new, `fetchPendingAction` takes a conversation id, and `PendingAction` carries the extra fields the chat endpoints return. * `lib/sse.ts`, `lib/types.ts`, `lib/collaborationEvents.ts`, `stores/chatStore.ts`: the stream and shared-conversation wiring, and keeping the store pointed at the open conversation. +* `lib/orchestration.ts`, `lib/orchestrationController.ts`: run-stream creation events, original-turn placement, terminal reconciliation and finish refresh. * `lib/conversationUrl.ts`, `lib/notificationLinks.ts`, `lib/notificationNavigation.ts`, `pages/ChatPage.tsx`: the `m365_pending_action` parameter, routing, and the one-shot focus. * `scripts/check_xss_sinks.py`: `chatHrefForPendingAction` is listed as a reviewed same-origin link builder. @@ -89,7 +95,7 @@ Nothing new to enable. Cards appear whenever an agent uses a Microsoft Graph act * Review the card under the reply, open **Review message body** to read the body, then choose **Send** or **Cancel**. * Choose a notification in the bell to land on the card in its conversation. The card is outlined for a moment so you can find it in a long thread. -* If a card is missing from a thread, use **Refresh outgoing actions** at the foot of the conversation-level section. +* If a card is missing from a thread, use **Refresh outgoing actions** in the conversation-level section. ## Testing and Validation @@ -98,12 +104,12 @@ Functional tests: * `functional_tests/test_v2_m365_pending_actions.py`: the wiring across the chat page, stores, stream, collaboration events, routing, and shared card, and a run of the three Node tests below. * `functional_tests/test_v2_m365_pending_actions_logic.mjs`: snapshot trust, placement, stream and history references, and countdown rules. * `functional_tests/test_v2_m365_pending_actions_store.mjs`: the store's state machine, including late responses, version safety, polling, and focus. -* `functional_tests/test_v2_m365_pending_actions_stream.mjs`: stream frames and shared-conversation events reaching the store. +* `functional_tests/test_v2_m365_pending_actions_stream.mjs`: real chat and orchestration SSE readers/controllers, multiple live cards, saved-reply promotion, failed reports, dropped streams, scoped stale-frame rejection and history recovery. * `functional_tests/test_v2_workflow_run_link_routing.mjs`, `functional_tests/test_v2_notifications_bell.py`, `functional_tests/test_v2_user_settings_memory_m365.py`: updated for the new routing and files. UI tests: -* `ui_tests/test_v2_m365_pending_action_cards.py`: the real message list with inline, streaming, and conversation-level cards, Send and Cancel, and focus. +* `ui_tests/test_v2_m365_pending_action_cards.py`: the real message list with inline, streaming, and conversation-level cards, Send and Cancel, and focus; desktop/mobile Orchestrate preparation, report failure, reference-only reload, keyboard body review and explicit mocked Send/Cancel. * `ui_tests/test_v2_notifications_bell.py`: a notice for a saved action opens its card in V2 chat from another page, from the chat page, for an action the list does not show, and for one that is gone. * `ui_tests/test_v2_approvals_and_terms_pages.py` and `ui_tests/test_v2_approvals_dashboard.py`: the Approvals page, which keeps its test ids on the shared card. @@ -111,4 +117,4 @@ UI tests: * A chat request that pauses for Microsoft 365 sign-in or a sharing approval (`m365_sign_in_required`, `m365_approval_required`) still shows as an ordinary stream error in V2 chat, as it did before. This change adds no pause interface for it. The list is read again when the request ends, so any action the request had already saved still gets its card. V2's orchestration notices for Microsoft 365 (`OrchestrationM365Notice.tsx`) are separate and unchanged. * Notices about an action inside a workflow run open the classic workflow-activity page. -* The backend is unchanged: delayed auto-send still uses the in-process timer described in [Microsoft Graph Pending Actions](MSGRAPH_PENDING_ACTIONS.md). +* Delivery policy is unchanged: delayed auto-send still uses the in-process timer described in [Microsoft Graph Pending Actions](MSGRAPH_PENDING_ACTIONS.md). diff --git a/docs/explanation/fixes/ORCHESTRATION_COSMOS_RESPONSE_COMPATIBILITY_FIX.md b/docs/explanation/fixes/ORCHESTRATION_COSMOS_RESPONSE_COMPATIBILITY_FIX.md index d88ee8df8..dec86c629 100644 --- a/docs/explanation/fixes/ORCHESTRATION_COSMOS_RESPONSE_COMPATIBILITY_FIX.md +++ b/docs/explanation/fixes/ORCHESTRATION_COSMOS_RESPONSE_COMPATIBILITY_FIX.md @@ -133,3 +133,217 @@ for an optional null answer binding in file-only plans. See the [planner deliverable fields fix](ORCHESTRATION_PLANNER_DELIVERABLE_FIELDS_FIX.md) for the reproduced sequence, scope of the model probes, and regression coverage. Validation still rejects missing required answers and unsupported deliverables. + +## Repository-wide boundary follow-up (0.261.324) + +Fixed/Implemented in version: **0.261.324**, recorded by the version update in +`application/single_app/config.py`. + +The earlier fixes were not reverted. A subsequently introduced operation journal +copied a point-read `CosmosDict` before passing it to `canonical_bytes`. The +subclass survived `deepcopy`, so strict JSON validation failed after an external +operation had already produced its durable action. That journal's boundary is +repaired separately as part of the +[email review flow fix](ORCHESTRATION_EMAIL_REVIEW_FLOW_FIX.md). No historical +conversation, outgoing action, or operation is rewritten or replayed. + +### Shared document boundary + +`application/single_app/cosmos_document_utils.py` provides +`normalize_cosmos_document(value)`. It accepts a `collections.abc.Mapping`, +returns a new plain top-level dictionary, and retains every document field, +including `_etag`. Nested values are deliberately unchanged. Non-mappings, +including lists of key/value pairs, raise `TypeError`; they never become an +empty document or a success-shaped fallback. + +The utility imports neither configuration nor the SDK, settings, logging, or +Azure clients. Storage owners retain their own authorization, metadata stripping, +absence/outage handling, conditional writes, and error translation. Equivalent +existing conversions in bootstrap, revisions, recovery, and output storage now +use this utility without weakening their original validation. Settings' private +metadata-stripping helpers remain with settings rather than changing their +different semantics to fit a universal helper. + +`validate_json` remains strict. This is an outer document representation boundary, +not recursive domain repair or a global SDK monkeypatch. + +### Classified audit, not a count of purported bugs + +`functional_tests/cosmos_response_boundaries.json` inventories application storage +functions, repository scripts, and deployer point boundaries. It includes returned +responses, method references passed to helpers, `getattr`-mediated methods, +module-level reads, conditional batch paths, and separate query/batch entries. +Each record has an implementation fingerprint, a consumer classification, an +explicit evidence scope, and applicable test references. + +The reviewed snapshot contains 1,045 storage scopes in 169 files: 7 normalized +strict boundaries, 810 SDK-compatible consumers, and 228 unused responses. +Evidence is deliberately separated: 99 scopes cite owner-runtime regressions, +718 retain source review plus real SDK API evidence, and 228 discard responses. +These are inventory/assurance categories, not counts of production defects. +Owner-runtime references exercise representative real-owner SDK regressions; +they do not establish exhaustive branch coverage of every listed function. +The per-consumer classification records the reviewed contract, not a static +proof that every downstream call is safe. + +The principal findings are: + +| Owner or consumer | Classification and evidence | +| --- | --- | +| Operation journal | Confirmed strict JSON mismatch, reproduced with the real SDK. The owner normalizes before copying; uncertain-effect recovery remains explicit. | +| Bootstrap, revisions, leases/recovery, outputs | Previously repaired strict boundaries. Real authenticated route, ETag, ownership, scheduler, publication, and download contracts still pass in both storage modes. | +| Checkpoints, continuation guards, artifact messages | SDK-compatible field access, nested plain JSON, or metadata-stripping projections. Raw point messages are not themselves the strict descriptor/result envelopes. | +| Workflow control, journal, result manifests/chunks | Control verification accepts dictionary subclasses, replacements are plain metadata-stripped projections, and result field verification accepts `Mapping`. SDK-default runtime/result tests pass without broad production rewrites. | +| M365 requests, approvals, delivery/resume, files/history | Mapping-compatible storage consumers. Public/domain projections and the independently normalized operation receipt must not be conflated with raw point responses. SDK-default regressions preserve current access and ETag behavior. | +| Existing settings, document/admin, prompt/catalog, notification, script/deployer consumers | Classified field/JSON/projection consumers or unused responses. Their inventory distinguishes source review plus real SDK API evidence from owner-runtime SDK coverage; it does not claim every legacy owner has a new end-to-end test. | + +No additional production mismatch was proven by these migrated runtime suites and +the strict-sink review. An exposed SDK mapping, an exact-dictionary check on a +domain payload, or a grep hit is not sufficient evidence of a defect. The +deployer's configuration point read is a mapping field consumer, so no deployer +implementation or deployer version change is required. + +Unchanged legacy source-reviewed owners have a closed fingerprint baseline. +Changed or new owners cannot inherit that limited evidence: they need a reviewed +consumer contract and owner-runtime SDK coverage. The checker is a maintained +change/review guard, not an interprocedural type proof. This distinction is +intentional, so representative SDK evidence cannot silently become a claim of +universal runtime verification. + +### Realistic shared and inline test boundaries + +The shared M365 and atomic orchestration containers now return the **actual +application-pinned SDK `CosmosDict`** from point reads and returned writes by +default. Workflow runtime/result doubles, offline bootstrap/result-route storage, +workflow chat delivery containers, and the inherited orchestration result/message +containers use the same default. `sdk_responses=False` is an explicit compatibility +probe, not the normal easy test path. + +Query rows/pages remain plain dictionaries. Real SDK transport tests also verify +that nested JSON is plain and returned create/upsert/replace/patch documents have +the point-response wrapper. Both modes preserve fields, ETags, partition routing, +conditional conflicts, and failed-batch atomicity. + +The inventory separately records inherited Cosmos containers, write-only and +embedded subprocess containers, test-local fault/compatibility seams, and +domain-level runtime/result mocks. Its 389 entries comprise 11 SDK-default +containers, 4 domain doubles, 227 staged legacy containers, 141 existing +explicit compatibility seams, and 6 runtime-tested fault-injection seams. +Domain mocks deliberately keep plain domain projections; they are not made to +impersonate a Cosmos client. Unchanged inline fakes outside the migrated owners +remain an explicit staged-migration baseline. Removed or changed exemptions fail +the guard, and a new Cosmos container cannot declare itself an unchanged legacy +fake. +Existing compatibility seams have their own closed baseline. A new or changed +point override must supply runtime `fault-injection` evidence instead of +silently preserving an old plain-response override. + +### Dedicated deterministic gate and contributor rule + +`.github/workflows/cosmos-response-contract-check.yml` runs the inventory, +normalizer/shared-double contracts, real SDK transport contracts, orchestration +response/operation/import/telemetry suites, and affected M365/workflow regressions. +The email-review-flow suite also runs in this gate, covering real owner +publication with SDK-default storage alongside operation-journal receipt tests. +It uses existing application/test requirement pins, no cloud credentials, and +`test_support.cosmos_network_guard` to block socket/DNS network access before +collection. Windows' standard-library loopback socket pair for asyncio is the +only narrowly scoped connection exception, not permission for application HTTP. + +Pinned tokenizer data is prepared as a dependency asset in a workspace-local +cache during setup, before network is blocked. This avoids an encoding download +inside a test while keeping the real context-budget calculation. Offline route +fixtures enter through the real orchestration bootstrap and mock the current +model endpoint's external client factory as well as the legacy planner factory. +Legacy approval coverage supplies current external safety dependencies and fails +if that unrelated remediation is unexpectedly invoked. + +The generated-output lifecycle fixture originally injected raw Cosmos reads as +domain-level conversation/run access callbacks. SDK-shaped defaults exposed that +fixture mismatch through both normal and optimized scheduler transport probes. +Its storage-owning callbacks now normalize before strict `OrchestrationResultAccess` +authorization, matching production bootstrap behavior. No domain validator or +authorization rule was weakened, and no container was forced into plain mode. +Production service wiring uses `read_owned_conversation`, which normalizes its +point document, and `get_orchestration_run`, which returns a plain +metadata-stripped projection after its ownership checks. External-source access +uses those same callbacks through `_read_metadata`. The fixture failure is not +evidence of another production `OrchestrationResultAccess` representation bug. +Both transport probes now belong to the core gate; lifecycle fault overrides +have explicit runtime evidence rather than an unchanged compatibility exemption. + +The workflow is triggered by relevant application, script/deployer, test/shared +double, requirement, inventory, contributor-rule, and workflow changes. A new +storage module or differently named test fake cannot avoid the gate. +The runner derives additional test selectors from reviewed owner-runtime, +SDK-default, domain-double, and fault-injection evidence. A newly reviewed +owner's regression therefore executes in CI without requiring a second, +independently maintained workflow test list. + +Contributor instructions are in +`.github/instructions/cosmos-response-boundaries.instructions.md`. Run: + +```powershell +python scripts\check_cosmos_response_boundaries.py +python scripts\check_cosmos_response_boundaries.py --refresh +python scripts\check_cosmos_response_boundaries.py --run-contracts +``` + +`--refresh` only stages changed implementations as `review-required`; it does +not automatically approve a classification or expand a legacy baseline. + +### Follow-up validation + +The normalizer suite covers field/ETag preservation, mapping versus invalid +response shapes, strict nested-domain rejection, and fresh-process normal and +optimized Python imports without configuration or SDK dependencies. Guard tests +cover unused versus returned/helper responses, module-level and dynamic method +references, point/query/batch distinctions, inherited and domain doubles, +similarly named non-Cosmos APIs, new/changed owners, and stale evidence/exemptions. + +Verified with the application's actual `azure-cosmos==4.9.0`; the SDK version +assertion reads its expected value from the application requirements rather than +introducing a second pin: + +- Final normalizer/shared-default, inventory guard, and real SDK transport + contracts: **58 passed**: + `python -m pytest -p test_support.cosmos_network_guard functional_tests\test_cosmos_document_boundaries.py functional_tests\test_m365_cosmos_sdk_contract.py -q --disable-warnings --tb=short`. +- Final dedicated runtime gate in the independently pinned environment: + **567 passed**, including **231 subtests**: + `.venv\pinned\Scripts\python.exe scripts\check_cosmos_response_boundaries.py --run-contracts`. + This verifies Cosmos 4.9.0, Semantic Kernel 1.39.4, and the application-pinned + Flask/Werkzeug versions, with external network blocked during tests. +- Final inventory checker: **1,045 owners, 389 doubles, zero review gaps**: + `python scripts/check_cosmos_response_boundaries.py`. +- Lifecycle fixture follow-up: **275 passed**: + `.venv\pinned\Scripts\python.exe -m pytest -p test_support.cosmos_network_guard functional_tests\test_orchestration_output_lifecycle.py functional_tests\test_cosmos_document_boundaries.py -q --disable-warnings --tb=short`. + Both normal/optimized scheduler transport probes and the underlying file-tick + no-replay regression also pass together (**3 passed**). +- Broader eight-file integration suite after the fixture boundary correction: + **560 passed and 112 subtests passed**: + `.venv\pinned\Scripts\python.exe -m pytest -p test_support.cosmos_network_guard functional_tests\test_orchestration_harness_routes.py functional_tests\test_orchestration_harness_chat_checks.py functional_tests\test_orchestration_action_runtime.py functional_tests\test_orchestration_executor.py functional_tests\test_orchestration_results.py functional_tests\test_orchestration_output_lifecycle.py functional_tests\test_workflow_runtime_integration.py functional_tests\test_workflow_result_store.py -q --disable-warnings --tb=short`. + The earlier 220 lifecycle failures no longer reproduce; SDK-default point + responses remain enabled and strict domain authorization remains unchanged. +- Complete retained-results/output lifecycle plus real SDK production boundary + regressions: **310 passed**: + `.venv\pinned\Scripts\python.exe -m pytest -p test_support.cosmos_network_guard functional_tests\test_orchestration_results.py functional_tests\test_orchestration_output_lifecycle.py functional_tests\test_orchestration_cosmos_response_contract.py -q --disable-warnings --tb=short`. +- Orchestration Cosmos, revision, and telemetry contracts: **90 passed**, + including **36 subtests**, with external network blocked. +- M365 runtime/authorization/approval/file/history and workflow runtime/result + contracts: **153 passed**, including **131 subtests**, with external network + blocked. + +An additional exploratory run of all workflow chat-delivery suites and M365 +continuation/pending-delivery/execution-preflight suites passed **426 tests and +31 subtests**, but reported seven unrelated existing failures: six route-first +public-workspace import-cycle probes (using their own unchanged plain-dictionary +container), and one stale stranger-edit refusal expectation. Broader workflow +result-route/review probes also retain stale retry expectations: an absent +message is rejected before workflow-result retry checks, and an unfinished +attempt prevents an ordinary edit. The refusal and result-route/review outcomes +were reproduced with explicit plain point responses. These are not additional +Cosmos representation mismatches and were not changed or placed in this bounded +contract gate. + +These checks do not send real mail, contact deployed Azure resources, change +production configuration, or relax authorization/result contracts. diff --git a/docs/explanation/fixes/ORCHESTRATION_EMAIL_REVIEW_FLOW_FIX.md b/docs/explanation/fixes/ORCHESTRATION_EMAIL_REVIEW_FLOW_FIX.md new file mode 100644 index 000000000..de6980a7f --- /dev/null +++ b/docs/explanation/fixes/ORCHESTRATION_EMAIL_REVIEW_FLOW_FIX.md @@ -0,0 +1,102 @@ +# Orchestration email review flow fix + +Fixed in version: **0.261.324** + +## Issue and root cause + +An orchestrated email request could create an Outlook draft and its pending action, +then report that draft creation failed. The review card could appear above the +conversation instead of beside the request. + +These were separate problems: + +- The operation journal copied a Cosmos SDK point response without normalizing + its outer `CosmosDict`. `deepcopy` preserves that subclass. The strict JSON + receipt validator rejected it **after** the draft and pending action existed. +- Orchestration's Microsoft 365 request bridge did not pass the producer's + request-owned pending-action references to the owning run and final message. + Without those references, the UI treated the card as an unlinked record. +- Preparation, owner review, send acceptance, and overall run completion were + independent states but their presentation did not explain the distinction. + +The earlier Cosmos compatibility fix in 0.261.140 covered then-existing storage +boundaries. The operation journal introduced in 0.261.321 missed that pattern. +See [Cosmos response compatibility](ORCHESTRATION_COSMOS_RESPONSE_COMPATIBILITY_FIX.md) +for the expanded boundary inventory and prevention checks. + +## Technical changes + +### Receipt persistence + +`functions_orchestration_operations.py` normalizes the trusted point response +before copying it. Document fields and `_etag` remain available for conditional +replacement. Strict JSON validation is unchanged. + +If receipt persistence or sanitization really fails after an effect, the journal +and action wrapper retain `operation_recovery_required`. An unfinished claim is +not permission to repeat the effect. + +### Live and durable linkage + +`functions_orchestration_m365.py` binds the run's producer callback **inside** +each action or agent step's Microsoft 365 request bridge. The producer records +only an already-saved action's ID, owner, conversation, and stable request ID. + +`functions_orchestration_adapters.py` forwards that reference with the run and +step locator. `functions_orchestration_execution.py` validates its owner, +conversation, and step request, saves minimal action IDs on the run, and resolves +current authorized card data before publishing a creation event. + +The final assistant message saves `metadata.m365_pending_action_ids`, including +when later work fails. Terminal responses and existing history hydration resolve +current cards, not private receipts or model-supplied snapshots. Send/cancel +authorization remains in the pending-delivery owner. + +Transport loss does not cancel owning-worker finalization. A card refresh failure +retains the minimal references and reports that outgoing actions should be +reloaded, rather than inviting the user to recreate the email. + +### User experience + +New, correctly linked actions appear beside the originating turn while work is +running, then beneath its saved assistant reply. Successful manual preparation +is **Ready to review — not sent**. Sending remains an explicit owner action. +**Accepted for sending** does not assert recipient delivery. + +If later reporting fails, its failure remains visible without hiding the prepared +email or pretending the whole run succeeded. The retained Outlook draft warning +remains relevant to reviewing and sending the saved content. + +## Scope and compatibility + +- No existing conversations, historical attempts, or pending actions are migrated, + relinked, rewritten, or replayed. +- Stable step request IDs, conditional receipt updates, configured manual/delayed/ + automatic policies, and explicit send/cancel controls are preserved. +- No new setting, route, or delivery policy is introduced. +- `application/single_app/config.py` advances from 0.261.323 to 0.261.324. +- No real email or production mutation is needed for the regression tests. + +## Validation + +`functional_tests/test_orchestration_operation_runtime.py` covers actual SDK and +plain-dictionary receipt responses, all delivery modes, cached recovery, unknown +outcomes, and saved references surviving receipt or UI-publication failure. + +`functional_tests/test_orchestration_email_review_flow.py` reuses the real offline +headless harness to test creation-time linkage, final message persistence, +authoritative terminal refresh, later model failure, disconnected streams, foreign +references, and unavailable card queries. + +The focused backend run passed **57 tests**, including validation with the +application's pinned Cosmos 4.9.0 and Semantic Kernel 1.39.4 dependencies: + +```powershell +.\.venv\Scripts\python.exe -m pytest functional_tests\test_orchestration_email_review_flow.py functional_tests\test_orchestration_operation_runtime.py functional_tests\test_orchestration_catalog_auto_execution.py functional_tests\test_m365_action_card_references.py -q --tb=short --disable-warnings +``` + +Frontend streaming, placement, and review coverage is documented in +[V2 pending-action cards](../features/V2_M365_PENDING_ACTION_CARDS.md). +The related Node suites passed **119 tests**, the mocked desktop/mobile +Playwright suite passed **14 tests**, and frontend wiring/documentation checks +passed **27 tests**, with no skips. The V2 production build also passed. diff --git a/docs/reference/chat-controls.md b/docs/reference/chat-controls.md index a4441fed4..46f98105b 100644 --- a/docs/reference/chat-controls.md +++ b/docs/reference/chat-controls.md @@ -157,10 +157,15 @@ being presented as a model answer that no documents exist. ## Microsoft 365 outgoing action cards -Since **0.261.321**, these same cards also show manual or delayed outgoing actions -prepared by Orchestrate. They are recovered from the authorized conversation list after -an integration step or interrupted run. Opening, refreshing, or approving a plan does -not send a manual draft; use the existing owner-only Send/Cancel controls. +Since **0.261.324**, newly prepared Orchestrate email cards appear beside the +originating request as soon as the draft is saved, then beneath its final reply. +**Ready to review — not sent** means preparation succeeded, not that delivery +occurred. A later reporting failure keeps the prepared card available and remains +a separate failed run result. Reload restores placement from saved action references; +the authorized conversation list remains a recovery fallback after interruption. +Older unlinked actions are not matched to messages by date or subject. +Opening, refreshing, or approving a plan does not send a manual draft; use the +existing owner-only Send/Cancel controls. Implemented in version: **0.261.038** (`application/single_app/config.py`). Manual and delayed email/invitation tools display a saved review card separately @@ -183,13 +188,14 @@ replacement when delivery has an unknown outcome. Immediate operations keep their existing tool-result receipts without a second Send button. For email, Send submits the reviewed content and leaves the original Outlook -draft. **Do not send the retained draft again.** See +draft. **Accepted for sending** means Microsoft 365 accepted the request; +recipient delivery is not confirmed. **Do not send the retained draft again.** See [Microsoft 365 Email]({{ '/reference/actions/m365-email/' | relative_url }}). The React V2 chat draws the same card with the same controls, under the reply that saved it, including while that reply is still streaming. A saved action whose reply is not on screen appears in a **Microsoft 365 outgoing actions for this -conversation** section at the foot of the thread, which also offers **Load more +conversation** section, which also offers **Load more outgoing actions** and **Refresh outgoing actions**. A notification about a saved action opens its conversation and scrolls to the card. See [V2 Microsoft 365 pending-action cards]({{ '/explanation/features/V2_M365_PENDING_ACTION_CARDS/' | relative_url }}). diff --git a/functional_tests/cosmos_response_boundaries.json b/functional_tests/cosmos_response_boundaries.json new file mode 100644 index 000000000..5ac4eead7 --- /dev/null +++ b/functional_tests/cosmos_response_boundaries.json @@ -0,0 +1,31839 @@ +{ + "schema_version": 1, + "audit": { + "implemented_in": "0.261.324", + "scope": "Production application, repository scripts/deployers; query rows are distinct. Runtime assurance is explicit, not implied by a static classification.", + "owner_runtime_assurance": "Owner-runtime references execute representative real-owner SDK regressions; they are not exhaustive branch coverage for every listed function. Consumer classifications remain reviewed contracts, not an interprocedural proof.", + "confirmed_mismatch": "OperationJournal stored CosmosDict reached canonical_bytes after an external effect. Parent-owned fix has real SDK operation regressions.", + "additional_mismatches": "None proven by the classified strict-sink review and migrated SDK-default runtime suites. Raw SDK returns alone are not defects." + }, + "legacy_double_baseline": { + "functional_tests/test_analysis_artifact_publication.py::MemoryContainer": "ec97810e7b5124d3453c7ca0a2cb80eefe27979c5cf33a1ed23cd587b7380553", + "functional_tests/test_analysis_artifact_publication.py::test_upload_digest_binds_idempotent_streams_to_actual_bytes_and_producer.Messages": "ee008aecb3540a21dc67ed331d73cd9895d1966d68edadbd2675309764324169", + "functional_tests/test_analyze_backend_saved_integration.py::MessageStore": "a42a7591508bb96afa1237692c068b8eece3578f6122a643ff0673a263598b04", + "functional_tests/test_app_settings_import_boundaries.py::embedded-BOOTSTRAP_PROBE::Container": "a57e20c3dbdccc261b4626a31dcdfa274e5e7a9dbef084dff956701a67bf7f79", + "functional_tests/test_app_settings_store_consistency.py::FakeCosmos": "cd1b74ab2f7b28788a85faff332d257f2c32ea197b2c87109edb905b398ef822", + "functional_tests/test_approval_notification_routing_fix.py::FakeNotificationContainer": "6045434e804b9570fbc1544a2064c42948949b144c84ea07dadd8735272ee712", + "functional_tests/test_approval_notification_routing_fix.py::FakeApprovalsContainer": "0a9417b62b96283ce5607c98cae4d2de7e8fcc1b489124bdea135ff57a6f28ad", + "functional_tests/test_approval_notification_routing_fix.py::FakeTemplateContainer": "52070b5424f470d19d3d7fc9c94d3f05b6a9ff91a5b6535e30330e45c1cea865", + "functional_tests/test_approval_notification_routing_fix.py::FakeActivityLogsContainer": "005bb7661218df5a3c11cb788b220e6e23149aa9562394134d25315ea246b443", + "functional_tests/test_authenticated_request_login_activity.py::FakeContainer": "19f324fe4b18662bf96c684bde8f65acbea7e3092a429b27986e4d5034ab1cee", + "functional_tests/test_broken_access_control_findings_fix.py::FakeConversationContainer": "050f1e9e27711bc3a014ce117eae75c8a770231216cb66a48033ee8312409f5f", + "functional_tests/test_chat_activity_logging_consistency.py::FakeCreateItemContainer": "5cde54cf8c52b09f846b3134d27d5dc68222db03d02083c2422e3eb42bd51552", + "functional_tests/test_chat_activity_logging_consistency.py::FakeUpsertContainer": "dd15845a300947c81168f6f636abd3cb03cb738f9f38ced2241af45ca83cd3e3", + "functional_tests/test_chat_artifact_download_bytes.py::SnapshotContainer": "0c9c86113ebdf97ccb5e7e18e0b94607a600a63375501940a8d159e650defbd5", + "functional_tests/test_chat_completion_notifications.py::FakeConversationContainer": "d10dfa9c22e7bb0c55537be05e40cc446606b04f7c3c989d095c64fcceb21b51", + "functional_tests/test_chat_completion_notifications.py::FakeNotificationContainer": "6de29a2ca725291333f687eeac7739504b2d61f4eeaf4919949ba65b389c76f9", + "functional_tests/test_chat_content_review.py::MemoryContainer": "571662ad3bfb7d415e15fc87ca5058b3ff6245132e4b69b8ead812b335480169", + "functional_tests/test_chat_retry_attempt_lifecycle.py::AttemptContainer": "950125475efe89b636c89b12fc627b1a7efe655850f59c2df76c7887a5c1d02d", + "functional_tests/test_chat_retry_import_boundaries.py::embedded-EARLY_PROBE::Store": "cbaff5fea3a887773cf9fbd5091ea8abf00401fcbab64136c5e9a32d5c1308b0", + "functional_tests/test_chat_soft_deleted_message_visibility_fix.py::FakeContainer": "e0a87844aa3ecabfd79f15ec1d2c982ff4b1e80045460924390b8841169c61ab", + "functional_tests/test_chats_user_settings_hardening_fix.py::FakeContainer": "c2e7589713eac62c8295839d46ee101e2bc2a35bce7d52b60b9c56dc5aa590e0", + "functional_tests/test_collaboration_conversation_summary_export_fix.py::FailingLegacyConversationContainer": "b10916bf4ad3a24d2ceb899e51ef12f0f2890a5d12e6d332e8eb7e9f2f4f2165", + "functional_tests/test_collaboration_conversation_summary_export_fix.py::FakeCollaborationConversationContainer": "0cca7924d04c8c9435b35858077f81be9082ac98c1f783855e150bee47a49ccb", + "functional_tests/test_collaboration_group_agent_stream_fix.py::FakeItemContainer": "fd9f4f549704c05bd8bbbd42a3931c6924941329a7b27bb873d20a06a6775368", + "functional_tests/test_collaboration_group_agent_stream_fix.py::FakeConversationContainer": "bdf3ba0e532b24b592f1d327ca1809ae06104bb97d4a64eea1a9500aa0a05b48", + "functional_tests/test_collaboration_message_delete_fix.py::FakeCollaborationMessageContainer": "de05ca6ef0b38648b7d245525fbcabc5692f5a673a8b952f8b9d4254728b9a90", + "functional_tests/test_collaboration_message_delete_fix.py::FakeConversationContainer": "6403f3d7d101201634db2940d69c6cc5e66b04889b81267af9737ae8a616fb1d", + "functional_tests/test_collaboration_message_notifications.py::FakeNotificationContainer": "cb0ce3d5f6533b303e0b9c200dfc0d1628ebdc373a2e3d72a75f8ff7168f54c9", + "functional_tests/test_collaboration_message_notifications.py::FakeConversationContainer": "b4445e3aa6982cede5e06969b96980782ab279060f1780a93e97d55de38e9242", + "functional_tests/test_collaboration_stream_image_completion_fix.py::FakeItemContainer": "fd9f4f549704c05bd8bbbd42a3931c6924941329a7b27bb873d20a06a6775368", + "functional_tests/test_collaboration_stream_image_completion_fix.py::FakeConversationContainer": "bdf3ba0e532b24b592f1d327ca1809ae06104bb97d4a64eea1a9500aa0a05b48", + "functional_tests/test_content_screening_access.py::FakeContainer": "49e1afde282ab0c06ce6d11e3a4880f5724dbaea45b8681add3e676d254abfa6", + "functional_tests/test_content_screening_activity.py::ActivityContainer": "50d33e640c11200df87f5f8edb9ba5d42eb7b50bf68b3bdb8e703a224d29f3ba", + "functional_tests/test_content_screening_persistence.py::FakeCosmos": "6e43c5d8b3da6130e4048987bd732b537b755fdc8a1a7b29f2fbbff86c089296", + "functional_tests/test_content_screening_persistence_lifecycle.py::TransferCosmos": "cbdf2376f92be34e5e580eeced5130fbdb9331b7cfca64d5daea493e022fe55f", + "functional_tests/test_content_screening_upload_only_intake.py::ScanStore": "98682bdf89b0c86d333c5d3bdf505031855403af903fae3fb305a001e714f5a6", + "functional_tests/test_conversation_fork.py::FakeConversationContainer": "bb7e27324c0642206aa1054c6fcd99c9c78a2ef5e7d4f3fed17dcaadb9e6903d", + "functional_tests/test_conversation_fork.py::FakeMessageContainer": "6018eed98d71fd668640dd4feacb08b9eb73d8125cd5a95d122536c9283db94f", + "functional_tests/test_conversations_read_ownership_authorization.py::FakeConversationContainer": "ba650b736d7b2292a2c85090c8651981ae00dc5c0c34ec43ea2040953a007988", + "functional_tests/test_conversations_read_ownership_authorization.py::FakeMessageContainer": "f081f5604867034a947a621bbdb014f2231d8c594b55703deb7cb47eb35baa79", + "functional_tests/test_cosmos_document_boundaries.py::embedded-source::embedded-PROBE::OfflineContainer": "745bd4517b52265a0f58dfcebc666df37d24145f7e246780425d39c6fff1bab4", + "functional_tests/test_cosmos_phase3_shared_cache_metrics.py::FakeCosmosContainer": "ecec3cde0f9955253ca772f6f808b987c0fa459936fc936eed0d8c66006cf703", + "functional_tests/test_cosmos_query_plugin.py::FakeConfigCosmosContainer": "095b220b2213af22be0034d4681b0e7ad5b83bec18c842feef322204db0446a6", + "functional_tests/test_cosmos_wave1_app_maintenance.py::FakeCosmosContainer": "bcbe331ab972db82e2aabb1a739383b7eccd280b2cb60aaf197c4fdf151f0aff", + "functional_tests/test_cosmos_wave1_cache_fallback.py::FakeCosmosContainer": "1d9621d284a53f3c76a7f361ca74ce43b4b0f88471ee9c44af69d7a2d07b2d71", + "functional_tests/test_cosmos_wave2a_chat_bootstrap_cache.py::FakeCosmosContainer": "993715fa7e392d397b233fa774311250648559c595ba5ebbb427bbde4eec4752", + "functional_tests/test_cosmos_wave2a_custom_pages_cache.py::FakeCosmosContainer": "40578067bab81e4bf886387c2499fcfc82ee95adf4c6717f8cad1bbb23719ede", + "functional_tests/test_cosmos_wave2b_conversation_cache.py::FakeCosmosContainer": "6f3108e5a59d4acc9fa61aa68e81bba061b0b59b856f6116db024244fd3b3731", + "functional_tests/test_cosmos_wave2b_conversation_cache.py::ConflictOnceFakeCosmosContainer": "fdc506e52743e70e842d81d512f7a7d97f142ddd5bb3a885b7732f61f5758b43", + "functional_tests/test_cosmos_wave3a_indexing_maintenance.py::FakeCosmosContainer": "fd7bb5710516eb27f904c73ec3823bb554fd8ac6caad09ffd1fca2b264a60fde", + "functional_tests/test_cosmos_wave3b_document_access_index.py::FakeCosmosContainer": "877c2641e7c9db8acc2c582f217014eee0a63219a3d3aaa8595e4772de5bf56a", + "functional_tests/test_cosmos_wave3b_document_access_index.py::FakeRepairBacklogStateWriteFailContainer": "0cba8e4febf8cd338dfeca127fda2fa469a51f292a27512c4a34df0923534762", + "functional_tests/test_cosmos_wave4a_document_access_backfill.py::FakeCosmosContainer": "5b3c45c2c094082569b756cb04b739ea3199e3d1ec878b70586b58af14aabfc9", + "functional_tests/test_cosmos_wave4a_document_access_backfill.py::FakeRepairBacklogStateWriteFailContainer": "1a9ccf9a16774c06699c86116a41007d582f33143298c68f212654e5754dbd16", + "functional_tests/test_cosmos_wave4b_document_access_shadow_validation.py::FakeCosmosContainer": "059a2352afda8fe35e9cd4c62d167c372439c9ef1c054cce10721f2ad000cbad", + "functional_tests/test_cosmos_wave4b_document_access_shadow_validation.py::ConflictOnceShadowStateContainer": "d483ae8e4e277a8790bd6fdc22ce2ee805f215a1ece83e7aaf89d16f54122c6b", + "functional_tests/test_cosmos_wave5a_document_access_read_switch.py::FakeCosmosContainer": "f1d8897ce4ec206e280295b3401380c4ae304d74eb00d24810619f7a0261b989", + "functional_tests/test_cosmos_wave5a_document_access_read_switch.py::FakeRepairBacklogStateReadFailContainer": "d6419642876a8dcd321a71b9a20f42e26d7740a1351ab9c9801e34d159e1364b", + "functional_tests/test_cosmos_wave6_document_access_cache.py::FakeCosmosContainer": "4d53bc0fbf9c63b5ef0c81a99d44c920d12be6112b20dec0b0ec5428c2ff947c", + "functional_tests/test_cosmos_wave6_document_access_cache.py::FakeFencedDocumentsContainer": "9b1bc623f59c1964a09180e2044914728adb4172d8db56c26033c8530ff15661", + "functional_tests/test_cosmos_wave6_document_access_cache.py::FailingRepairDocumentContainer": "ffa7826dd8c1e8908fa929ac363872af2c4cefc1995dc6299f260ab634a6936c", + "functional_tests/test_cosmos_wave6_document_access_cache.py::ToggleFailUpsertContainer": "e69811a541918f46c6529854338e68c0c886aa0f40a4fd037cafd2735e6f0b78", + "functional_tests/test_data_management_ai_search_backup_export.py::FakeJobContainer": "551770da8f4807a75a52f69fe94cf610f46f1982e0a0b59d5d8edcbe4d98cc52", + "functional_tests/test_data_management_ai_search_backup_export.py::FakeItemStateContainer": "1aaf6efa476d43fda952276eb4c1ffdcc97138be01c191ee19f0ac5b4169d004", + "functional_tests/test_data_management_ai_search_migration_resilience.py::FakeJobContainer": "bde452bc7ae9d7e7dfab6d6d7784d0a08709ac15a8554df5371b46fcff5bd02e", + "functional_tests/test_data_management_backup_durability.py::FakeJobContainer": "0298f4c937c060c6cc15afc06e111d9fbe0724d6d248e4b2cbfc8c4f476689b2", + "functional_tests/test_data_management_backup_durability.py::FakeItemStateContainer": "a2fcd77112808242860182f2d0397d9b32268479f14c37c5b1b6adea9892aa2f", + "functional_tests/test_data_management_backup_parallelism.py::FakeJobContainer": "b2a9fb5ca9a8f0d1a2750b9d52b814facad0f2be42b67f6ba5050dca522dca9a", + "functional_tests/test_data_management_backup_parallelism.py::FakeItemStateContainer": "5d7e5573af411579fd1e91cb62c27d0a3b6e7e77e35c3ef28dd4638330584df8", + "functional_tests/test_data_management_blob_backup_transfers.py::FakeCosmosContainer": "2a0f8cd8f58505c7bc1cccc93b6c0a814ec8368455b94c6516f314b31e0a5ee7", + "functional_tests/test_data_management_blob_migration_resilience.py::FakeJobContainer": "076697802996b6c8b54d8e02a81181934d58690be63bf05ff304c87714a2b449", + "functional_tests/test_data_management_cosmos_migration_resilience.py::FakeJobContainer": "8627d84a50bda641dcb7667a0fc68924d5eecfc2a6cb6bc906a9b90fa19a1f65", + "functional_tests/test_data_management_cosmos_migration_resilience.py::FakeTargetContainer": "df43049507ff09f110e9e4f0754f191939d9b73641bd807c24f89cb7a3102290", + "functional_tests/test_data_management_cosmos_migration_resilience.py::test_cosmos_write_renews_heartbeat_while_request_is_in_flight.SlowTargetContainer": "1b3e0dd66cea8d1497b5faaf48c847043091b5011f75a5512706a6d2d6af7122", + "functional_tests/test_data_management_destination_cosmos_capacity.py::FakeJobContainer": "b6eea217f23866518d5ae6dd78494ee06ad87810ff1cfdf51249431716f0381b", + "functional_tests/test_data_management_destination_cosmos_capacity.py::FakeTargetContainer": "9ddcf9c0739431e83e15bc7e7709f1878f889dd424db7ad300ba8d4732bcc323", + "functional_tests/test_data_management_incremental_migration_modes.py::FakeJobContainer": "d290a2b58632cf8f29d15b78170f9525408316ef6ba288a5090ffa7a4adb6933", + "functional_tests/test_data_management_job_step_status.py::StubContainer": "9cd6527154390fb306bd57336780cc844406d4e20137ff3cd20e7fcdf11b1ff5", + "functional_tests/test_data_management_migration_cancellation.py::FakeJobContainer": "faf6856b4a7824d8187bd5d637754851dc022691849bbbc39aa6256921f5ed70", + "functional_tests/test_data_management_migration_coordinator.py::FakeCoordinatorContainer": "6e7d0b99d7c774a3c56b1ca0515ef8c8ca8152650cab4501ee3c6376589e9e2c", + "functional_tests/test_data_management_migration_manifest.py::FakeManifestContainer": "16989f3287810a975da8df258a52e2b065f3e354c0df83b2dad8a408899bd443", + "functional_tests/test_data_management_migration_manifest.py::FakeJobContainer": "aeca572888f0a23d023f901059f86bc1993450264028adebad550adce1cffed0", + "functional_tests/test_data_management_migration_orchestration.py::FakeJobContainer": "bca4a1b44a4645f0f151d2c3f2ca710ca4bc52b6d2a157a5942722afb34a3e59", + "functional_tests/test_data_management_migration_preflight.py::FakeJobContainer": "b7b0a1f1395522afd40a016e3327d9abfa126d491e4aad4e01cecb4b28b7273d", + "functional_tests/test_data_management_migration_reconciliation.py::FakeJobContainer": "d5787f620baebca14cccd99fb75d3abc87582c2a9db1dd33ee958673ff02ee71", + "functional_tests/test_data_management_migration_reconciliation.py::FakeCosmosContainer": "8ff029f73494c0c3a59d42e85b618dc9d757e0e09a7ae6084bd1841c93e6630b", + "functional_tests/test_data_management_migration_reconciliation.py::FakeSearchGateContainer": "97100ad227cc4ff84b0b78e4011031a41c8af32dcb15c8d51a3ff8e8eb606b20", + "functional_tests/test_data_management_migration_recovery.py::FakeJobContainer": "10141aa567c05681749bba6b4c5eb3447e4c7a1cae166ce4bab13b6483265b96", + "functional_tests/test_data_management_migration_retry.py::FakeJobContainer": "925f9f2f1d4e40b6dc41780dae85ae3b5d6213957430e887ecc1e873595c7fc2", + "functional_tests/test_data_management_migration_retry.py::FakeConditionalJobContainer": "ccfbae71fe9891d382c29e396f1a775c47c0cae257ad5a077bf3831650bf73c1", + "functional_tests/test_data_management_migration_workflow_contract.py::FakeJobContainer": "a11d3df9e31ef79a2c6e084a0b82e6e4b87698ac82d60df8ce50d7966c2d2822", + "functional_tests/test_data_management_public_prompt_migration.py::FakeJobContainer": "e4425c2413451a929d7ce8d484436e3377390aa97d8078f5e740eaa328eb6c57", + "functional_tests/test_data_management_public_prompt_migration.py::FakePromptContainer": "f90a351f5d1c7f9a839dffb1ea672e590f89f793a69a0ca9261dc6d654b5b233", + "functional_tests/test_data_management_restore_workflow.py::FakeJobContainer": "0e4faec7d72e3868283d1ed5b87cb4a5f53a0c87520ab342dea9d71dd1c94f80", + "functional_tests/test_data_management_search_write_fence.py::FakeGateContainer": "f394479b2cf1c792190e223a79a25e66c4e3cedc7e879897da8e3242557a2189", + "functional_tests/test_data_management_search_write_fence.py::ConflictHeavyGateContainer": "7d9d5513b34b7d999cba20e9c244b0138f021a4e7cdaf6ab738554d47cebb178", + "functional_tests/test_data_management_search_write_fence_authorization.py::FakeDocumentContainer": "5874ec2ea0226e92ebae46370a79de919dcc0cd02d2dfef1de9023c6cee779e6", + "functional_tests/test_document_action_token_usage_aggregation.py::FakeContainer": "e361c4a3f139294e8df324901e4a28f206ba3674b67c89f7adc00d096b8b0362", + "functional_tests/test_document_analysis_work_recovery.py::AnalysisMemoryContainer": "43e50434122272c7ff69fe482ff91ebe64de87f28ab2f43fccd4b4ae775675de", + "functional_tests/test_document_provenance_origin.py::ConversationStore": "630bfc8422d888ce8a1734e838558088c1ce97442c414b68d92ea8f2ea324664", + "functional_tests/test_document_provenance_publication.py::test_an_unreadable_conversation_never_blocks_publication.UnavailableConversations": "2f5064c80b76b576c350ae31e227f600afe4b68141b950fc3b073e3be39bcd91", + "functional_tests/test_document_provenance_versions_and_guards.py::ConversationReads": "6b6e988a4e5a58c97875c61b731a11c92fcd62567f635898c815e6f9bbed1ba1", + "functional_tests/test_document_search_metadata_sync.py::FakeDocumentsContainer": "81341dcf6916ebe93a2ad55f6a2e90c747d7d8f19d6b7b019399f440d98ba717", + "functional_tests/test_fact_memory_profile_and_mini_sk.py::FakeFactContainer": "38a457b1b2a3236d946664ca1db4353daef1e21c6f36abadfd47178a28ad1393", + "functional_tests/test_feedback_submission_authorization.py::FakeConversationContainer": "314eaff4d7220b4632b4a838633a4c3928350063fd568f04da566aef8c3d3df0", + "functional_tests/test_feedback_submission_authorization.py::FakeFeedbackContainer": "8280ace4523971c41e58ee4481d244324bc42c7c264451e0fe953a838b0d2dcd", + "functional_tests/test_file_processing_log_cleanup.py::FakeContainer": "41ff073c85da8fef7fc313fbcd91768c6346b85e9a51e730753e211234245330", + "functional_tests/test_file_sync_concurrent_write_safety.py::FakeContainer": "cad02223f972963265e08215caa9ce5f694d67c1f68de51787433c62b645adb8", + "functional_tests/test_generated_artifact_lifecycle_authorization.py::FakeContainer": "40b9e39e5be46f6931e7c464370aaaf5e3d37dcf8e1dbaf9878a88a63a0ab3ba", + "functional_tests/test_global_action_user_audit_fallback.py::FakeContainer": "02ce692e66f14c955277e5b5ccfbe3febf5f4d072bc77dd4fb9873fae6c86aae", + "functional_tests/test_governance_activity_logging.py::_TestContainer": "9f02ab0c3183caaf69c19e6f2b033dec456e8150780bae92f7924b16fc18127a", + "functional_tests/test_governance_activity_logging.py::_InMemoryContainer": "0eca2d37c35a1795aa5e8c81ad2bf8edab3278e5c2eb2f81fefd8aefc5c68ed8", + "functional_tests/test_governance_activity_logging.py::test_log_governance_change_payload_shape._CaptureContainer": "32c533efa11bb5e0e43eb04e1ff8181e2f61136547a41ba4f049e3f9f32e7885", + "functional_tests/test_governance_enforcement_logic.py::_TestContainer": "d63738467acb076f9b58352cacffdb089964ed34bfcf9e7cb2559398652752f8", + "functional_tests/test_governance_enforcement_logic.py::test_item_policy_retarget_moves_existing_policy_document._RetargetContainer": "d40ab12258ce79e37633ce0dd8007ed21f366fbca61707710b22d26b222d1ac6", + "functional_tests/test_group_collaboration_source_storage_fix.py::TrackingContainer": "b7f6aaeb047f653a04deb72b47f6d3dc4ea7217657a458804619f7d541451fa1", + "functional_tests/test_group_document_blob_upload_etag.py::EtagContainer": "04d26586e428a7b409df295fed7f7dc30006d079b32e771fcca8ee434292f0fc", + "functional_tests/test_group_document_collaboration.py::NotificationStore": "9bb791d0b53d58fbf3f1ae9b612c1353c5cf4c64fd6ed461b8efb22409fa680d", + "functional_tests/test_group_document_management.py::MutableContainer": "edd199af6e65f009cde7064a0c3f75a10528a2804a87fa088026fc8a51b54695", + "functional_tests/test_group_document_projection_fence.py::ConditionalSource": "c20344bfa0fb178c58e8902951c929b25031407bb293cc03f48ac08f4f8a23c1", + "functional_tests/test_group_document_publication.py::ReceiptStore": "6fe3e6d0e35d37c57c5a546e36ec84875d00143bddfb380cbce277eb71794627", + "functional_tests/test_group_document_read_apis.py::ReadOnlyContainer": "925157ea0fe0958105d37ead5a17c1b9cd425fd63b4cfcdf3a0e776afdc02bb0", + "functional_tests/test_group_workflow_round_trip_preservation.py::WorkflowContainer": "3fab6066dea8faf8de7a9c7579402b831de2920391510a28c0f476c248b310b3", + "functional_tests/test_image_chat_route_integration.py::MemoryContainer": "c30f1c70f4722977981804422a9ca1c7283302626f6a0960480713143e423f05", + "functional_tests/test_image_reference_resolver.py::ImageReferenceResolverTests.test_personal_metadata_reader_never_searches_group_or_public_containers.FakeContainer": "0e983ef8ec51a81d6004da495dd127c168bcce8f7c12173046c2a98d50c60b4c", + "functional_tests/test_keyvault_external_notification_telemetry.py::FakeReminderContainer": "e1aeb47e7e545f70ac1cfff338c1079af707337fbcfd8e74be62e07a095a8392", + "functional_tests/test_large_image_api.py::FakeMessageContainer": "770121757d61639154206a58faf6a80f46b33a097b2ee4ee8e56ab62e8981bab", + "functional_tests/test_log_credential_key_redaction.py::install_cosmos_stub.StubContainer": "3bdfea7af241b250bc5e9397d90474ca77fe6c5d32cd8d86a66bf510264f8824", + "functional_tests/test_log_injection_codeql_alerts_fix.py::CacheContainer": "eb422ca7e5993397e230cc80dfa2fc3b6b0620e1e7188f5422c9c8b844f3a3ee", + "functional_tests/test_m365_action_card_api.py::CardContainer": "5b8f2d941400e8f05bec6782db6260bc4c075be15d8d0b9916c2a3c00d2e93af", + "functional_tests/test_m365_action_lifecycle.py::MemoryContainer": "a8d9a2799d781e7080af5f2cb9edd7ec079ba2072f694d9eaf49f60ef77aca9a", + "functional_tests/test_m365_chat_action_cards.py::run_offline_scenarios.Container": "a920b0d111b76470c5329435987179ee91722e093e8147e3c0dbcb0d884c9a65", + "functional_tests/test_m365_continuations.py::PendingJobs": "e72fab118acd5efc25d2abf21dcaae8fab1da84480fc764a93faa130e46bccb1", + "functional_tests/test_m365_conversation_lifecycle.py::PendingContainer": "aa3e0ed29d4fcd5ceffab62147053c57edfa2d52dd75d511cc07782e28d0036c", + "functional_tests/test_m365_pending_delivery.py::PendingContainer": "6d7f9224c38485e2ab89910c54da8914ccdb2deb6c74f9686edb4756a4c082f1", + "functional_tests/test_m365_runtime_imports.py::embedded-PROBE::Container": "bea3be0a6d645448de027c756f434e8074405d0af51c2e3f6cccea8c10266954", + "functional_tests/test_m365_settings_ingress.py::test_concurrent_removal_cannot_be_undone_by_a_stale_settings_write.Container": "d9e4703c452054edf8afa3416cd3f96feeb50f7aadd210ec80e624e9d1452c7c", + "functional_tests/test_mcp_legacy_stdio_management.py::MemoryContainer": "9cf968cd08dae37d3b7ff411ba289fc8c4c4886d647b4b0418e5ae465727c75a", + "functional_tests/test_mixed_source_hardening.py::test_citation_artifact_cancellation_rolls_back_partial_publication.CitationContainer": "e0862a25ebe3eacdf878f2aa5ba669ab1bee4cbf314394fd5a2a082483fe0e14", + "functional_tests/test_mixed_source_manifest_contracts.py::FakeItemContainer": "726452b10b6d643018640bf35a3e14267f9778b5551f78d910a755c20bee8a43", + "functional_tests/test_native_tabular_compute_service.py::MemoryContainer": "9c202a2f5b77929fb894a653d496cb3210228b48736ca181cc6700e013bc98b7", + "functional_tests/test_orchestration_deliverables.py::test_the_approval_route_never_pays_twice_for_a_planned_image.Messages": "c924a9b032582bdca61c02deeb5ae07b03d30ecfe134d9cbb69b55fd0251dd27", + "functional_tests/test_orchestration_elicitation_context.py::MemoryContainer": "58b6664323cd3f3d7a7226ec7799a8790adb7ad263368b8d1606e3067781a877", + "functional_tests/test_orchestration_external_bootstrap.py::BoundedMemoryContainer": "bd58572f9260ba7706b856aabc59262354fb55e3349c6d9b93acb8d4886732fe", + "functional_tests/test_orchestration_external_metadata.py::RecordedContainer": "d549c7964480d85b7edd0b04753a5bf222896290f29f118a7541a33bf762d6f0", + "functional_tests/test_orchestration_image_references.py::test_candidate_computation_images_only_and_conversation_mismatch.Messages": "c83f012c8945ca7cfc3ecf94073bdb6a28ea0de7043bc52d266d98130aa939b8", + "functional_tests/test_orchestration_image_references.py::test_candidates_use_enriched_metadata_scopes_and_fold_uploads.Messages": "19f833896f6ef02d8b9ba8aebe79e81c21622ddc55d5ba4218dea3f7afbef91b", + "functional_tests/test_orchestration_publication_policy.py::embedded-APPROVAL_PROBE::Messages": "2a3b0594aa169126b37006a4fd16a41679d68d8b6a0a733f48a60d1828c7b618", + "functional_tests/test_orchestration_run_hydration_routes.py::_load_projections.UncheckedReplyMessages": "35f1185c741c93db15b5ae1fb8c304298a8e892eb5da3932802f01a3fbe50779", + "functional_tests/test_orchestration_shared_conversations.py::CollaborationMessages": "1ef0833a0f30a281222ceb8fcc43011d94512aad2ea9b5ef689754a26d10d417", + "functional_tests/test_orchestration_source_access.py::AuthorityContainer": "afca61571d53031a3ddb9b0a6867adc88ef2bdb6556faa4c5a545db5e1282016", + "functional_tests/test_orchestration_workflow_handoff_routes.py::Items": "6914cac3c722eef349cf1501a2be418bb3f6b4f43313a2417b7011488b0a70e2", + "functional_tests/test_orchestration_workflow_proposal_routes.py::WorkflowStore": "91a993eec08666cb4b02bb093d8b88770e3950e1f906b2c9d0c690e67413475d", + "functional_tests/test_orchestration_workflow_proposal_routes.py::RunStore": "6eb7164a6fe952467933ad96ba82d70bda80397860753babde5731309904467c", + "functional_tests/test_orchestration_workflow_results_answer.py::_RecordingThoughtsContainer": "d1bf0b07378a65b1cab993aa347f9951691578ff94e2ca28875ac4ec2e815f7d", + "functional_tests/test_orchestration_workflow_results_reads.py::test_point_reads_raise_retryable_failure_for_cosmos_errors_and_not_found_is_none.FailingContainer": "3431f807d65601efe70e820f8c8d260b4a046e60e076e515390666ff598568b4", + "functional_tests/test_orchestration_workflow_run_adapter.py::Items": "f8b44aa6f394af2d977a54208ec4a32a1569f26080d97458e29a8edeab92121a", + "functional_tests/test_orchestration_workflow_run_link_routes.py::Reads": "d15889852fc5294cf921bf21598344bc6af30837759fed3dc42a2055bb85f14e", + "functional_tests/test_orchestration_workflow_run_wait_delivery.py::_Interleaved": "bf9623f29d24db3a5c3bbbbc678c7a174bea8ea420fab2dd72b3ff27c9671d0f", + "functional_tests/test_personal_conversation_followup_authorization.py::FakeConversationContainer": "fb77c31de0fbaa797b2a7f2322bd1be5f56f449b07ce9c4f8709cb39f57c05c2", + "functional_tests/test_personal_conversation_followup_authorization.py::FakeMessageContainer": "ee1d15567a3fca917624ca25f6763507bbc6c73b452d6eeefc3b2f84b94f6fb6", + "functional_tests/test_personal_prompt_helper_user_id_fix.py::FakeContainer": "a3b0ad067a024947f255fd92b5586bc5771c31b65cb0f572d18a24912c20c9c3", + "functional_tests/test_profile_last_login_activity_logs.py::FakeActivityLogsContainer": "c0a0e16dcb46f190d2154ef84da3f5616df03c1efa2a8117ce9b60a2710ff497", + "functional_tests/test_public_document_management.py::MutablePublicContainer": "8f1b235aea39f0113ef1f98d21c5b78e188f86e97dd3d8ab0579dcfe3db3b4ab", + "functional_tests/test_public_document_publication.py::PublicReceiptStore": "80ff2515fc0b99b7b75c571c20cfea3b3af79c4ca457b2b65f1198fc3cce1a53", + "functional_tests/test_public_document_read_apis.py::PublicReadOnlyContainer": "4dbfccf1c46ddabcd9b37b16bd0f0732a946b8d9bdf470915f93ddbfa832ccf6", + "functional_tests/test_retention_policy_conversation_scope_coverage.py::FakeContainer": "bee7de987e969bda891a5f6f1b4154af99e58742d0fdc4e0626b9bf1196b582a", + "functional_tests/test_rocksdb_plugin.py::FakeConfigCosmosContainer": "b78f10904add5d7bdb2f0ee4e030b25fed9df7f70d6b326ddeb80bca314967ec", + "functional_tests/test_security_authorization_hardening.py::test_chat_route_enforces_conversation_ownership_and_scope_canonicalization.DummyConversationContainer": "44beae8c8fb09ae4bfb46adbef5e4a689f6fc91c7091fcab4c6cd9cf3713ff14", + "functional_tests/test_simplechat_conversation_messages.py::FakeConversationsContainer": "6f84dba9a66ccec93c2bdb647b9fbccbc21f39560d6fbb380e5e2a35b7f4ba02", + "functional_tests/test_simplechat_conversation_messages.py::FakeMessagesContainer": "30db219d7d2d2876e243a4ea8e75800def281bdf733823dac06fbffba2cc650d", + "functional_tests/test_simplechat_operation_notifications.py::StubContainer": "da8fe2ca99d9f82d2b10c91e8f97286987842f63310533097819b97dff96d9f1", + "functional_tests/test_sql_plugin_key_vault_secret_storage.py::FakeActionContainer": "768117cbefcc6f10ad01c44065dd53a5357aad508afc4de83b06b1ed05ffaebe", + "functional_tests/test_tableau_action_plugin.py::FakeConfigCosmosContainer": "2891876d4f48b5d3095890884d949ebed41a539245158d0e5c10564785271966", + "functional_tests/test_tabular_queue_run_output_schema_end_to_end.py::_FakeCosmosContainer": "b7e7e3d1fca788bda4a6a11ff4107a1515fa0d3d0674fbef53ddf72cf70b8467", + "functional_tests/test_tabular_row_orchestration_scale.py::_load_authorization_helper.ConversationContainer": "0a5bab1189c80777556da73db39d4e1b059b31532a62e3970d02ed4b4cb9afb7", + "functional_tests/test_tabular_row_orchestration_scale.py::_load_idempotent_artifact_helper.ConversationContainer": "1424579df50c6b9cd672b3bc1e4a0eb4bb3cb3b3879c828a99b9395775d7b546", + "functional_tests/test_tabular_row_orchestration_scale.py::_load_idempotent_artifact_helper.MessageContainer": "f3721403a528e2fa7752bce16e6df9f13540437bcacdb537ebe5c2a3655507f3", + "functional_tests/test_user_profile_idor_authorization.py::FakeUserSettingsContainer": "3bdc0718fc46fd1a9d0e5cda3051e0dd4bb828df23e79fdc75a803587940df80", + "functional_tests/test_user_profile_idor_authorization.py::FakeCollaborationStateContainer": "3c957b4bd86d055e0479d3924d483809acfaa49bdc7eff55629ad105a8884c47", + "functional_tests/test_v2_admin_global_editor_backend.py::FakeContainer": "b40564d4a39248ea5113ac721ceebddfd0c0e40adeedcb26fd644e3a84a85ce4", + "functional_tests/test_v2_collaboration_visual_style_fix.py::_FakeMessageContainer": "67b75eed00079d97919cd876edb09c9db3d0ec1071c3181cfc0244fb7e4f8368", + "functional_tests/test_v2_collaboration_visual_style_fix.py::_get_conversation_kind._PersonalContainer": "42a95d8d775aa56caef2af45d3dd5718c8173f0c40ee3a3f0039fe61f9f575d7", + "functional_tests/test_v2_control_center_action.py::ReadOnlyContainer": "b3fc8c0e3b6613e42dda8ce6982e4bc3b657d9f9cb3e38548ce01276c0440efd", + "functional_tests/test_v2_control_center_dashboard.py::GuardedContainer": "efd5bc89fad705f49de835b2fd734a1b293e5fb8c6fa7e06b34d00022938b7b2", + "functional_tests/test_v2_control_center_groups.py::InventoryGroups": "0122043eeed2aaaf30d0ceeaa49b20f5cbcfc675bea809a3ec3a4ef44ab9bf02", + "functional_tests/test_v2_control_center_public_workspaces.py::WorkspaceQueries": "702976567ccf5633b3e28f5f13684ab4a8e9303b8e7fc7f92375b7d24421c568", + "functional_tests/test_v2_control_center_public_workspaces.py::Activity": "53834ae0f934316d5a2cb15170ab10a566f0dbbf40ee32754663ea706058431f", + "functional_tests/test_v2_prompt_attachment_persistence.py::MemoryContainer": "f5c64014f88e8cf6a32ecfa6504c90930996bbee835ea67c8c7706fbfe0cfdc1", + "functional_tests/test_workflow_alert_acknowledgment.py::FakeContainer": "b5c41c4277956dceb248fd8acbf23cfda0f6a5973321f7d356bc7d05b4bb5b6b", + "functional_tests/test_workflow_assist_dry_run_parity.py::test_a_store_outage_is_a_503_never_a_missing_workflow.Failing": "67078b330bc416001af83f5593c239854804ee654689ec60afa4e03b903ebc02", + "functional_tests/test_workflow_assist_limits_runtime.py::ScriptedContainer": "4f094a5bc2d65c3a578761e9187838993b448f28a8c12d9effaf75f38c798dfc", + "functional_tests/test_workflow_assist_limits_runtime.py::ReadOnlyContainer": "45e0717be7b2a7ba46a8ba7820af7cc96498be25fe3d8db9b230d74a5b716ee8", + "functional_tests/test_workflow_assist_limits_runtime.py::LimitContainer": "4d3ac9d01d9ab958b435a2a048abbbdfe85bf99c8406996b34090eb480a8078e", + "functional_tests/test_workflow_background_identity.py::UserSettingsContainer": "d8784a657b813098418c68f028f774acb2b489db090c0bbb9802df4b3a99709a", + "functional_tests/test_workflow_chat_delivery_imports.py::embedded-PROBE::OfflineContainer": "57e0a5028a73e934671f6fd67fea3cc1e0bec95fd3d0cea24c6a34aaafa0ae4f", + "functional_tests/test_workflow_definition_concurrency.py::Container": "4f636ecdf07b473645840ba33d20e1b466b389225d4fc47c9f51c7a16a949215", + "functional_tests/test_workflow_definition_store_integration.py::WorkflowContainer": "3a9f42dcc26d3640dde6cb9e1d6dfb793995b4f173971ae1ec97f756c03506cc", + "functional_tests/test_workflow_durable_execution.py::RuntimeContainer": "6c1092805035053525e87598adb696b309c5ad4db3982460ac13e28a97d3a8cc", + "functional_tests/test_workflow_for_each_execution.py::LoopJournalContainer": "91a930bf853c47faa0ab13f147522a5687a1cb796ace034282d97d7323d43530", + "functional_tests/test_workflow_loop_inputs.py::Container": "bdcb36c96bd3040d0bab37b130c809a9cc1f5b96ecceea607a2bdfc7b839f906", + "functional_tests/test_workflow_plan_replay_execution.py::RuntimeContainer": "261c47ef00ca665b097906fdb2604440033326e912735b162d4ec8a9f1b6c82c", + "functional_tests/test_workflow_plan_replay_routes.py::WorkflowStore": "fc978256baff1d479d7930beeebcd2e196971649c7cba272e327651bab1f2505", + "functional_tests/test_workflow_private_analysis_records.py::Items": "bf3fe857ce402fc7ba8ffbb7b4163bebeff13f295de896f7f92e145a5e3565bd", + "functional_tests/test_workflow_reply_replaces_agent_posted_message.py::FakeContainer": "d8c2864e6fc5992b088caea0d70813c79a48a1104cf440a05bd19537b1e5c059", + "functional_tests/test_workflow_result_followup.py::Messages": "36d789c1247b2f2488093045647a6670d1f7f24e548aac09f24650f90e292b6d", + "functional_tests/test_workflow_runtime_integration.py::ServiceContainer": "cffcfe612c3e5963875a758197331c393c580d29adec7191eefecd93e0533999", + "functional_tests/test_workflow_structured_flow.py::JournalContainer": "22617222c341f976e6438a50dad225229aba459fb17ae631c2da34a931e488f6", + "functional_tests/test_workflow_task_result_handoff.py::RunItemsContainer": "c3b26a1b2428fe15593ce4f45db10df0e208217f4dfee7f200f74d75650b3dde", + "functional_tests/test_yamcs_action_plugin.py::FakeConfigCosmosContainer": "484348ec19021ba279aa44c152721f7d0f8da6eb16f72afca92c0035156e5588", + "functional_tests/test_yamcs_basic_auth.py::FakeConfigCosmosContainer": "98e363d239d8d8432772c3921fe34da109d39895a30ae200ce76823c0e968589", + "functional_tests/test_support/document_search_sync.py::FakeSettingsContainer": "35e64544ef22a24fd938dff315098a18df75d69f480fa3a01813b0dac969187e", + "functional_tests/test_support/group_action_harness.py::ActionContainer": "d99f9befa4a855c8a1ceb4ee15a626499ffdb684367fd7a14692cd334d68f16a", + "functional_tests/test_support/group_agent_harness.py::AgentContainer": "f12ce9c23db08169cdd8cf635e280fd4dda5dba6ad7e63d650414e9074bcc76e", + "functional_tests/test_support/group_file_source_harness.py::FileSyncContainer": "709d63d875b8307dc95a60e8f7c4fa42a3d0e18198d8b5c7e40b66cd403af296", + "functional_tests/test_support/group_identity_harness.py::IdentityContainer": "8bf84795716fb05095c3aa3c82088b694450e5067ef605eadae12041611c9209", + "functional_tests/test_support/group_prompt_harness.py::PromptContainer": "be0edb616bc6968b1fd8be345afc887975becde08963bc3b2ec93a7c591c58bd", + "functional_tests/test_support/orchestration_reference_world.py::RecordingContainer": "18d5969f551fe5d56a09fbe0f64a375050a6a1e0bc647e7ba6da17c5e9db9674", + "functional_tests/test_support/public_file_source_harness.py::FileSyncContainer": "f92bbce3c7ffb32b0a827f7a40a5decaea04385ad14a7b86eda49d9c42f39813", + "functional_tests/test_support/public_file_source_harness.py::WorkspaceContainer": "2e207f81faa57d515f811974d7e333e201fe87c3f1b94ab27b0bc5e93ca6f1a1", + "functional_tests/test_support/public_identity_harness.py::IdentityContainer": "52ffee57db3ccecf089409ebfdd001588bd748be62835b7824f0820370879e7f", + "functional_tests/test_support/public_identity_harness.py::WorkspaceContainer": "caa5fdabaa2a25ccb32e9aba7d9badbc79b2217fe9e1284d8e9464c3866f4cf3", + "functional_tests/test_support/public_prompt_harness.py::PromptContainer": "966ef57ff79b8542aa5a4c8092cb91a675f04217548f781cc342492025196792", + "functional_tests/test_support/public_prompt_harness.py::WorkspaceContainer": "9b27f02278b8c8fbdda3c8f4eabf9697c62a3e51da531e090ff73a7c9543b6e8", + "functional_tests/test_support/safety_review_harness.py::FakeSafetyContainer": "1df19db7bf53c8a2204b111ac52ba68d67c25f77121acaf007a378f5d871ba4c", + "functional_tests/test_support/safety_review_harness.py::FakeApprovalsContainer": "04041e7b36202562ffb1c357e658a01665328bb33c842f577d8b2f350c28144e", + "functional_tests/test_support/workflow_result_chat.py::FakeContainer": "29ced7d445032c9b7f0ef64bbb90e907c8a3dc27e2f4f1b8cb1a3408508652c4" + }, + "compatibility_seam_baseline": { + "functional_tests/test_agent_delegation_entrypoints.py::test_actual_stream_stop_finalizer_persists_completed_child_sources_and_usage::point-seam-1": "f936c54594c2fea11a969037139d842dde2548fc7a95b4ef3b03b2966f0e36c3", + "functional_tests/test_agent_delegation_entrypoints.py::test_actual_stream_stop_finalizer_persists_completed_child_sources_and_usage::point-seam-2": "98f823b77b5c86200f521c831b0b25842a930f248df77893b2c920aaf9236010", + "functional_tests/test_ai_connection_embedding_migration.py::MigrationRuntime.__init__::point-seam-1": "3f764672e77c40eaf47a3322af05ee036c38d2628d2bb29d9377bda404e5e6a4", + "functional_tests/test_ai_connection_embedding_migration.py::MigrationRuntime.installed::point-seam-1": "3f764672e77c40eaf47a3322af05ee036c38d2628d2bb29d9377bda404e5e6a4", + "functional_tests/test_analysis_answer_and_export_data.py::test_workflow_explanation_exports_keep_the_original_source_restrictions::point-seam-1": "33bab539f3319ffb0356014efc773b28d183a774a63443570966ec6a1bbce162", + "functional_tests/test_analysis_answer_and_export_data.py::test_workflow_explanation_exports_keep_the_original_source_restrictions::point-seam-2": "33bab539f3319ffb0356014efc773b28d183a774a63443570966ec6a1bbce162", + "functional_tests/test_analysis_artifact_publication.py::test_upload_digest_binds_idempotent_streams_to_actual_bytes_and_producer::point-seam-1": "a6bc4b09bbe5259531d39809982d8b1c6f046fa8ad2643d95447f3223815da77", + "functional_tests/test_analysis_result_store.py::ChatAnalysisResultStoreTests.test_cleanup_tolerates_objects_disappearing_during_conditional_deletion::point-seam-1": "79ed64d08f98a4fca04dc9a188c0a22a517f3058471f6cd444ee91fe4931dd92", + "functional_tests/test_analysis_unavailable_message_families.py::test_former_bare_raises_name_the_container_that_failed::point-seam-1": "f1ea659581f344555c06bb890d248e3a924ef1c84bb7e5c3cf5e5ecb8807dfc8", + "functional_tests/test_analysis_unavailable_message_families.py::test_former_bare_raises_name_the_container_that_failed::point-seam-2": "e2a95116de1787567c7778506d12c16ebd3e549f327bfc599b6e445e0f8c33ee", + "functional_tests/test_analyze_backend_saved_integration.py::chat::point-seam-1": "c2924134207839e68c93a6387a701717e7b2e85490bd0af0fc764f454561cc02", + "functional_tests/test_analyze_backend_saved_integration.py::test_direct_analyze_persists_one_assistant_inside_the_merged_guards::point-seam-1": "5e1c69397b19f2eab1ab0eb2b5e7f97e4b862a1f8da387255246054681f4db97", + "functional_tests/test_analyze_live_write_fences.py::test_stop_between_guard_read_and_payload_batch_is_conditional::point-seam-1": "eca9a3d25c3efdfc044e702cb5bdadb8d01f21ff51f060e4f83d76ec7c8db238", + "functional_tests/test_analyze_live_write_fences.py::test_user_turn_retry_association_is_conditional_and_actor_bound::point-seam-1": "65a265d658851ff14f6a4ec48ee5afb4e343c4c233304c782e8de396107c2234", + "functional_tests/test_analyze_live_write_fences.py::test_cached_conversation_update_cannot_erase_a_racing_deletion_marker::point-seam-1": "7d7ce8b3587c7003dd96380770e4457e46bc87c061129e9c756847feeb5840e5", + "functional_tests/test_analyze_live_write_fences.py::test_deleted_followup_turn_cannot_publish_a_late_explanation::point-seam-1": "1dbcd3a8a8e1d9c2429e37efc6cc17ae95f68e7653579e8f1475d373d8be09bb", + "functional_tests/test_analyze_live_write_fences.py::test_deleted_followup_turn_cannot_publish_a_late_explanation::point-seam-2": "93b885b77fef7af413fbb6949e20d978e46aae99b38d554430824b51d059e471", + "functional_tests/test_app_settings_embedding_write_guard.py::test_guard_covers_cas_and_shared_publication::point-seam-1": "35efd968dac1374a92b820c977f571811555f724a6daf8fc36f928be6302a8db", + "functional_tests/test_content_screening_model.py::ModelScreeningTests.setUp::point-seam-1": "b055a801fcce98f8471e9011e5afe19480bb1c141d878b7d369acaa8ca14ef76", + "functional_tests/test_content_screening_settings_api.py::ScreeningApiTests.setUp::point-seam-1": "74f7f9b6775dc16f2ac73bad41be814d961fad8552fcebe0a26c2951d3f1325c", + "functional_tests/test_control_center_group_writers.py::after_first_read::point-seam-1": "5de003ca45b93656241c492c9fe0aaab177004156aef1387637ccd256e0a1e8d", + "functional_tests/test_document_analysis_work_recovery.py::test_lost_unit_completion_acknowledgement_resumes_the_committed_payload::point-seam-1": "95200f2a066f0aeb1dc0031f5adbb989e719e01fab3eaf538d69e89ede188327", + "functional_tests/test_document_transform_sources.py::artifact_source::point-seam-1": "2ba56ec290b576c73babefd0bf5e3e5ba80783d8e52b86e5ad1c6960182008c9", + "functional_tests/test_document_transform_sources.py::artifact_source::point-seam-2": "2df426737d6d9db74b9bac70d7917c1d1c8fe0d749fd35b6e3a10f7f237476cf", + "functional_tests/test_group_bulk_endpoint_save_writer.py::test_an_uncertain_write_failure_keeps_the_staged_credential::point-seam-1": "3b6e0e4e3ed668adc041c5025ce9a719e46c7210f9ccc0c801c9933aea0fd385", + "functional_tests/test_group_collaboration_source_storage_fix.py::::point-seam-1": "4a48a24c2df97a05d5a40913107be86372924525a6937cae0b1a1442978df655", + "functional_tests/test_group_directory_apis.py::test_a_storage_failure_is_a_generic_500_without_the_exception_text::point-seam-1": "49c7c8deaa5a44d44ff2bea40175742a0502eca9fd076ebb4ba778a5475e093c", + "functional_tests/test_group_document_collaboration.py::sharing::point-seam-1": "622061cb752b75c2bd60a15973aa66ba2a1c40caa3a3e3ce13bfd8b5aa9d6cc3", + "functional_tests/test_group_document_collaboration.py::test_lost_effect_checkpoint_acknowledgement_never_replays_completed_work::point-seam-1": "0eb0cfbf4a569eecb062f0f92c8091e796edbefe160957cd376cb81c917da99c", + "functional_tests/test_group_document_collaboration.py::test_unknown_notification_create_acknowledgement_is_not_a_replayable_refusal::point-seam-1": "e73cb994e7dc1ed15f6e01442678c0596439655563876e680060b16d10ff88c1", + "functional_tests/test_group_document_collaboration.py::test_unknown_notification_create_acknowledgement_is_not_a_replayable_refusal::point-seam-2": "ab267636be22eb0fe4c1570617372c40703729d1ee0c28a3aa857f7091423c8c", + "functional_tests/test_group_document_etag_guard.py::test_a_lost_response_commit_is_recognised_rather_than_retried::point-seam-1": "baa274ecc8140f28630a480339a8ac1d90a5d46cbff7b77b6750c1a4e88bafed", + "functional_tests/test_group_document_etag_guard.py::test_a_none_cache_reason_lost_response_commit_is_recognised_without_a_bump::point-seam-1": "baa274ecc8140f28630a480339a8ac1d90a5d46cbff7b77b6750c1a4e88bafed", + "functional_tests/test_group_endpoint_apis.py::test_a_lost_response_commit_is_reported_committed_and_its_key_kept.replace_then_lose_the_response::point-seam-1": "0049dac4f02755fa9c7acf09ec5bc2560a3afd2c96803a49eb3c6bf95c6c3bab", + "functional_tests/test_group_endpoint_apis.py::test_a_lost_response_commit_is_reported_committed_and_its_key_kept::point-seam-1": "f71a1eea72d6a68103893fdf6f15ec57f9d5bebf2ba1f0fb5384c37f4cc5b8d3", + "functional_tests/test_group_endpoint_apis.py::test_an_uncertain_failure_keeps_staged_keys::point-seam-1": "dd5e8c5480df1bca33af9cbe6f36011fcbe522fa94063cd5483e6a068980c53b", + "functional_tests/test_group_membership_apis.py::test_an_unexpected_failure_is_a_logged_generic_500::point-seam-1": "ef3c9de02250a4782170b33ea862728152775eb2c4a2952791292edbd6f11438", + "functional_tests/test_group_screening_fixture_parity.py::RealScreening.__init__::point-seam-1": "32f4a3eea0a5dc6ae5c85e6f15a7f5afbf0b1422cac0bbd97f79ada944d7090d", + "functional_tests/test_group_settings_apis.py::test_a_storage_failure_mid_write_is_a_data_free_500::point-seam-1": "8836d3440676eaf33b011a2bf76b29f9a0c0673f6b167b344c304261978017a1", + "functional_tests/test_group_settings_apis.py::test_an_unexpected_failure_is_a_logged_data_free_500::point-seam-1": "405ed0d1a8554e092c90443a1f21931c381e4df5fe29e26f7f483f134fd85d08", + "functional_tests/test_group_settings_legacy_fixes.py::test_a_storage_failure_answers_reviewed_text_and_logs_no_detail::point-seam-1": "d3a7587deee2f8c5dc92682224c482398f54c1612cdc7726362c354cd48d9648", + "functional_tests/test_group_tag_definition_writers.py::tag_environment::point-seam-1": "818cd86350b506bc49e4e02947b0e11dfb14380820170c9a8d52fc44629259bd", + "functional_tests/test_group_tag_definition_writers.py::after_read::point-seam-1": "08481ae890cac7fce71bb88cf3d596ef572d23189bd5530937bce57183b0a2c4", + "functional_tests/test_m365_action_lifecycle.py::test_exact_id_lookup_never_treats_storage_failure_as_absence::point-seam-1": "ebaa519abc9f29220a6c78cd1eae3c542251167dd91017c6f308bc45c1d93ff5", + "functional_tests/test_m365_action_lifecycle.py::test_migration_receipt_lookup_never_treats_storage_failure_as_absence::point-seam-1": "86419fec7c2c4d60436b41cf80fdd444ac052bd5deb4d9ebb8dbbb2c29e94f6f", + "functional_tests/test_m365_file_runtime.py::test_conditional_conflicts_retry_the_same_budget_with_fresh_etags::point-seam-1": "852a59c59402643ca050c03833a13a7a09380150fd49e029d13d1d8bb8162025", + "functional_tests/test_m365_file_runtime.py::test_final_conflict_exhaustion_is_an_error_not_an_empty_budget::point-seam-1": "4fa4b4f448f1cfdeb1131f4b38a885803a94b98e73c5cf2d1c82ae7c9f07e088", + "functional_tests/test_m365_file_runtime.py::test_conflict_cannot_switch_to_another_request_budget::point-seam-1": "a5bb3ea2163d0717b7f62bca83119e8cd80bcc7716b12a4d5194d7d8e502b362", + "functional_tests/test_m365_file_runtime.py::test_non_conflict_storage_failures_are_surfaced_without_retry::point-seam-1": "696797d4e9dd34edf466130805635acf8a713ba90244dd6983f4d54f1329f098", + "functional_tests/test_m365_routes.py::M365RouteTests.test_dependency_errors_do_not_reveal_sdk_or_configuration_text::point-seam-1": "e7e922f903b75f695ebd5046b2d8720f215844627c1c0287537920099fd783c4", + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_single_action_lookup_storage_errors_are_not_reported_as_absent_actions::point-seam-1": "7f3bab30dec53ea2102d4450a219a6dc099963d1adc38b66b0f477a8c5361c3b", + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_legacy_list_read_and_validation_failures_remain_visible::point-seam-1": "54a75d4f867eee35ffdacb2313b66c1a3e449cefe80fdaead4374784218b467c", + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_legacy_list_read_and_validation_failures_remain_visible::point-seam-2": "d8cc9e4fd4cc9680faf7432db6389117b933eb85617548cb813c8e48e0455c35", + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_global_save_propagates_lookup_failures_without_writes::point-seam-1": "5b666b16529e29204ace02c93856f6b5e84b7ce1f5483d1ff0060774cf669a94", + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_route_settings_preflight_entry_point_preserves_sources_and_propagates_failures::point-seam-1": "44ec4cc86b9a1dacea46525ba8b41aff557a28ba99897777bc838ac8bd432b3c", + "functional_tests/test_native_tabular_compute_service.py::test_atomic_submission_race_preserves_one_owned_job::point-seam-1": "1428cce7aa903edb52dd293d4e0e52b449ba7aa2330318b8046f4a9eab68acf0", + "functional_tests/test_onenote_upload_dispatch.py::OneNoteUploadDispatchTests.run_dispatch::point-seam-1": "b02aabf2eb772690694c14d3c4a77f0379b0b4adddcbd257778237a029317c17", + "functional_tests/test_orchestration_checkpoint_error_mapping.py::_fail_read::point-seam-1": "ceaa19e624147e4906937d58ff9ef9fa120c2c526a4f287af6bc081ea97f36ac", + "functional_tests/test_orchestration_cleanup_bootstrap.py::test_root_cleanup_does_not_coerce_non_mapping_authority::point-seam-1": "5e6346b3fec47b703d027d683c703e09624ad88dae97f78c2a676a2104e2b514", + "functional_tests/test_orchestration_continuation.py::test_result_read_rechecks_epoch_after_the_control_point_read::point-seam-1": "afc7f23eb210c8d5636b2f32732c7bbed2fba7cc4aeb7554dc88170f258f4746", + "functional_tests/test_orchestration_cosmos_response_contract.py::test_output_read_does_not_coerce_non_mapping_documents::point-seam-1": "7db8d3cc7f1aaf30ddabeb5cfcac4191332dd90aa75fba47b8d63454e315d96c", + "functional_tests/test_orchestration_deletion_enrollment.py::test_cleanup_fences_and_enrolls_before_any_payload_sweep::point-seam-1": "e49d7be57c154d5d8c00208fa928fd5ff6725077067418275c1092cf9770cfc7", + "functional_tests/test_orchestration_deletion_enrollment.py::test_lost_parent_ack_has_real_guard_proof_for_missing_conversation_replay::point-seam-1": "ddb32af28ff14e1ecab68dc9b5426d7e7075f65cad9226d02b50cf76395b3ef4", + "functional_tests/test_orchestration_external_bootstrap.py::external_root::point-seam-1": "ea8a9f7e58a1d8a71f9b2e09ba36ebd7946c59fadf2d2c4f41f3b8693bda61d5", + "functional_tests/test_orchestration_external_bootstrap.py::external_root::point-seam-2": "f30b7c58e415c93458a496a7dd33f3908bf5d8da9a1298445b1c78201e8d0da2", + "functional_tests/test_orchestration_external_bootstrap.py::test_default_root_current_authority_storage_failures_are_operational::point-seam-1": "5c295f01095171c162144621364ac8ae5511df0408b6419e6ec3eedf01bc5546", + "functional_tests/test_orchestration_external_bootstrap.py::test_identity_does_not_coerce_non_mapping_settings_into_authority::point-seam-1": "de3dc806cf455361d5108d594d3436415f2278e5d473829dad261c70b7fa89c5", + "functional_tests/test_orchestration_harness_execution.py::test_harness_strict_source_io_failures_remain_fenced_at_the_real_model_boundary::point-seam-1": "b08c02aa0a58372e103a5e704426a24007217e964562325870a93979699faced", + "functional_tests/test_orchestration_harness_execution.py::test_initial_result_binding_outage_does_not_publish_a_terminal_outcome::point-seam-1": "1358e236ff8d70450b9082a6adddbf2a99da494c6602c9e14733bea8daa843e8", + "functional_tests/test_orchestration_harness_execution.py::test_continuation_io_preserves_saved_work_for_retry::point-seam-1": "ba3bf0eb6547ec906df6bd483e7c4946b5cf78e431ba2910bd9e0baef0d8e109", + "functional_tests/test_orchestration_harness_execution.py::test_external_runtime_callbacks_keep_signature_return_and_shared_service_identity::point-seam-1": "ed1bd5dc1e19a4737b7b0f477901784da7d8213a1781bd82838afa0bfb808be3", + "functional_tests/test_orchestration_harness_execution.py::test_external_runtime_callbacks_preserve_typed_failures_and_recheck_the_live_lease::point-seam-1": "ed1bd5dc1e19a4737b7b0f477901784da7d8213a1781bd82838afa0bfb808be3", + "functional_tests/test_orchestration_harness_execution.py::test_actual_preflight_preserves_current_metadata_failure_identity::point-seam-1": "ed1bd5dc1e19a4737b7b0f477901784da7d8213a1781bd82838afa0bfb808be3", + "functional_tests/test_orchestration_harness_execution.py::test_citation_delivery_rechecks_exact_sources_and_preserves_storage_uncertainty.recheck_source::point-seam-1": "c194c26b928acd87733d18298236eada76d23f24ca004b0e17d77cc7edca3ef4", + "functional_tests/test_orchestration_harness_execution.py::test_authority_infrastructure_never_becomes_a_headless_denial::point-seam-1": "7208dcd8b308ea7e87a1d4c53dc26c1613035b31642d582d2aaa51d83fbf3c59", + "functional_tests/test_orchestration_harness_execution.py::test_checkpoint_read_outage_preserves_the_committed_file_before_publication::point-seam-1": "1c2d4f2b39ac0e39deb6dc37ad78d6c9af39ef364b52939892997e4e356c58ad", + "functional_tests/test_orchestration_harness_execution.py::test_real_native_checkpoint_read_outage_does_not_poll_or_finalize::point-seam-1": "3ea9485b02cf329612e57b476d0321bb979c26ca217dbc313df20891cef260fb", + "functional_tests/test_orchestration_harness_execution.py::test_execution_publication_authority_failure_closes_without_a_success_frame::point-seam-1": "e9c7730eb62a242ad43c9f5b43e99ad86171347b5a91dd62a85cb60890b6d138", + "functional_tests/test_orchestration_harness_routes.py::test_bootstrap_metadata_reader_rechecks_real_owner_and_preserves_storage_failure::point-seam-1": "dce3543080cad52c7eac9fc48b230015efea63ac41770cd686299a84c6694ee0", + "functional_tests/test_orchestration_harness_scheduler.py::test_scheduler_preserves_real_headless_authority_uncertainty::point-seam-1": "9b5b4037195795f9d56902d2df0134ebce10267538547876b8bfb33cc19927d0", + "functional_tests/test_orchestration_harness_scheduler.py::test_uncertain_admitted_output_preserves_minimal_step_wait_without_a_task::point-seam-1": "67105095ec2ffc34fcd1cb66014dd8356d51680ecc8d42733847a267c224bd83", + "functional_tests/test_orchestration_harness_scheduler.py::test_enrollment_restarts_after_a_process_dies_between_exact_output_tombstones::point-seam-1": "5cabc24c72911324ad274d54d9916f8d2c15c53fe23e933568b5fb17ed90340c", + "functional_tests/test_orchestration_initial_claim_recovery.py::test_initial_claim_persists_the_deadline_in_its_own_conditional_write::point-seam-1": "713374d0a03b19040145829adf94bd58fc98c98d52de0d37cc9033ac5876d9b8", + "functional_tests/test_orchestration_initial_claim_recovery.py::test_first_binding_reconciles_lost_acknowledgement_and_freezes_exact_value::point-seam-1": "cbef93c0fb2af601ba834cf59a50a3464eae6a0460c04cc32398ac83e4f1ce24", + "functional_tests/test_orchestration_initial_claim_recovery.py::test_first_binding_cas_cannot_overwrite_a_concurrent_owner_or_stop::point-seam-1": "ac16451278895362a2133670a15c293d06043c77fd570c62e97387803e662b95", + "functional_tests/test_orchestration_initial_claim_recovery.py::test_lost_initial_claim_acknowledgement_recovers_without_restarting_the_budget::point-seam-1": "cbef93c0fb2af601ba834cf59a50a3464eae6a0460c04cc32398ac83e4f1ce24", + "functional_tests/test_orchestration_initial_claim_recovery.py::test_lost_first_binding_acknowledgement_cannot_adopt_a_successor_claim::point-seam-1": "006c0c521750dde2b00a68acf4860af09743633f3c2a9a2bb9201f869aeb47d9", + "functional_tests/test_orchestration_m365_actions.py::stub_modules::point-seam-1": "21bce9bad3ccfb36846ac339006811a3f8332b085753f143da27bb5aa5fca51b", + "functional_tests/test_orchestration_native_infrastructure_failures.py::test_actual_pending_poll_transport_failure_preserves_original_wait::point-seam-1": "d6afb55de0212ec166a0b8b99f760e399b71d3be84a76282b396620fa7062650", + "functional_tests/test_orchestration_native_infrastructure_failures.py::test_receipt_transport_uncertainty_is_not_absence_or_replacement::point-seam-1": "ec8e6956c8973b63f11a240bfc7e46165a2f33a933ba1f6c26827174323c7130", + "functional_tests/test_orchestration_native_infrastructure_runtime.py::test_native_wait_survives_transport_failure_and_finishes_the_original_job::point-seam-1": "d915467d6f2c441f60d311182542b05788ad7eeb533ea528a382bed7fb626612", + "functional_tests/test_orchestration_native_infrastructure_runtime.py::test_scheduler_preserves_native_wait_and_recovers_after_actual_transport_outage::point-seam-1": "d915467d6f2c441f60d311182542b05788ad7eeb533ea528a382bed7fb626612", + "functional_tests/test_orchestration_operation_runtime.py::test_saved_manual_draft_reference_crosses_bridge_before_receipt_failure::point-seam-1": "a04b7b2c3283773f941ee8dfcdac3a382dfd665081369a3e76d5b4fc1a273689", + "functional_tests/test_orchestration_operation_runtime.py::test_receipt_conflict_retries_storage_not_the_effect::point-seam-1": "238961d2ff4168f4f1984bb71ff50a0530abccced2b0d445cedae59bf5369280", + "functional_tests/test_orchestration_output_checkpoint_storage.py::checkpoint_failure::point-seam-1": "384d4e46181b64c9079299762b1192e31bc7ced16a0c5ae913fb7a556a91080e", + "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_rechecks_owner_before_deleting_bytes::point-seam-1": "da33a84c69de324a322e17b5527ac569c00a64b089c7a969e0dcbb9301e23e29", + "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_message_delete_is_conditional_and_can_reconcile::point-seam-1": "8e59b84740e8042d3f3107595ee61c89258880d6c2c1365794625008a5d8ef81", + "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_finish_cas_preserves_uncertain_acknowledgements::point-seam-1": "cdd5d5f094befbd7d5c5a73bdc9905f48cb45fbc6ce28b4f31edec16084d6f62", + "functional_tests/test_orchestration_output_deletion_pipeline.py::deletion_runtime::point-seam-1": "423bff81aca75a70145ac96e5fa06d3ac8c7f8e9a5a0aeded78072581ebbea3f", + "functional_tests/test_orchestration_output_deletion_pipeline.py::deletion_runtime::point-seam-2": "d0a2c40af189d4781dd32eb8360a043d480e3f70f80fd8f2c55917198505c649", + "functional_tests/test_orchestration_output_deletion_pipeline.py::test_interrupted_deletion_enrollment_is_replayed_without_another_delete_request::point-seam-1": "a0e2656b75de507800bb3591e11204f1e0d7069d50b9a837f887ede5890eaa38", + "functional_tests/test_orchestration_output_deletion_pipeline.py::test_interrupted_deletion_enrollment_is_replayed_without_another_delete_request::point-seam-2": "4a11a1895fb8d8a74c465f431f3e9b651092387288dad1284513a14cae580add", + "functional_tests/test_orchestration_output_enrollment.py::test_competing_enrollment_workers_keep_one_durable_fence_per_output::point-seam-1": "cf35de3b0b53438b42e873a9f42c5247ea4d0f8d1f9ffcb0891a7d24ce3ad200", + "functional_tests/test_orchestration_output_enrollment.py::test_completion_marker_requires_persistence_and_reconciles_uncertain_ack::point-seam-1": "ba9cb4f2972dc8d91225202927b7e6287a96bdc5ea2838dd00894bf4585fbe97", + "functional_tests/test_orchestration_plan_revision_routes.py::PlanRevisionRouteTests.test_storage_failure_does_not_publish_or_discard_previous_plan::point-seam-1": "fd011e247b496901a32f6389e24930d482bc34682bdb6caec05ac8b9b78d39a8", + "functional_tests/test_orchestration_render_waiting_runtime.py::test_waiting_render_passes_full_checkpoint_to_public_resumer.observe::point-seam-1": "4bd89900255c8a7a17ff42adf8c41aa703bcb23d3f8ea919860af0a905a06694", + "functional_tests/test_orchestration_render_waiting_runtime.py::test_initial_render_read_outage_preserves_admitted_wait_without_a_task::point-seam-1": "1b2a02f8e873debbb0cb3d647a41275e1dedaef78e22c3cc14f2867b1e313795", + "functional_tests/test_orchestration_waiting_continuation.py::test_lost_claim_acknowledgment_reconciles_exact_submission::point-seam-1": "20e7660c38676cb2ced97f5c9e4d7f599b0d2965fb3a565bd2a0480d7c4c7d13", + "functional_tests/test_orchestration_waiting_continuation.py::test_racing_claims_have_one_cas_winner::point-seam-1": "dd60031f4d7d0e9e3773355958af8960ef3162042eeb1f6dc13fa610614d51b8", + "functional_tests/test_orchestration_waiting_continuation.py::test_cancellation_after_run_cas_finishes_without_dispatch::point-seam-1": "8f55835a1dc4d1a3d01b5dd18e89585119c7fb4115d590da9d69b42b36b646fa", + "functional_tests/test_personal_identity_apis.py::test_raw_provider_error_is_not_returned_or_logged::point-seam-1": "be128874e8b59af58d2902847237bacc1e5b0189137cae41ecdf4702dc4bc43d", + "functional_tests/test_prompt_variable_knowledge_fill.py::load_service::point-seam-1": "4733923bb3eb24aa55bd01ca8f0697051908dd12ee53722e3a09e3f3557136d1", + "functional_tests/test_public_membership_apis.py::environment::point-seam-1": "373c32d15676464d8221df458fcb27842051c7d82f474e4aff2153dcfd27c7b5", + "functional_tests/test_public_settings_apis.py::test_a_storage_failure_mid_write_is_a_data_free_500::point-seam-1": "7792b513be29ddea364c9b71c7d187f87a75d54a0bb9abfd2af0e49e01e60e19", + "functional_tests/test_public_settings_apis.py::test_an_unexpected_failure_is_a_logged_data_free_500::point-seam-1": "920c4c511207409144cb4cea8825c38680dc15a4df0a0e9251c9c4be9d6a3148", + "functional_tests/test_public_workspace_document_write_guard.py::test_a_lost_response_is_recognised_rather_than_retried::point-seam-1": "766e1732dccce4e2298f9516d841a444c9d6a886bc9aba2a65d87442ae51810e", + "functional_tests/test_user_plugin_bulk_save_id_preservation.py::UserPluginBulkSaveTests.test_missing_legacy_graph_id_is_rejected_before_batch_mutations::point-seam-1": "466b260f8df46b1c9959a2d2cdb094933de88b77b69b7da54b975b52e0980414", + "functional_tests/test_user_plugin_bulk_save_id_preservation.py::UserPluginBulkSaveTests.test_non_missing_storage_errors_are_not_treated_as_absent_legacy_actions::point-seam-1": "466b260f8df46b1c9959a2d2cdb094933de88b77b69b7da54b975b52e0980414", + "functional_tests/test_workflow_assist_limits_runtime.py::test_the_store_reads_a_document_in_its_own_partition::point-seam-1": "3e7602d2993d0c14d6bf73fd3f3d54c5e0b66362de388bf954ceeb7316f21463", + "functional_tests/test_workflow_assist_limits_runtime.py::test_the_store_reads_a_document_in_its_own_partition::point-seam-2": "95f65b44ebb40ecf0b483653ad7f0f5903163f121d679301d21a84fc159871dd", + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_store_that_cannot_be_read_is_down::point-seam-1": "b110efaaea3384de8e7621b2eeaa6aadc01fed8d6b18c7875fbc9ee3cc4a04a2", + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_create_that_finds_the_document_lost_a_race::point-seam-1": "68bc72a295e20ba2658869b3265e62d5d1d80ea5ed85b9821deb8389315a534c", + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_create_that_fails_otherwise_is_the_store_being_down::point-seam-1": "48c5e19f1ae1f4917731fb1a43f8ea426d8522baf8ef677acdbede51f841dead", + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_replace_that_finds_another_write_lost_a_race::point-seam-1": "ec2cfa2627efc422217a411d65f137119a25aaf0a3b971ef2a186072c3755efe", + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_replace_that_fails_otherwise_is_the_store_being_down::point-seam-1": "8ab19a169a3f7e5a7aaba5b35f08e969e04cfb56c6adbcbadbbe0a8a247fc4fc", + "functional_tests/test_workflow_chat_delivery_concurrency.py::_barrier_first_run_reads::point-seam-1": "6153bfbc4347f43c269e039d85749015a1542abf63521718cdc0eaba8a4f3341", + "functional_tests/test_workflow_chat_delivery_off_golden.py::_capture::point-seam-1": "20800a059a73612425d69f9db0ebdedd1dea174c7ccddf5ae111a8d0ece97a5e", + "functional_tests/test_workflow_draft_service.py::test_a_failed_orchestration_count_fails_closed_wherever_the_cap_is_checked::point-seam-1": "7c3d38086a4008776603de7fe20aad1e8cfbdd24d289fdc0819350c5ee33aca5", + "functional_tests/test_workflow_durable_analysis.py::test_run_deletion_fences_never_prepared_and_existing_analyze_work::point-seam-1": "9c6bfc739980ceac5721fcdd90130815c26970470a3912ef8658e8a36a96db1f", + "functional_tests/test_workflow_handoff_end_to_end.py::e2e::point-seam-1": "e2c35e481b335a835e185bf1cc5b454488222d357f8dd4da79e6be33802cd49c", + "functional_tests/test_workflow_plan_replay_routes.py::test_a_store_failure_is_a_fixed_error_without_detail::point-seam-1": "b03c530b2928cf04ba8f312f1a5efaa38585aad4dc065e08d98669192b677262", + "functional_tests/test_workflow_repeat_recovery.py::test_lost_acknowledgement_does_not_duplicate_transitions_or_grants::point-seam-1": "4e05f3a8eaeef7b18b8d6e1be567beb8c406e8d581fdef83c1ab5669985daeb5", + "functional_tests/test_workflow_saved_output_artifacts.py::artifact_services::point-seam-1": "2e410d511a8651a63b80437a7522973585c2d952d7a9a1340de6a14e177f953d", + "functional_tests/test_workflow_saved_output_artifacts.py::test_lost_acknowledgements_reuse_the_prepared_bytes_and_address.lose_message_ack::point-seam-1": "2890bfdfb2f08d9429c878adb41f10902239b2f89f0c42fcef830bd4e0b6b324", + "functional_tests/test_workflow_saved_output_artifacts.py::test_lost_acknowledgements_reuse_the_prepared_bytes_and_address::point-seam-1": "fd04b1fdfb6dc1218b28b07ab0c7984ac193e88446a174bdd6ca077268c9604c", + "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_delete_during_the_save_is_the_same_409::point-seam-1": "11df306eac15f712de0b0918b56472835dbccece35be2b91c97a02e43e6bd642", + "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_transient_read_failure_is_never_reported_as_a_deletion::point-seam-1": "d13cd1900a1a4d0d7a4ea8deb22a2c848be4cd71dd4ed9b65e4c98fed58b1ad4", + "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_lookup_that_fails_once_keeps_the_existing_conflict::point-seam-1": "a65761664076730a428a8819bb7517483b5ae93aad589c41670cfd74774f9d16", + "functional_tests/test_workflow_structured_flow.py::test_v3_analyze_writes_retain_workflow_and_native_guard_fences::point-seam-1": "4e8d69da1be95c3cc2c276894841c08a3418f85e84324e55107697bf04bba67c", + "functional_tests/test_workflow_structured_flow.py::test_lost_decision_acknowledgement_does_not_double_admit_or_change_choice::point-seam-1": "0c097af5e776e145a70cf76ff20e646d056cff9492518df13c3a9d14f59ad571", + "functional_tests/test_support/document_analysis.py::document_analysis_runtime.screening_container::point-seam-1": "1562d317edb1247b23cdefb4be192b669c6540cd42bd16f4ad4a175826fb1568" + }, + "source_review_baseline": { + "application/single_app/app_settings_cache.py::_read_cosmos_cache_version": "9807a5a3af43768c0f13e16766448e020783b76aef3c974bc915e510c5b174c6", + "application/single_app/app_settings_cache.py::_get_cosmos_cache_entry": "dea14a891613aba100ad1ece813ea5dc7a3975d6d2298235aff0fadcc4d0a353", + "application/single_app/app_settings_store.py::AppSettingsStore._read_cosmos": "56597c9f9be5567c646e0dfff7123209205054b9bd512c49db3175dd05060fb5", + "application/single_app/app_settings_store.py::AppSettingsStore._write": "d211afdc1a48792598479fe6a2f216f41e6c2929df544d46f796ff8410a52a82", + "application/single_app/background_tasks.py::acquire_distributed_task_lock": "96acb8f99f87eb710ca72f6d0cf05265ff72e8ab5fb63d851074742098a71da9", + "application/single_app/background_tasks.py::release_distributed_task_lock": "a625bff11adba5becc4a58831d6715a0b90812f0e5b2c4b4cbe4e57afe72fa98", + "application/single_app/conversation_memory_runtime.py::resolve_memory_context": "bd5d1887e75be3047ff78cb0d7aa431cf38f53bbb16eb94a2ffa791ba2ec2d2f", + "application/single_app/conversation_memory_runtime.py::resolve_m365_memory": "c46a93c135fe6f55da1a1e883834708544439a83d6a566a22cf08639df9ee0cb", + "application/single_app/foundry_agent_runtime.py::_collect_recent_chat_upload_file_inputs": "0336dc2e7609706fb2958378324a0055120a6b05317540a9679b97b235535ca0", + "application/single_app/functions_action_catalog.py::_stored_actions": "aba84bb7ce5b1ebe875bbcfdded7b6b5b24375f75d2691598929a4b3e92fb45d", + "application/single_app/functions_action_catalog.py::resolve_action_manifest": "f01c80cf5839e08a8371a31bd2bbfb506b3571d20be25faaf58dc3ce29f69170", + "application/single_app/functions_activity_logging.py::_create_activity_record": "50d0b535cfc55173fcc55bd71537691e7fd3db09016ce89ae7b773fbc26e67f8", + "application/single_app/functions_activity_logging.py::get_user_login_activity_summary": "7e9db505a3220eb5fdd4f5ef4dc1bfd478958ee27db74a10e61324652245fbfd", + "application/single_app/functions_activity_logging.py::has_user_accepted_agreement_today": "62d39c33bf74a46d29fa636720b792f0fef24efe016343ba9d82e2c1c1cd736d", + "application/single_app/functions_agent_catalog.py::_load_agent_usage_counts": "898f0c7b0ef6a8643ddaa114a6995d1920faa01c92790aec505eaf9a04fc8ff6", + "application/single_app/functions_agent_delegation.py::_read_agent": "98b0527a67765b824cd1624b3f71b181664ccb8a0a8d47cb1b5ffa43767c9db0", + "application/single_app/functions_agent_delegation.py::_list_records": "9b4d4a7d31be42b3b5681de9ff9d8bf834d7c2814cdb35342032287d892704e9", + "application/single_app/functions_agent_templates.py::list_agent_templates": "785b9059d2d6b1359565c202284ad9f8ea208a36e790f9a06cc7af2af61b5531", + "application/single_app/functions_agent_templates.py::get_agent_template": "a79daee0684d9c81bc0deeae07b7c8e0161f39d2ef7cefa0dbb9276f4f826eb8", + "application/single_app/functions_app_maintenance.py::_read_maintenance_state": "932710e6a35a148fdfffa9fb54d296c286f88f8b8897b16c729ae75c2048cc30", + "application/single_app/functions_approvals.py::create_content_screening_approval": "d6052c5c826e5418ed0eb7467cac5a2711ce2cb26be5405893b1010c93d2b9f6", + "application/single_app/functions_approvals.py::resolve_content_screening_approval": "153ed7b68dd8a138bf2f3658602fedf0fa46b4a5ddad78626fa6fa19a151b614", + "application/single_app/functions_approvals.py::create_approval_request": "3f5323256bcf4a5ec2bd4edc156d3aeea20ecd23bc6ed4199aa669405544a6bb", + "application/single_app/functions_approvals.py::get_pending_approvals": "577bad70072d84d11583820cb49e77a53f13a9f3966b6c46857ddaf8617ec0ec", + "application/single_app/functions_approvals.py::approve_request": "bef5fd51a045d8df621d6cddaf2dbc87e4cf11b30daa7104c77c2d48c393c0f9", + "application/single_app/functions_approvals.py::deny_request": "9376f173eab062430572e090f9029a216c89ffcea4e8672ba70df8e132749131", + "application/single_app/functions_approvals.py::withdraw_approval_request": "e845dff3da353c97afef3091f4b6977703bda47966e33097e8d6ed71592a033c", + "application/single_app/functions_approvals.py::mark_approval_executed": "3c2c32d5a44a81052fad877146c713b518cb227421a640e7ca1573c3a1bf03ca", + "application/single_app/functions_approvals.py::get_approval_by_id": "cabbb18329053cc566f7394493be93ca60e292bde5ec195ffc5bff268094f03b", + "application/single_app/functions_approvals.py::auto_deny_expired_approvals": "7c676bd432fc6b5555f969f71b6f8cdb0ce826d1133f53249a37d7f8a55d8271", + "application/single_app/functions_artifact_publication.py::_authorize_artifact": "43ac0f1e6af3796dc37c6dcef1d2fb588f94d93ac23315635bd6ddb2733cd08a", + "application/single_app/functions_artifact_publication.py::_receipt_change": "56a9693f65d564f785022c39c81eb72622d90b6985ab53e8ad4d3d004f6c7f78", + "application/single_app/functions_artifact_publication.py::_destination_document": "2952174da5c83f17cf77058b53622ddffc463a3df8abce3a495b6151dc365097", + "application/single_app/functions_artifact_publication.py::_notification_exists": "cc04ff997921643e6530280f847980ff92bd16a76f5bc5f07ec0632b2ca711f3", + "application/single_app/functions_artifact_publication.py::authorize_publication_status_read": "38721b80fa6ff735230e1ed4b3774c4d169c6a3fa5139bba4562af026c2e4a7b", + "application/single_app/functions_artifact_publication.py::read_artifact_publication_request": "22104c95006040beed1d80911d5cd7a4ac7fe30e76f4e7d2215f5008a0101b6f", + "application/single_app/functions_artifact_publication.py::enroll_legacy_artifact_publication": "dd975ad787e7c3968304fa63a8010eb23bee72a5765ffc41db1ea768bd1f0dcc", + "application/single_app/functions_artifact_publication.py::_decide_artifact_publication_with_content": "7cd4a5a43540b1373b59175f232e2483bcee95bddf9ada140516d8ca10934b90", + "application/single_app/functions_artifact_publication_readiness.py::_processing_change": "9bda63a43d0f6bbe001b73af26c10f6486c142fe65494c233bdc91533a55561d", + "application/single_app/functions_assigned_knowledge.py::_query_documents": "6cfc73e2861b636fdceb44ed311286ead984eef3010806e15ac327bb3831da50", + "application/single_app/functions_chat_content_review.py::persist_chat_reply": "4240e30b7f1a3c1256518dd69a8bec339edf874c9df58aec0cf7a83bc706bc93", + "application/single_app/functions_chat_content_review.py::refresh_checked_message": "178ec09b9f06b6bb6eb74adcbbd7ccc49934e84309839e9f8426cae02f1dc58d", + "application/single_app/functions_chat_content_review.py::retracted_stream_payload": "b85b2dd0577226425be62068f010e487ee92a9b5371e94e47dc9253fbeda6ba5", + "application/single_app/functions_chat_content_review.py::count_unchecked_chat_content": "ad4cd705e9a5316928adc3b98f85cdff1d64c5035561233962898e6dbb19a8c8", + "application/single_app/functions_chat_content_review.py::recheck_chat_message": "80c82d703a8953645bc28a997b18fd56e38d15df5fb97991569ab4bf094166ec", + "application/single_app/functions_chat_content_review.py::_clear_conversation_projection": "87256fcc6fd1385dd3ab6f7321c64b5e27f269e4d3d08d9c652dabb1e1e4f44f", + "application/single_app/functions_chat_content_review.py::propagate_chat_retraction": "6e15bad8550a21ca03fa61d10826025620c504f0d454e7be6b1f54517a24e28c", + "application/single_app/functions_chat_message_metadata.py::patch_message_metadata": "1ac4f68a384e77afa49a655e76e61b33779a8f68a46712c440ade40c0e544e04", + "application/single_app/functions_chat_retry.py::load_owned_retry_message": "f428dfdc38f8fb4889e3f110cec43a2c964eb16ab4c49f4cd19263dbb101cbd4", + "application/single_app/functions_chat_retry.py::retry_source_user": "c98dcecfed6d77a2526edc0b1d343d9de85726a5b97b4f182adb50b23f81a6e1", + "application/single_app/functions_chat_retry.py::retry_thread_messages": "cd673c851a02f8524cd59c888eb6a32a0e7c15674915987d24968c40daf6de55", + "application/single_app/functions_chat_retry.py::reconcile_prepared_retry": "270dbedba98ebd1357fac1eb709744aa478e65996e2fa8abcfb1ad34ec7f6a33", + "application/single_app/functions_chat_retry.py::_publish_retry_attempt": "7ec917d171d91e3fa32281c49163e46b6980c828dd434c4cf92b79241f232c16", + "application/single_app/functions_chat_retry.py::prepare_retry_attempt": "5b9a93ccc34ab2db33f29cf69e0420e5d95d6a41478a3766afb2a2dd5bd96d78", + "application/single_app/functions_chat_retry.py::claim_retry_attempt": "4752adacc06eb7f8a0a939d98d85e36f849498f067362076383f56c3c14003da", + "application/single_app/functions_chat_retry.py::set_retry_attempt_state": "4e4ac5134b028ce986305f34eff2985b686ee419886332e75cbd2ea5d54e6fd3", + "application/single_app/functions_collaboration.py::get_collaboration_conversation": "8dda60d666bcd81bea1bf9a67db86240841f69817e5a91a2bb774cf6f2e1072f", + "application/single_app/functions_collaboration.py::get_collaboration_user_state": "e25b02d70290b74a34d1cdb3b7fa5f69b9e3ba2993acc272d528eb74773af291", + "application/single_app/functions_collaboration.py::get_collaboration_message": "1eaaf2b3c0474cb4bdac09c3d3706ef93946d240fe87d6188b542c3adccd07e2", + "application/single_app/functions_collaboration.py::get_collaboration_message_by_source_message": "51dc4583502910825c283a0658d7f07a6be986bcc69a0639873c28ebacf68c53", + "application/single_app/functions_collaboration.py::_get_collaboration_source_message": "f0bf42f10013d7405515b8ec6c7660904f2b48262bbeab2459b33aaa5b5e0ee9", + "application/single_app/functions_collaboration.py::get_personal_collaboration_conversation_by_source_conversation": "9f81788a4b5c1819c8ac70323a6f2a37639f729019b638b882fc8ef5470aa38e", + "application/single_app/functions_collaboration.py::ensure_personal_collaboration_for_legacy_conversation": "6995b0522a49766d95a2bf48e6ccac912d8d7dbe418c81acc6ed0d861005b807", + "application/single_app/functions_collaboration.py::ensure_group_collaboration_for_legacy_conversation": "86ced7807abaa15dd43926834ee85cc7676cefede233b7a39a653a12ab6b2120", + "application/single_app/functions_collaboration.py::list_personal_collaboration_conversations_for_user": "81cd0c21b5f65e014dbb09833d0d75664a4b9032f50de20cc63d0ae5a7294f36", + "application/single_app/functions_collaboration.py::list_group_collaboration_conversations_for_user": "ea82606621ef81d790a5efd784afb85fa6f899930111f1bd258175d5d171baec", + "application/single_app/functions_collaboration.py::list_collaboration_messages": "d04f154f9e9d3b8e8552ac14cab3aeffd38de516a0e3f735eef5f7717f1f601d", + "application/single_app/functions_collaboration.py::ensure_collaboration_source_conversation": "8a500d8c97033688e78319c0ba543082768262ea45c51332dceaaa88c24607ea", + "application/single_app/functions_collaboration.py::_read_linked_collaboration_source": "98413a04d546341c4b47f6a7426f03c47fe0829bd5b86d665cbaf666bd98e105", + "application/single_app/functions_collaboration.py::_cleanup_linked_collaboration_source": "1815a4b32c85034b9cd6d7881d07e66dddf43ba42a97912a140988080606fb74", + "application/single_app/functions_collaboration.py::_delete_collaboration_conversation_records": "f8020240437e141250a65c99f3f73c41e83a6c8aaf8335cf8bbbf40324024825", + "application/single_app/functions_control_center.py::execute_control_center_refresh": "065c8d8282a45e12f5b6bca8dd0f43db460bcf160aef49e629e4238ba724a716", + "application/single_app/functions_control_center_activity.py::query_activity_rows": "f41fd14cbf03cd85c0b5b0d853c742e099011097c50b89cd8c54d5ab8278fc05", + "application/single_app/functions_control_center_activity_display.py::_lookup": "9fd0065570fd02edb4e8e3717464de5bee8681594506ebf92586ee5767bd5be5", + "application/single_app/functions_control_center_activity_display.py::search_activity_people": "dedb79a8e910dac3324daed68ce8ed23247aaaee54ca48fea556a62c27421533", + "application/single_app/functions_control_center_activity_display.py::search_activity_workspaces": "6087e2a186e8f147d7a1aad7fce3962c8acfb3e5cfc8138b69658e8fd2ce4a02", + "application/single_app/functions_control_center_dashboard.py::query_count": "e85d1c9c377fa760cac8dda0deba43c790ad00616c92daa36c60ba5b696cfbb2", + "application/single_app/functions_control_center_dashboard.py::count_active_users": "6563a2e2d260f7e56994fd647d91dab6d797160666b1e6459431c27359ba78cd", + "application/single_app/functions_control_center_dashboard.py::status_rows": "3ae5ae574d3ee0918afb1c9bd2bfb0826fae06b22e0702a8e74d3e44a6219e7a", + "application/single_app/functions_control_center_dashboard.py::token_total": "92b68af814626f9e1af266c31d9d65964b770a326650485e15de6ebbfdef44cc", + "application/single_app/functions_control_center_dashboard.py::aggregate_token_usage": "e0802712a09b12bbe4b80d1b49bbc1f39978ce91c47452c20cffc5bb8e6f248b", + "application/single_app/functions_control_center_dashboard.py::_activity_rows": "868e77b0191ef050a93a01e4b221cdc8e845e8c0b678a622971bb37665bc5e38", + "application/single_app/functions_control_center_dashboard.py::resolve_entity_names": "a6fd3983cc95dbb700b12ad6ce86facd192a671a03a2c0c97debf7a3dd9d25fe", + "application/single_app/functions_control_center_dashboard.py::find_entities": "146dc66aaf316a6c99c929ef5c576bdd9cfe00ba8107a347e4bb6e88d5e6acc5", + "application/single_app/functions_control_center_groups.py::load_group_inventory": "75ad863834ec9b6999fc2055c11cc313f00cd7eb7d43b113af4489f826af1e33", + "application/single_app/functions_control_center_public_workspaces.py::query_workspaces": "9392a9230ca0ce14a84ea87f6dccaea870fe49b39061db3be748eee4a150a9b0", + "application/single_app/functions_control_center_public_workspaces.py::query_workspaces.count": "bb2fa31a60018eeb97e3ccce9ad2285fa760cb9b063b579e5d13c09607d090e2", + "application/single_app/functions_control_center_public_workspaces.py::select_workspace_ids": "9f7469a1174dfd287e4fc67dd698b05874cbdad90564d61075e1c6e47a364a4c", + "application/single_app/functions_conversation_metadata.py::get_user_info_by_id": "ea23cfffe8bf58c0d748f44f28da02373fad58742e4a44e0ffe4f1226bd01636", + "application/single_app/functions_conversation_metadata.py::_get_conversation_item_with_source": "2ad564b263a2b5e3fcc0f9dd4a20340b72016a5174f77d0ff37c79608526fdb3", + "application/single_app/functions_conversation_unread.py::mark_conversation_unread_guarded": "54460724dbc0d56d2b77baf55db436d2443cdec8b7e4a19268ed7000f244ce06", + "application/single_app/functions_cosmos_stale_cleanup.py::_query_stale_cache_cleanup_candidates": "527c1da102010649ea00d3cb93fd2e337144e3e3c4a7b091707180ff27087b87", + "application/single_app/functions_custom_pages.py::_list_cosmos_custom_pages_source": "f528c38d8a8d056f99ed039f42a5da8545b6b264efe349b2e6587ca1f535477d", + "application/single_app/functions_custom_pages.py::get_custom_page": "83cd6e736174f457983ad4ee3ebeb17f713588df34417d7e3bf0e88fb2e47b37", + "application/single_app/functions_custom_pages.py::save_custom_page": "bb5a805aaf37a1e56c168678fef600004052dbdd83fdaeb7f76a5827a59851e1", + "application/single_app/functions_data_management.py::get_data_management_settings": "b67c66bbd54e859294f5cf74e9d0cd59a93c07df77b7f39391cb30f516b56dd4", + "application/single_app/functions_data_management.py::update_data_management_settings": "832b401e6cb5bf56f89e3763091d1ad9362a3c31d1014add4015511ad700c0d5", + "application/single_app/functions_data_management.py::generate_data_management_encryption_key": "a258a0cf7e77783aa2916b5a7aec421c562097a2ad43d58f6ba68b289c93e913", + "application/single_app/functions_data_management.py::_get_completed_migration_baseline_candidates": "54651f049e8a9516161fdbce46c8db7ba4a6d3ef811fa204cee4d29135f58be0", + "application/single_app/functions_data_management.py::_preflight_target_cosmos_migration_access": "691c65a45af3fd3333d6bad739064548df4d7f80f0984ae7b23cbedae7816596", + "application/single_app/functions_data_management.py::_iter_selected_cosmos_records": "5f0cc1efbe682b23a921e8489eba6c0e300b70f1e58decc9e3767ba1fc34e501", + "application/single_app/functions_data_management.py::_iter_selected_screening_records": "da94c5d3229679eed43d70dc4ed4d13302b48714588b6bc86744e2915ec01d0c", + "application/single_app/functions_data_management.py::_get_target_cosmos_document": "11628d7cc290ff59ef13e47b704045a98a7c9876967a6f591eedd60fcbc4a724", + "application/single_app/functions_data_management.py::_iter_target_cosmos_records": "3b88efc919b65430d7f0208e104d87a42a7bac096fd801dc97d4444b70322442", + "application/single_app/functions_data_management.py::_source_blob_reference_exists_in_plan": "cfc5be953d0e6428bdb972c77c5cd122a5f57671d29269417c7a25ab20bd7827", + "application/single_app/functions_data_management.py::_validate_mirror_deletion_candidate": "329954557985f2c3cc755b0d486622034476de561da0dbc9597677f1cd1b1d2b", + "application/single_app/functions_data_management.py::_read_job": "b2bf37417ccff31d46065b9db05086288c75f8555b55c70c6dd7539d971db475", + "application/single_app/functions_data_management.py::_renew_migration_destination_lock": "15e530fe78c81d1f752e5f6a3dea70756a542a98be75fbe540639305a01a5f99", + "application/single_app/functions_data_management.py::_renew_backup_source_lock": "31ea462f8fdb189808c729615c2844691ae4e555780b75cfc0cbf16d2c98bb41", + "application/single_app/functions_data_management.py::_replace_job": "b67c5f4635ed100a9bda55796d183e2a81ea8f5be6a70a9fbe3345366461c434", + "application/single_app/functions_data_management.py::create_data_management_restore_review_authorization": "0a57bb19741937b2ae36ae53fde0aeff68d5a1aa276c5c2cccb8271a092e10b5", + "application/single_app/functions_data_management.py::_read_data_management_restore_review_authorization": "e74efb38def435609235299b362a283336ec63a600d22e0a9f2157b1f1e9b490", + "application/single_app/functions_data_management.py::release_data_management_restore_review_reservation": "95cd51dd5ed238f2b6e31ffa978e08efdca6f9f1e79ac1a526fd410fa26e2cad", + "application/single_app/functions_data_management.py::_iter_backup_manifest_entries": "e1fd63623aa090d32bbb2f995fc8fa67bd56e45bbd1b59a5678368e2f8cf554d", + "application/single_app/functions_data_management.py::_target_cosmos_container_has_records": "76ed8f029dca428f2181207cca3246bda19ca4ad9e64be1fa7008921def57b41", + "application/single_app/functions_data_management.py::queue_data_management_job": "f8b52dcf8f811cd45fd9ecf4f8504d3f239c38e0c47456285ec81feace6ae9b8", + "application/single_app/functions_data_management.py::_query_data_management_history_items": "24f94d1e4a9ee1b2e29c49155402123253c8c24ef22ff439a9025d86c786b293", + "application/single_app/functions_data_management.py::get_recoverable_data_management_jobs": "d5fcf5ec78897cb181c242257224ff40c82454fd20f7bcea535ce2eb930e02fa", + "application/single_app/functions_data_management.py::get_data_management_job_items": "0b5d29763ff280e1dbfcf2a0c919db018418eebea94b098ba7d7d6456c14395a", + "application/single_app/functions_data_management.py::_get_latest_successful_full_backup_id": "ede1b8ef7b8afc5983f84fc5f4bded047ea302485e550eea826058831a32dadd", + "application/single_app/functions_data_management.py::_get_backup_retention_candidates": "6f5d7485687f69d466379863cb78b71a7a8dba30d6abb8842392f44612d6b9b5", + "application/single_app/functions_data_management.py::_record_backup_retention_cleanup_run": "e32e1f8ad440d455ec2d0e23ba4514a0491a64200569b55b991dc7ce210472cb", + "application/single_app/functions_data_management.py::_query_migration_catalog_count": "29aa78c98aa03ed7ea17f942a716f0cd23f0a284732dbb1dd3f4f36714335058", + "application/single_app/functions_data_management.py::_query_migration_catalog_page": "0ed22254f0f006300c954097327207de50ce03982fe36bcd36641f3f8e3a9a40", + "application/single_app/functions_data_management.py::_count_documents_for_scope": "1fa8a5f048e7809bb3ed41484f52fdf6297fbdd5bbe587f184743348b849aee6", + "application/single_app/functions_data_management.py::_count_migration_scope_documents": "9dcaf39f5212dda6ccc9b2f63d460829033c513ea6a22c1753dc1f1f1927c38f", + "application/single_app/functions_data_management.py::create_data_management_migration_review_authorization": "0b192697cc5c6ff817d7f30214f69dbe5ed20e0cce507f28af64ff892de703cc", + "application/single_app/functions_data_management.py::_read_data_management_migration_review_authorization": "4d3118b9ebbc21d1fa93078c8a95cce32c40e6ea586a7aba24e3fb8eeb7529b4", + "application/single_app/functions_data_management.py::release_data_management_migration_review_reservation": "fd7930c4514d8111b1d516ff1bf111de6b597d00f79a6b75c552b11f7cb20150", + "application/single_app/functions_data_management.py::resolve_data_management_migration_manifest_item": "c255815401da8055cb33c0a5237cfc2cc86147aa80f9daa0e1e2486bb2d5b753", + "application/single_app/functions_data_management.py::_write_migration_manifest_batch": "69ae5c3e18d62fdadb0837653da9903bce96600f151d9592991e267802996410", + "application/single_app/functions_data_management.py::iter_data_management_migration_manifest_entries": "110f76ac844bb298294bd7514932df512fc60f49306201dfa509ccf5a546ff7c", + "application/single_app/functions_data_management.py::_write_mirror_deletion_candidate_batch": "f78ecabfa1622169c765de539413f1df34fd8578c822c41ec7ff5deae0e561d1", + "application/single_app/functions_data_management.py::_iter_mirror_deletion_candidates": "ff634f32a5b21a7607c9faf2070700e49e8bb99428690b44a7ed22ef616d3609", + "application/single_app/functions_data_management.py::create_data_management_job_item": "131ac737b923b55febe66e85aa1721c9590c53630368d0c7de6181426a606ef6", + "application/single_app/functions_data_management.py::query_data_management_cosmos_editor_documents": "730cd53aef03e6ac6ceb9ef5c4fdc14f47ac45d2686d093dde1d6d024f4526bc", + "application/single_app/functions_data_management.py::get_data_management_cosmos_editor_document": "ff04a48b410d179bd1017026dde26f5937bd4f119306d3cfa57277d8ac1a6bd4", + "application/single_app/functions_data_management.py::save_data_management_cosmos_editor_document": "33d38b01069c46d9e115fdeb47fbcda995bae839013468cdebd9ff4f571f6605", + "application/single_app/functions_data_management.py::_save_data_management_job": "e4c89cfbcef9f71b45fd6cc6ace3f95223abc13107ab4620af05098c2bc26b67", + "application/single_app/functions_data_management.py::_iter_cosmos_container_items": "5da5117b6aef54e32cc346f70b02f17474ab7e03d9cf88265632f4776a76f08f", + "application/single_app/functions_data_management.py::_can_skip_unused_screening_container": "42b6eedad04ca79a0595f060fc0c2ffcebed67b8562bb818a2879970b87b1931", + "application/single_app/functions_data_management.py::_read_backup_latest_item_state": "5f08f9f9164ecfe743b54c611f6cdaddb45095e91a3c53a3a849f635ebb0d42d", + "application/single_app/functions_data_management.py::_record_backup_latest_item_state": "5db63e43222a6e9f7030b2a901eff57fd3a7ffb7c9577e83b7829a89741b945f", + "application/single_app/functions_data_management.py::_sync_backup_latest_item_state_from_manifest": "da7d2e53b391394815a3b2fd4484b8aafcea6073fcca60faf1aaae2639fc70fa", + "application/single_app/functions_data_management.py::_write_backup_manifest_batch": "d6090600df531ceeebfe00f8a49d6f75009497133aa4f7dadbdc61ab41cce435", + "application/single_app/functions_data_management.py::_iter_backup_cosmos_source_items": "e8b04d8f1a02f5c84a8b8164844cccbf799405d9364e2cccee6dbdd0c01b9072", + "application/single_app/functions_data_management_search_write_fence.py::_read_gate": "fc002ccbcc7d8d55ebf8239165585470136c964b2f80bc8aca9281ec7b2e0c7d", + "application/single_app/functions_data_management_search_write_fence.py::_create_or_read_gate": "ffb90b09341ccbf0e8d77e41f95af5cfcde74453d0ce59dd2a0f0404631a152b", + "application/single_app/functions_data_management_search_write_fence.py::_replace_gate": "d00d1fc6c2095c864d7aa3171aef5faf21bf8758c737ea6ab201a638a273225c", + "application/single_app/functions_data_management_search_write_fence.py::_read_target_migration_coordinator": "e2065d4aa4740f90bd3ea0650b11272d691d29245e2356171eb51b12d4973a50", + "application/single_app/functions_data_management_search_write_fence.py::_replace_target_migration_coordinator": "154acb528002e5ee5088dc92cf5425243cc6adf72595713b483f3501d53861f7", + "application/single_app/functions_data_management_search_write_fence.py::acquire_data_management_target_migration_coordinator": "887d06d4e8676ee29fc0f0938760a4f81a27ad174e1676901f68076d4248d09f", + "application/single_app/functions_document_access_index.py::query_items_with_cosmos_diagnostics": "f0a2e03ac62e5bd7bc6dbceb13732515991a3e96f4cac29f9d518ab6971b3b62", + "application/single_app/functions_document_access_index.py::_resolve_document_access_hashes_from_projection": "0321794ba92b72e3ed9262547104cc6a38829fa06cfd40ebf82992f37cc42078", + "application/single_app/functions_document_access_index.py::_resolve_document_access_hashes_from_workspace_container": "5a8da9076dd8286632f0477e5bdbee711315c15cb5c410eacf60e1353280564f", + "application/single_app/functions_document_access_index.py::_resolve_document_access_hashes_from_user_settings": "707527d1c9495022b3e73a0a738091f0e98627daba6a635962fa918121726321", + "application/single_app/functions_document_access_index.py::_query_existing_projection_rows": "914eec59f328a80fe3c48a007fd16f413d2ca9d9a7a9461af188162c131d6c72", + "application/single_app/functions_document_access_index.py::_read_shadow_validation_state": "3d90d4ae362059fd20e5f53b08367e1e756a3143d037d7eca5224fb6c8d86d0e", + "application/single_app/functions_document_access_index.py::_query_bounded_projection_rows_for_scope": "1b03e6216017bc57ec89cf73aaadc78d6008d5b9e703ff2009d17582e1e8cf67", + "application/single_app/functions_document_access_index.py::_query_legacy_projection_rows_for_scope": "eb47ce78bdcc334f8b4450d48fd77e6815ec361bffcb513d5ecbc3c974a234ec", + "application/single_app/functions_document_access_index.py::iter_document_access_index_candidates": "5b12fd31be8f0ce70648f8a396a5bc9f2a05de481ca72d92366d971dff31e2e5", + "application/single_app/functions_document_access_index.py::_read_repair_backlog_state": "9db7358f270f70efa2f32d03d786acc72f65b3022b961a1aa9c37ec7e1fc616f", + "application/single_app/functions_document_access_index.py::_query_repair_backlog_exists": "9d59c725c42b1eca8b999639dfb52d97b9e24bbd439f4ae4bd2a6f34b21986b0", + "application/single_app/functions_document_access_index.py::_query_first_page": "458d85488207908caab5231c3e4152a57f69c12d447e5895d0d28c53bf5495cd", + "application/single_app/functions_document_access_index.py::_read_backfill_state": "de1b280d3acbe90445b9b5cd8a19aacbde8d128ea8d47d941f90b631bafeac35", + "application/single_app/functions_document_access_index.py::_read_source_document_for_repair": "1a8ed5d8848e47db7cc096bf05a52788beb2af52d65bf1aa1dbe3eb84aa3c190", + "application/single_app/functions_document_access_index.py::count_document_access_index_repair_documents": "e599cb3f279ec90be2938502368f24ebc7d916577ca18edc0de05c5a8a1c521e", + "application/single_app/functions_document_provenance.py::_read_conversation": "f7748a80784d0254864dc3ec55fbff8c1ecd357b5ba2568577a141806bf971e0", + "application/single_app/functions_documents.py::_upsert_document_and_sync_access_index": "669d006bc89d04f974fa5d352191ad3480462e5e8eee67c92ed109085e19a55b", + "application/single_app/functions_documents.py::_get_document_family_items_from_document": "0596e1d131369dad92fe839e00e3d3db1660682fbf32294cab1525f06908d64c", + "application/single_app/functions_documents.py::create_document": "6e11070763076f28c4cd13591c5acb8bb65d1f73ab61463042551b267258169c", + "application/single_app/functions_documents.py::get_document_metadata": "82994ffe86b9bc22683cb80f538f6642e70c246479fa59a59dad0c61053ce3d6", + "application/single_app/functions_documents.py::update_document": "edf2db45b82d8c96e5c250070d94e4d8457b1a6ca7efb2cb5941eb2c58d83382", + "application/single_app/functions_documents.py::get_document_metadata_for_citations": "554f1b6a717b67f8625e171f82473f1f5e4edc029de0e0389389fec8ae406f2b", + "application/single_app/functions_documents.py::_rebase_document_after_fenced_acl_projection": "3b88a923c818e4b10a4fbee6860ac527a374e28814e7783955dcb547eb66b2c2", + "application/single_app/functions_documents.py::_read_document_search_sync_record": "307a5e34bacaf5d637d9c6b1024d5124aca2fd996c9e79d57637e73d9bedb7d0", + "application/single_app/functions_documents.py::_replace_document_search_sync_record": "1e0126eaeeb484ddf36896093c480548c681d1a73b902559e7a1eb747d99a49e", + "application/single_app/functions_documents.py::request_document_search_metadata_sync": "bdd69e6c4bdefa2ab5679bd4b32b1b583670787cc529f4c63e50add4aa504c22", + "application/single_app/functions_documents.py::_read_document_for_search_sync": "b860ead3e324bc8917be1be3199a67d29d110d3d00d9c097f1eb0921b9e0f30d", + "application/single_app/functions_documents.py::process_due_document_search_metadata_syncs": "0002037c010cfd66e3e89d78e8b43fc3625fab08d1ace6592cb832a8f2a62ee6", + "application/single_app/functions_documents.py::get_document_record": "a1cf4d46071ffe27c390dc429996ff7855c5dde408dd4f2626b558923d11f876", + "application/single_app/functions_documents.py::get_latest_version": "68e362e47dd81ca8820c13ee502bc809cabf960ab1ed66dcea19355ea60afec0", + "application/single_app/functions_documents.py::get_document_version": "58406c0cf5330598ffd0640fb5db52e4091740f34a5d4ddf2d09afe505f52efb", + "application/single_app/functions_documents.py::delete_from_blob_storage": "f41d2e24ec43c5ae8b446f8d3f916295b3af8befe72098df40660a769f01c350", + "application/single_app/functions_documents.py::delete_document": "d8775246eed09ce6e072e53bb8ba3e4471777bde87ad149e4af98b0009f8c8c2", + "application/single_app/functions_documents.py::delete_document_revision": "ae9b71e625a14586f88257cbac161d19775da85394502eac4320a17ea0ddfc12", + "application/single_app/functions_documents.py::get_chat_upload_workspace_documents_for_conversation": "bf54d73a17b5c44e3f42746744d6d87a57f9e8fb34d36e96e41de1d9c4eb800d", + "application/single_app/functions_documents.py::get_chat_upload_workspace_documents_for_collaboration": "1283fe96ad66fff2a985f20f6c7f67e0e1ad09b9d58974b4e89f4415f665909f", + "application/single_app/functions_documents.py::get_document_versions": "e2104a3828bddfed2a0cd157ab861801a49a8aa9d02888c27ae6c0613f3e2007", + "application/single_app/functions_documents.py::detect_doc_type": "131534dab7be522ddd3dbcbc833ec8a96a072732594cce197956bbc1a244df3d", + "application/single_app/functions_documents.py::extract_document_metadata": "18539e265237e501abf9f223329cba600e5c9dd9f919108428c41e725600bed9", + "application/single_app/functions_documents.py::upload_to_blob": "d561e99c4b411149271742885a104a1821b099c1e6bacd3636901d045f622e00", + "application/single_app/functions_documents.py::_query_current_xsd_documents": "2cefcc111e376ea955d5d191491bb264560a533668732f55c8d5b5622787386a", + "application/single_app/functions_documents.py::_workspace_file_name_exists": "58bca9dc5c4c311b48ff15b88d369b31138bc24294e0b41132aaae38d5959f72", + "application/single_app/functions_documents.py::sync_chat_upload_workspace_attachment_status": "38b39737ad295b5a02ea9a39cc763fabedb8bb56403370c48effba5552c0498e", + "application/single_app/functions_documents.py::_process_document_upload_background_impl": "be75c7decb63b27e9b4776f395fb10690ebdb7107a1890f9915d7ede7de9d22e", + "application/single_app/functions_documents.py::upgrade_legacy_documents": "5fee4885bf25bf384f5b4178d973801db1a64e2588becb2a5160cf017e1bc4e9", + "application/single_app/functions_documents.py::share_document_with_user": "11e21f0da3795a70081cd95e2c52af07fced0df4ffe244e088f5d160c408637e", + "application/single_app/functions_documents.py::unshare_document_from_user": "a8f3a55e2fe06ca971c1fc280303a4630835b620cafd04ff2914d377c8c5cc07", + "application/single_app/functions_documents.py::get_shared_users_for_document": "5d071686ddff0ac133bea6420d5eb1ee50584ee51f8968c340db8b7db617e97c", + "application/single_app/functions_documents.py::is_document_shared_with_user": "d203f7466968d3b6f26e2aa2ff4b226666437f0ab410eedc837e09e941661162", + "application/single_app/functions_documents.py::get_documents_shared_with_user": "4c97ecd031a9098d8327e529f97e5b50d8b1af040a2b0b9a4b824f44958346bd", + "application/single_app/functions_documents.py::share_document_with_group": "57b852e7cccbac5806ce4dd2ab45a578c20a952333cd89202b92c058693f7af6", + "application/single_app/functions_documents.py::unshare_document_from_group": "cd882bd5a80329e11c63010980160a696c11c78f69f12091c9f95fe3d987ccd9", + "application/single_app/functions_documents.py::get_shared_groups_for_document": "40b32e5ad6cdfabaab1fddf6ad180281e53363447fcd131d12cd6cac87d423e0", + "application/single_app/functions_documents.py::is_document_shared_with_group": "02bbe2c782840dfee4ecc13fee01f9a192d7927578dd3e2af6ea7738ec14b32d", + "application/single_app/functions_documents.py::get_documents_shared_with_group": "07760f89132373a4d340ae5e3c6fd598c289b4fbc59686d1ebf926ea77be01b1", + "application/single_app/functions_documents.py::get_workspace_tags": "9d3d4ea210083f823edce6427f2a7d9f9a98d54cc76a0c39f650262f2a8695af", + "application/single_app/functions_documents.py::propagate_tags_to_blob_metadata": "624067e2c6dd87dd59f7709607ffc2ef11aa4506d1275dcbdfe702cf40feb5d9", + "application/single_app/functions_embedding_compatibility.py::inspect_empty_embedding_stores": "7401781be74e07ab4fc8043c69c5d8c58e91bf34209a12084e853e3433279eec", + "application/single_app/functions_embedding_compatibility.py::persist_fact_with_embedding": "c4eec8143936830d06d7316baaac5ef8863c99ce8a26b30a39c021cd4f9ca3a5", + "application/single_app/functions_file_sync.py::_write_with_etag_guard": "adf47a1cff121465fbe6f4fcc8357548fda928e1a78a9531867466c0cdb4a699", + "application/single_app/functions_file_sync.py::get_authorized_sync_source": "f866450eacb43ba3f57c9d75b1f7bb85cddd5b8531b0ba971feb2e2771dc860b", + "application/single_app/functions_file_sync.py::list_file_sync_sources": "97925c713538a41941ac6b22c91389e3b83d9b9ea9baacb59dacf94979c95631", + "application/single_app/functions_file_sync.py::delete_file_sync_source": "21237c51e3f28855776a359f23f47f12e1faece00d0257877ced9b1f4a225c8c", + "application/single_app/functions_file_sync.py::list_file_sync_runs": "7455bf1ebe3ef550bc7d310aeafaba7144dd67795b119dbd58b031b7e93def98", + "application/single_app/functions_file_sync.py::process_file_sync_run_by_id": "e8244be2147fccd23250685e26c5238fc6372ef12ac00e4f24fbb45dc363e105", + "application/single_app/functions_file_sync.py::_load_existing_items": "9297e9ad17079b666d2aeb87afce9bc69b440c2d74bbe741c48ada40b15c791c", + "application/single_app/functions_file_sync.py::_count_active_runs": "a8d0ed4fefd439a5331565ce3e5a52a65ab1d0e1d5fbfe5c3513f986298a3463", + "application/single_app/functions_file_sync.py::_source_has_active_run": "6959dae437a3cbfc384f359e53076bdad487e64e8485c6d80f1ee4bf29346baf", + "application/single_app/functions_file_sync.py::_get_due_sources_for_scope": "b000bf660ffa02fa32bf087fa34daefe59759a379204a18d7133e84a995e043e", + "application/single_app/functions_file_sync.py::_read_file_sync_source_for_document_action": "e4f6866fa997d42ae8ab69f843eae09e1ff16a5d7137e48cd2f24c5a1626f7a1", + "application/single_app/functions_generated_file_approvals.py::list_expired_pending_generated_file_artifacts": "78ea99973634f39416647e7e7b9882ba3636da488c84829cea7d535459ec33db", + "application/single_app/functions_global_actions.py::get_global_actions": "1f59301db98927a6b50b0c53398dc1cc073dc1c6260a7e92aa804d59870f5e97", + "application/single_app/functions_global_actions.py::get_global_action": "96000fd3b279b520960961dcb3778049c354491052e2d5ae3df4c5121cefbbcf", + "application/single_app/functions_global_actions.py::save_global_action": "e85614c95675e24bfe36437a5b3948e172a2b524d2527be1d47481c850c4614d", + "application/single_app/functions_global_actions.py::delete_global_action": "69dbd117ae14228cc2b8b35facc389d53f482db2014ceb18e2b8c37031fefc81", + "application/single_app/functions_global_actions.py::update_global_action_enabled": "b0210e7c84e12bff5dfe8a3ff262047e17c1d358db35ac664294fdc9fc73dd07", + "application/single_app/functions_global_agents.py::get_global_agents": "925044ba91e093ad48c1f67a61d3dc0bcaadba0815589012ed8e4cfce254df77", + "application/single_app/functions_global_agents.py::get_global_agent": "73e80228138b64fbc2bd1e10b8202538d38f1ea1e60ad79431ccc9364baa928e", + "application/single_app/functions_global_agents.py::save_global_agent": "265ce2afaa78f99d48acacf9fa512dcff3fdac58ff95834cbefb1362aacb762e", + "application/single_app/functions_global_agents.py::delete_global_agent": "71e342703ea83bb2dcb9b54cf183ecdc58f8671ca9e28cc6d3d498c26621d76e", + "application/single_app/functions_global_agents.py::update_global_agent_enabled": "1c5a5a0cb5ae774224aa6cc015feba81991ccd77e8a4464a9c4e306744960843", + "application/single_app/functions_governance.py::_read_stored_feature_policy": "73b019829c14b87d4841433602b2cf4e7f63935251e0004159a37a18ec0423ca", + "application/single_app/functions_governance.py::_read_item_policies": "d9a3513fcfbb4d67bf1ebb03b8492b50074d6e58dddedb900c996dcb799d2a80", + "application/single_app/functions_governance.py::_read_stored_item_policy": "8207c78224565527ba99860c13fc790856fff281c9445d359b6da211b5f7f6ed", + "application/single_app/functions_governance.py::upsert_feature_policy": "7b85025fe88464388f49919aefa5236712ad5c470ecdfa6d4230c41779806a7d", + "application/single_app/functions_governance.py::upsert_item_policy": "1f5ed01ecc0625cecd3bbd0db728813a5021b4932da97105006d16cf32ea2f3b", + "application/single_app/functions_governance.py::_read_existing_item_policy_for_delete": "20f5fce9a66eba75cb91298be5b659050dc7d858e17a82a8b5f58f5581462013", + "application/single_app/functions_governance.py::list_feature_policies": "9b4a66d083c5e0c8e99e79ddc5dae47acaaf38c923823d737d987dcf425d9997", + "application/single_app/functions_governance.py::list_item_policies": "dda00d89b7377011b2b08a970a0f80cd8b1ddd811cb08a8dff9fca63aa10c428", + "application/single_app/functions_governance.py::list_item_policies_by_policy_id": "f363850661b60d214a03a9f328493300614147d11d7e5d71280342ed7c25d70c", + "application/single_app/functions_group.py::search_groups": "079c6b5e4cd0845f14ded10fef131a333379aabbeff8acc563cf53ba57a219e1", + "application/single_app/functions_group.py::search_all_groups": "ff669cc64b3ebd143ea67936caccb0017ea4a8dac30148fe28503569c065a142", + "application/single_app/functions_group.py::find_groups_by_ids": "7d3782ea77f57f8fae94f40b8a6fc04796695000074c26cdb5f7a7824cbba166", + "application/single_app/functions_group.py::list_groups_for_admin_directory": "f25a3e09685afe4b10bd35f17c4959600d0f5b771417167d7672599c246bfb55", + "application/single_app/functions_group.py::get_user_groups": "c875942337f57365eea717b60d1348decbe4e872bf751e92160aa9038d3aef43", + "application/single_app/functions_group.py::find_group_by_id": "de97382d2d96cd4ad3e6ecaafca8fe5f3cb5af119bb753c1360f64ae74393a0c", + "application/single_app/functions_group.py::discover_group_records": "a4c2924360826ba6f6593dd9987b642b5c357e9b35d8491473ce1f9044b5a0e9", + "application/single_app/functions_group.py::update_group_document_with_etag_guard": "694fa0c7aa39a668142e741691a0a0b3925f90358b6aab19fa15732724c2d127", + "application/single_app/functions_group_actions.py::get_group_actions": "6985fe87070299f56a7b50ac7413ebb852ca4b98759299a50406bb31ccf30a3a", + "application/single_app/functions_group_actions.py::get_group_action": "e34711c77890b49142b18ca05e6456d09fabd6eeffec1a78216f9978e924b47a", + "application/single_app/functions_group_actions.py::save_group_action": "5a59d375c674b352b492d2565f3beb3e5537eb8ea7965772e151ddeae55c4e13", + "application/single_app/functions_group_actions.py::delete_group_action": "aed77a69b7d09a31ee19d3ecbbdac7b5ecee358269f5c5c80ef06f48389f4d39", + "application/single_app/functions_group_agents.py::get_group_agents": "d9f01cb684870d79df0cf4dcc555cf68df0309192652326b58254d25b9a805eb", + "application/single_app/functions_group_agents.py::get_group_agent": "1f3f42201018bb77988374619496805afc69102f75dc58286cad8a0f31d52ef9", + "application/single_app/functions_group_agents.py::save_group_agent": "fbb3f2b3873cd744bf52ff6573ab6337df4dedb31a9111878c131fa06c9e00bd", + "application/single_app/functions_group_agents.py::delete_group_agent": "ed2c2483931b8411d43d6190eae7454f93e59f5a5d9b6bef6e2106eab8c514a1", + "application/single_app/functions_group_directory.py::list_group_directory": "b0d06eeb2149eeb35988ab12fea36542801e22b1d017a9aeb201d53f6c64362d", + "application/single_app/functions_group_document_access.py::read_group_document_record": "e09bb1bcdd2179cb16cbc9eb1c7c3cab7c5dc4944ceb09e6560dca6aeb1f6f86", + "application/single_app/functions_group_document_access.py::group_document_cleanup_allowed": "afc6589792bcb233ec956baa27137d22faed9af0c68e4ae3e062f5dda6387dab", + "application/single_app/functions_group_document_access.py::group_document_family_records": "5a85c37b870396df5d01d2721c1f4db8f68bd9ffc5a7cc87f8e6f16ff449ae45", + "application/single_app/functions_group_document_collaboration.py::_replace": "5928aeb0938d248fc8968416fb3b0cfa658f184204f716b72702c912c1bf6c9e", + "application/single_app/functions_group_document_management.py::_patch_tag_definitions": "d07ec717cc5f88ea9b9253c2f6c304af8f361bbfde925eedcd2b223cbb9ba851", + "application/single_app/functions_group_document_management.py::_current_owned_documents": "dcf4f5479b53d8d899adda7e9de741161af9c7e31f54a7cc8b8a71c004fd75bf", + "application/single_app/functions_group_document_projection_fence.py::_read_source": "ae4bd0b61fc18306196ce6c14c78f0f0b298b0c045fe6f0191f92bb170c56077", + "application/single_app/functions_group_document_projection_fence.py::_replace_source": "d9023802bd07aa0edd1b55deac280eb5b4de4fc6ed47c3c5debd839ca2089be2", + "application/single_app/functions_group_document_publication.py::decide_group_document_publication": "4c140442a591194016dc998f9e75d2e9cf63f95132a7529b6821f98c446feb2c", + "application/single_app/functions_group_document_reads.py::_query_group_document_records": "8437a0190d1e764e97687ba875f3927585facba07622324a338359db9b9a186c", + "application/single_app/functions_group_endpoint_access.py::find_group_endpoint_references": "8f96cdb98481cd2ac0b1cd4cfa7800c754f2dd33519a36e06a6853579f64a2b0", + "application/single_app/functions_group_insights.py::read_group_activity": "05ae4171d2be71290d2986837627a588da62307e977e2e3884c59475ac72a2ce", + "application/single_app/functions_group_insights.py::read_group_stats_rows": "26971ceb4e786e4d01ddc04bbf2227b317cd707036ba97e6aff1a88b3fc9652a", + "application/single_app/functions_group_workflows.py::_normalize_group_workflow_conversation_id": "6427413f44a81b809444d1dbf0f7dca5a513d50a65e9ac8574be008f5c3477b8", + "application/single_app/functions_group_workflows.py::get_group_workflows": "e64d3294f6e9bb34532711812ac0830cefad4c13596552ce4c30f8de9d796106", + "application/single_app/functions_group_workflows.py::get_group_workflow": "429a6fb335a3fece76f959edfda3f06cf544f11742bb5f3ecb4c2a5209eddf04", + "application/single_app/functions_group_workflows.py::get_due_group_workflows": "c079c4cb1bec267a32c14c8a643d87e892406cc0a4ac812ad82d4169dd2a2274", + "application/single_app/functions_group_workflows.py::list_group_workflow_runs": "d80fdc8de57159d87ffc4e2ab6c143aeb015f61e2d021ab17116070cba0fcb12", + "application/single_app/functions_group_workflows.py::get_group_workflow_run": "059f4a919ee8b181a8c41a4ca03f3c6ba2f84cecfc85ba67429e193813127006", + "application/single_app/functions_group_workflows.py::get_latest_group_workflow_run_for_conversation": "c0a18d5678a9396a496be1797207548f7ed64c4d5b4307144910ec6ae134fd21", + "application/single_app/functions_group_workflows.py::save_group_workflow_run": "47698a8084c95e1c0d7a391b2111ebb1c9b1a75fd808fa2d071a0326b5f6b6da", + "application/single_app/functions_group_workflows.py::save_group_workflow_run_item": "37d88892d26406c3072b7fe2b09d2e5fc2bd308f73c82dbd18d83b1396ef280a", + "application/single_app/functions_group_workflows.py::get_group_workflow_run_item": "15c0fe2b9278e945106c28385153a5f879efa6e5866433dc7169ff4fec5fae6b", + "application/single_app/functions_group_workflows.py::list_group_workflow_run_items": "71fe852b1f1e93ec7e479715bb73bb41aef2b379ef37d6bd81d38217d345f976", + "application/single_app/functions_image_messages.py::get_complete_image_content": "55bdf84516d54ee4edaa7d264a738ff8a1eff8b3acc5155cbb1bb11336f5295a", + "application/single_app/functions_keyvault_reminders.py::upsert_key_vault_secret_reminder": "c6a8fa7c3da3711875cfeaa9dea59c51a4aceaa0d3e8d56e2a2dcd32e275cfed", + "application/single_app/functions_keyvault_reminders.py::mark_key_vault_secret_reminder_disabled": "f68553d9bd9e41f600ac17f2ae0bc3f51aa8b69361a02ecdede50ec7b3b136a3", + "application/single_app/functions_keyvault_reminders.py::list_key_vault_secret_reminders": "428216f6ea1a157e12e943fe49d7b8bc4bb3e10e72dd3adcf914dd04aa26affd", + "application/single_app/functions_m365_agent_continuation.py::AgentContinuationJournal._job": "3e93c9abd66e5eeec6143025acfb896a9f72f402284826cc158b08aae59b6895", + "application/single_app/functions_m365_continuations.py::resume_pending_workflows": "17a0d1a95e49b2006bb2301efad2f1f86f8ecc67c97cfcc9988ee7df8cb562c7", + "application/single_app/functions_m365_workflow_checkpoints.py::read_m365_task_checkpoint": "24c29a3e590681ce48e952a636b6a53015f6bf7f8d3307f5d1b83d067b6b0c5f", + "application/single_app/functions_m365_workflow_checkpoints.py::save_m365_task_checkpoint": "77a082ecb7a4a20c39698b3a440953e450ecfd402901f6ab6dc681055af05f0c", + "application/single_app/functions_mcp_server_enterprise.py::check_inbound_mcp_tool_rate_limit": "8563316a6e6733e95dd8f4bf11585527afc2c3d3a79fd470869944223d4ef2c1", + "application/single_app/functions_mcp_server_tools.py::_load_legacy_personal_conversations": "2d089a8ed6a514f6ea6727457977048b8df7cb31995c4fb0813afbb5e6f7c98d", + "application/single_app/functions_mcp_server_tools.py::_authorize_personal_conversation_read": "e198efb864fb600e6f9064d7f90a0d9925fd291dad8060a1b08d4d45efc49d75", + "application/single_app/functions_mcp_server_tools.py::_load_legacy_messages": "0113be12ba7f24aade864c0929ea46be0727d4039d1bb68b0f0d59423ba2feee", + "application/single_app/functions_mcp_server_tools.py::_load_personal_prompt_page": "05845d307473e30980aafde342c9bedd4fd4b10b7427e34ef49e023bf90ee1a8", + "application/single_app/functions_mcp_tool_pinning.py::persist_mcp_tool_drift": "d4973e7c62d1e6987b4070fb3c404cc7b11413bbe7dbd20954dea0f028eb4fe4", + "application/single_app/functions_msgraph_pending_actions.py::create_msgraph_pending_action": "a21f629072ed36c85b69d8f9158d8387039b2c48dff47b67a2fdd3cb8906fbf5", + "application/single_app/functions_msgraph_pending_actions.py::get_msgraph_pending_action": "b2d5ca87ecb2c6ba2f42bf6a5c307deb8b95e4de3d2e8c54ff36e94b3db63d31", + "application/single_app/functions_msgraph_pending_actions.py::list_msgraph_pending_actions": "f9b3a499728e9f6ba82a9128bbeeb7d7dc5c4be4d6b8c9cb57e98f0348cba1d5", + "application/single_app/functions_msgraph_pending_actions.py::get_pending_action_page": "646c66a2110ca3d522bbfd5a7eb1c84497b54f57fa20d14afe6da9f333b34e66", + "application/single_app/functions_msgraph_pending_actions.py::get_chat_pending_action_cards": "f3e43f1dcd114054378bfce48234e47fbe4d88363154e3821d4566455a411309", + "application/single_app/functions_notifications.py::_read_existing_notification": "d3b17a86baa8600c9f00303815c2fa8aa31ff78f728a007e1db0093e96dc3121", + "application/single_app/functions_notifications.py::get_notifications_by_metadata": "f0f6bd5c6c05508a18802f821efc5a7953cf2e3a294b7e238c2f33f6c8de3043", + "application/single_app/functions_notifications.py::get_user_notifications": "b89a7c49901656603a5e35d3ec34739d1130bc19ee364eb29aadc0ab6bb5bb32", + "application/single_app/functions_notifications.py::get_recent_chat_response_notifications": "9101e3a54a0054e1ab3043aea48a8cd0871439f986584f04b9ddaa6c689d4994", + "application/single_app/functions_notifications.py::get_unread_workflow_priority_notifications": "942119d18682ebe7b5552c6b8724f1af7039470ccf6e88c7c9248d3f407de34a", + "application/single_app/functions_notifications.py::_read_workflow_alert_page": "c9230a57ef09ccf3e728e2574b87f936638e13f040fc7ed31d44f517f83b88e8", + "application/single_app/functions_notifications.py::_read_notification_by_id": "82ee5da960802da1071531587265d8edc10edc2c9f6db3506f200c8fa30e512e", + "application/single_app/functions_notifications.py::_write_notification_change": "82cc5d4f81604a76ebd007dac7cda3e95384389c5a865bf2eb483940b6468bff", + "application/single_app/functions_orchestration_collaboration.py::_refresh_mirrored_answer": "7f0eaa8812e33322262da8a5c208324b9f9a781b475f358f61061c947bacd996", + "application/single_app/functions_orchestration_collaboration.py::delete_orchestration_backing.read_backing": "0dbd48b611e5c0d277f645ddea3bf692284e6cfc163b1bfe1b1570e9fd91c593", + "application/single_app/functions_orchestration_context.py::_image_reference_message_candidates": "6d6a7b8ba9f78ef9b10f0ba55b8d6f18488206cb004e102e01eb3f3ff4715315", + "application/single_app/functions_orchestration_context.py::_owned_elicitation_conversation": "e938fb6773d3befeff376dcf23ad01f6a1a56373f99eb8686f7de6c06981d1b4", + "application/single_app/functions_orchestration_context.py::_authorize_references": "f297054359cf1296836b842c9ff70ca5787c32b92c246084cfa6b202407122ff", + "application/single_app/functions_orchestration_runs.py::get_pending_turn_context": "ea9e8ea9d5c26b68abeaffd369cdeaad0df0a5bc5748d1d4df014de740479b4b", + "application/single_app/functions_orchestration_runs.py::_replanned_outcome": "7c8dfe316d74c544b48b4ca595151386be1a3331c36be18c06a62158e39bb5b7", + "application/single_app/functions_orchestration_runs.py::_publish_replanned_run": "c79252d36d79df63ffdc38628206de5496eb0cac7c4f0b0f7296281d699ff4c1", + "application/single_app/functions_orchestration_runs.py::get_orchestration_run": "908e76b2988685816197019f3e0a4aea0d32ebc992c0198ed4ac430e6a68e4d0", + "application/single_app/functions_orchestration_runs.py::get_latest_turn_run": "aab405d0b7fc15a56308f3545dcd781c0f3fa53a96cae86c3774acc81a089364", + "application/single_app/functions_orchestration_runs.py::update_orchestration_run": "a85de870093af5ccc3a0d77d32711faedeb677de3eb6465e7b616c63eec4b17b", + "application/single_app/functions_orchestration_runs.py::_update_run_decision": "c15b64341648bbf0241209dfd1ca33f47d8b8b6b327d0e7d024e9bbd26d565f0", + "application/single_app/functions_orchestration_runs.py::list_conversation_runs": "58f954eec6ce821c582d49e4e4d102cc83f17fcc7c7aac45c55be2454613fd9b", + "application/single_app/functions_orchestration_runs.py::next_turn_index": "7b6a267a5ab8f78d9c2520fad1c08cbc8c1ae008d3aa8f5138e04f6b5415fcfc", + "application/single_app/functions_orchestration_runs.py::get_pending_elicitation": "e7554ae30d1f0087714b0e1340d52fd8b7f860fe2418fa7e3b081d81738933cc", + "application/single_app/functions_orchestration_runs.py::create_pending_elicitation": "9d1cf8d1f74db8625814c77f711677d91de5bdc6f4eb8c30bdb1a11daa092b98", + "application/single_app/functions_orchestration_runs.py::_replace_pending": "115d7e78aef1c002a3bf95d1aab87c09b112e0ac0d6cf09bb2e3f9cccc870f52", + "application/single_app/functions_orchestration_runs.py::save_orchestration_step": "73eb814415222ab91add82c86cf9fb7bce32e68241d68013225909cca583bf71", + "application/single_app/functions_orchestration_runs.py::get_orchestration_step_record": "d2d2acb89ed64a68e561ef8c8096bf6f9045060bdd2cf2894abe036151ce01f9", + "application/single_app/functions_orchestration_runs.py::list_run_steps": "ab9d6e26de5970720e6bcd4b74c8374f1ae5b53aa9c966f4042aad6993f355ed", + "application/single_app/functions_orchestration_scheduler.py::enumerate_due_runs": "3ee4b0d3fcaf170e9eaae4ee2293c5237b9be086e9847487cb5c30dd18528244", + "application/single_app/functions_orchestration_workflow_context.py::_read_personal_agents": "f2e09eb63b012196502aa502ab60a41ad5efd4cc3f6f90c0b53fb81602123b18", + "application/single_app/functions_orchestration_workflow_context.py::_read_global_agents": "4fdd993d426241ca7b83baba80475546e8a66ba25fa227f09a990a0d169a54c3", + "application/single_app/functions_orchestration_workflow_context.py::_read_workflows": "55c742e6c677be568c66ee47f57819528633c8c458698c7081556d099c1f14cf", + "application/single_app/functions_orchestration_workflow_context.py::_read_wait_workflows": "98d5b536075b0cbf5637fc53322385839420c3d25d1c5446558303a75585cef9", + "application/single_app/functions_orchestration_workflow_handoff_decisions.py::_read_workflow": "22cc82878b1df27322b3bb4a529f07ab3d4451cc5aa70ba0d2daa5bb7b25dcae", + "application/single_app/functions_orchestration_workflow_handoff_decisions.py::_read_workflow_run": "8fb41cefbc1cead5c2ffb73bc63b1cc9075993afab480e50205e47fb4eb4fdd3", + "application/single_app/functions_orchestration_workflow_proposals.py::_read_workflow": "04f5f464541540a451389a3e23a63ddf75c485e2ca6fbb21d1856fa3e551222c", + "application/single_app/functions_orchestration_workflow_results.py::_point_read": "4620c22db8dd6c7f18a0a6e96def9f9176246522529434a2ce9d2fb00759295f", + "application/single_app/functions_orchestration_workflow_results.py::_query_runs": "cb98bdfce574b42c37ad0603fd7b1bf4c9dec9e47254d4893a0d29ecd9854364", + "application/single_app/functions_orchestration_workflow_run_links.py::_point_read": "cfe6ae27270536f1ad9bff61a5f9ba0ab3220bfe76dbe98218c475da152a9e3f", + "application/single_app/functions_orchestration_workflow_runs.py::_point_read": "efe4896bb9f4094744efe20695580651e4079b9e9f719c4c46e742b445293e7e", + "application/single_app/functions_orchestration_workflow_runs.py::_write_plan_wait": "dcf1a0cfa8cbfea406dc10f54e659c885d9b3cc101c7c77f8a07a8d5ba59d9e5", + "application/single_app/functions_personal_actions.py::_read_personal_action_record": "0f33c40dc18ad82afb9db059ba9a16fa2009e95f44b0b96725e71750b5ad76dd", + "application/single_app/functions_personal_actions.py::_find_personal_action_record": "7eb9544197b57ad8d2e3767ad67a9e9c214d0f15522a28d9e13719f208e914aa", + "application/single_app/functions_personal_actions.py::get_personal_actions": "9aba8abbd11ba6c1df1c2b5328ef47edc765152ea3d6c0bdf71422286a4b961f", + "application/single_app/functions_personal_actions.py::_save_personal_action": "a64754b09404cc62816a5b576a1162bfc149894c20d7a587721d12e6948110a6", + "application/single_app/functions_personal_actions.py::_migrate_historical_msgraph_action": "5fbaa7a62940913a9cc0eaca24c34f72e2f77659daf2b608745192d33b8c4a26", + "application/single_app/functions_personal_actions.py::_read_legacy_settings_document": "95162c5ef5a4ee88d92846b61a26459314170cb97545a3b3ae5b482247445ff7", + "application/single_app/functions_personal_actions.py::_read_legacy_settings_for_preflight": "47ed5dfb5d939bd2a47e8cd86d614ac6391b1960771d28a68dd3db372536ff7d", + "application/single_app/functions_personal_actions.py::_remove_legacy_snapshot": "b94095f8c9cc9989f9db392ca09d8e10e9c5dd86650c942c1578a0b8ef14573f", + "application/single_app/functions_personal_actions.py::_ensure_personal_secret_name_available": "19b826ba7f48e47634907cca87be8a6f9b87cfc4d5097ce06d04dac5a5316853", + "application/single_app/functions_personal_actions.py::get_actions_by_names": "db5c6dcada8d279ffe16d97bee044149278868dbd50bb9e4b687f46d4b7a8eac", + "application/single_app/functions_personal_actions.py::get_actions_by_type": "753573c6149b5e276c7327019d7f3fe99192cc7ff82624201c184c609e5d4f9a", + "application/single_app/functions_personal_agents.py::get_personal_agents": "d1d7261b51a3a2a6be02c655ef7a9d673436b015dfe549305bb99e1d030990d5", + "application/single_app/functions_personal_agents.py::get_personal_agent": "637b0cf6c26df0351f7cf571bed018f0b7791071e00b01a59a56dfac1be32b87", + "application/single_app/functions_personal_agents.py::save_personal_agent": "430c4e509d52a810269035864de8f732badf5c4cc24f12bdc6285458348b0e51", + "application/single_app/functions_personal_workflows.py::_normalize_personal_workflow_conversation_id": "16afdb79dcd640854edb583edef3a040bde7cb1c44060696f89e570c259f9175", + "application/single_app/functions_personal_workflows.py::get_personal_workflows": "d2f873226e240ae9e535f2b4e28eaec65bbef99a6c7d0ecd98b88761f3001fe8", + "application/single_app/functions_personal_workflows.py::get_personal_workflow": "412c4792e949096ead5b2a9e33675fc408a1ecc353fd7c93e450c2251f511761", + "application/single_app/functions_personal_workflows.py::get_due_personal_workflows": "38211baad31c7491f6802b377383e256524c385ead1f53f8b396af8b2c5c55f4", + "application/single_app/functions_personal_workflows.py::count_personal_orchestration_workflows": "d195bef74676a284127e6095b842b3d6ded16a892f18f9e42b7ded2fb818de3a", + "application/single_app/functions_personal_workflows.py::count_personal_handoff_workflows_since": "6ee1f567f03a4b610edda03b09b620b72ae29c67185d0ea0b4705712f18ecd6e", + "application/single_app/functions_personal_workflows.py::list_personal_workflow_runs": "7b6b849dbc3ef31091bc541b8395422110bd48f8b844301866e599da04944960", + "application/single_app/functions_personal_workflows.py::get_personal_workflow_run": "0421fc4aa5ea00478f6c0f439e41113e758970799258a9cccbf5524b7e621dce", + "application/single_app/functions_personal_workflows.py::get_latest_personal_workflow_run_for_conversation": "86caab75ef1c4861ac47bfbe0f98d626a44c82943376ac4ce908e0e24335cad3", + "application/single_app/functions_personal_workflows.py::save_personal_workflow_run": "32e2f0d4249f0a3c3dc2d3c45e833db23d6ef7719da328da044ee7a6da6d06a5", + "application/single_app/functions_personal_workflows.py::_save_chat_started_workflow_run": "31b480224d23cda564af9f5b2d4b28c53195c326453e4c2a7351a8925854c5e1", + "application/single_app/functions_personal_workflows.py::save_personal_workflow_run_item": "db2f57fe92805e46de7edcb37bfc027c03401fe7b8214e008d23ff36f12fc7a8", + "application/single_app/functions_personal_workflows.py::get_personal_workflow_run_item": "7e5c0a316d1e8a3fdb9934f0b70390024deb193205525d3be917acbffa6f149b", + "application/single_app/functions_personal_workflows.py::list_personal_workflow_run_items": "59c8bc0cbb438f3ad96fdad8fb2d93e538aa64f11ecadbf44a768b04df72f2a8", + "application/single_app/functions_prompt_variables.py::_authorize_conversation": "99041e0e602e80f65fd0347e101aee569e840a6f2b0c251da79bfba6ba2790e1", + "application/single_app/functions_prompts.py::_query_prompt_items": "f44507a724b5ceeaf06811d848537ad56a8fea7d6221f5f391ca6e1ac3eb4591", + "application/single_app/functions_prompts.py::_read_prompt_from_container": "0da4805dd65c93d8a494f40cf8627747bcd8f44345636c3b46c75396fa3954ca", + "application/single_app/functions_prompts.py::create_prompt_doc": "cca1769ccc0ab0a2ee49101d2a799eb9db495de8c904c81ae91df0a42c373d56", + "application/single_app/functions_prompts.py::update_prompt_doc": "1c649ac2138430acabd55e7b0528ecc9509148b3ced7032f26fe1fb6a913f758", + "application/single_app/functions_public_directory.py::list_public_directory": "d2a2c12c36f3351c8479948a0cb05262e4d0ba4032828effb7ae2bd80c673226", + "application/single_app/functions_public_document_access.py::public_document_family_records": "465dfe387c7a3fc5ed65f099ee51f56d745bae6b757acc52b13da93a3f60bd85", + "application/single_app/functions_public_document_access.py::read_public_document_record": "e1354a92b8ac16342903d523ae347a7cfb447805dc6fb0b55c68bde731252cc9", + "application/single_app/functions_public_document_access.py::public_document_cleanup_allowed": "2494f0127e8d5bd6b557ed0e034d676de927ba5ace9cfcbf89dce4e63d030da8", + "application/single_app/functions_public_document_collaboration.py::_replace": "6df9ef25a8327184c30cac183df688f1cebd7155665aa7563c45549d1a8f3437", + "application/single_app/functions_public_document_management.py::_patch_tag_definitions": "a579e47d9e5185eddf692f2f093d84f9705f0973f1a01c73b72d81c900f00ddf", + "application/single_app/functions_public_document_management.py::_current_owned_documents": "0ca80e7e8f38e66b3069a4d642ccfada6900cc221623f06c72f0ae2727b8a8b4", + "application/single_app/functions_public_document_publication.py::decide_public_document_publication": "c32e7448c363e0841a42ec5b16e0f3cb162f725233207de387731b19e911a584", + "application/single_app/functions_public_document_reads.py::_query_public_document_records": "88ba3c20912196f7c10fdfa1b242a6a51f6965fc716d6741f5039c9f7e6e4476", + "application/single_app/functions_public_insights.py::read_public_activity": "3af20659c8da2a99e2432823c2bb59b694559c569ba84389336308ff1eaf9250", + "application/single_app/functions_public_insights.py::read_public_stats_rows": "b77aad80dbb748ac3e080de5b3df9e8047498449275340b3de1f287b3e33b217", + "application/single_app/functions_public_workspaces.py::update_public_workspace_document_with_etag_guard": "440266b85f8007977ac02d6d82c81529f8567db937f9b8897c09ffc148f83757", + "application/single_app/functions_public_workspaces.py::find_public_workspace_by_id": "1446f9b3207013aa981d9261eb2e36fd699c36978a43f825a19b8e9c3d08d255", + "application/single_app/functions_public_workspaces.py::get_user_public_workspaces": "f56d885c9b23f39300d7510a0af7d6808571d7d76c52fd09c9ffab5673778c01", + "application/single_app/functions_public_workspaces.py::get_all_public_workspaces": "70f48676c4a7d462d58fcb511374dcd38818a10fd939ec0d6db5424b4cd35899", + "application/single_app/functions_public_workspaces.py::search_public_workspaces": "2b34ea6cc178b7a713240f772c9053002c236e7dad9e72ebda83fce5d5a63010", + "application/single_app/functions_public_workspaces.py::search_all_public_workspaces": "4f1584ed2cfcd81295b5fea8838a44d4b1fbb06667325006fa4f79872e1fb996", + "application/single_app/functions_public_workspaces.py::find_public_workspaces_by_ids": "1b0e9e16c370302891eb6964fdea8e81914faf1a17a9527ba784ba5c2181d1dc", + "application/single_app/functions_public_workspaces.py::list_public_workspaces_for_admin_directory": "9d34f8607c2ca43c409f17d667dec470d91822980108b4e235839a4ed82bfb92", + "application/single_app/functions_public_workspaces.py::count_public_workspace_documents": "b6cca49a467e7ec327e8fa55b22ca111c3d2d17886308713dbb8f2fc314f36d5", + "application/single_app/functions_retention_policy.py::get_all_user_settings": "08293b094b6dd4eb489947cac24db8dd383fd7e8a418f14215380b2ea1ea427f", + "application/single_app/functions_retention_policy.py::get_all_groups": "84c7da72a8c38d5f23633adf36f19326245997b791a030da7b1b7adf80d9b336", + "application/single_app/functions_retention_policy.py::get_all_public_workspaces": "f07caa201835aa228108371876e050fa76fbdecfdb218f4cd579057c689e8577", + "application/single_app/functions_retention_policy.py::_get_existing_public_workspace_ids": "90bab849493ee32944fc5a93c04f190c321c5bac08641e840dc6b7f7c84024bb", + "application/single_app/functions_retention_policy.py::_delete_standard_conversation_for_retention": "447574f7b543cfee183cc339fcd8f60f8e5b46a31d69cd13c81b10f1ad484e3e", + "application/single_app/functions_retention_policy.py::delete_aged_conversations": "334ab086726ea2fff59943e00b6a7ce79a347d84a0b08eb025379452121d3c92", + "application/single_app/functions_retention_policy.py::delete_aged_documents": "19e0072704b6110511d7fe24230dc558c4c0c167220f2c06ae2e2bf4ccdd4b5d", + "application/single_app/functions_review_assist_runtime.py::_read_record": "21f6139572fa52e6d88f5aff9177000ece5beb44954ecdb5a8053b892aa5048b", + "application/single_app/functions_review_assist_runtime.py::count_prior_violations": "265a74183c7d28233f251ea273fe5cc0cc4821219a50a2f933f96dc10d4466be", + "application/single_app/functions_review_center.py::replace_review_record": "2e7010588567470e3f1a3ac8650b583c9d32f1f3836985472f5d3da1f319f76b", + "application/single_app/functions_review_center.py::resolve_review_users": "d6fce8216db4cdb39dd614f522cb290d100c8161ad6a2bd6dc45facbc0c2e68d", + "application/single_app/functions_review_center.py::_read_review_record": "9ede2f2d3783921a2de832ab5d64ebdf526de3c7599543b855cfe622fd9452d5", + "application/single_app/functions_safety_remediation.py::get_safety_log_item": "968801a274912315559fd88660d003d186f0cdb168520e1d5b94a9d90b0780e1", + "application/single_app/functions_safety_remediation.py::write_safety_log_updates": "7047a64b09bbb563368d91abeb78242f10c03bbc77d46729c6cf9c497d905296", + "application/single_app/functions_safety_remediation.py::_lookup_remediation_requests": "b74e2f516568c1494a6b462bbd4d482a5b7b59abeaf1a5d3310b1e78b6f21f25", + "application/single_app/functions_safety_remediation.py::_replace_safety_log_if_unchanged": "099c5069fa9fef7012aaf9bb5ac26991e806ebe0187e8bcb47174ffea376c910", + "application/single_app/functions_safety_remediation.py::record_safety_warning_send": "de92e01232983766058c607c3516a11337ef7be003cb333947c3fac66c3c1dd8", + "application/single_app/functions_safety_remediation.py::count_pending_safety_warnings": "057730e929c5b10e89d8459f61ee3a4b47ac50d594be07bd730fe4555f499a69", + "application/single_app/functions_safety_remediation.py::list_pending_safety_warnings": "e2591c76c1553114ec4e47f14b08e86e66e0b3e6c31334817249fafe284dd709", + "application/single_app/functions_safety_remediation.py::acknowledge_safety_warning": "6f69dce6f072ecbdc6a771865fd4a152d8c397a5adbf4278f9cb8eb4c4460493", + "application/single_app/functions_saved_analysis.py::_authorize_conversation": "bac426efc25b572d4fb800427a1c5dfdaa16d981ea949e51703af165ae546a62", + "application/single_app/functions_saved_analysis.py::update_analysis_conversation": "ff3f8808a0bd65f87cedd6fadbea397d7c4eefa8f0fc9db94e4b4a676a8b46e7", + "application/single_app/functions_saved_analysis.py::bind_chat_analysis_attempt": "53bdf370b2ded3069991788c17fb5ab4e70ae4101372d45cf5f545d1f1c4ff92", + "application/single_app/functions_saved_analysis.py::_load_authorized_message": "869c1fd9a410a217967863c5a111cca89ea24f79281ca525409b0b2d3aecba71", + "application/single_app/functions_saved_analysis.py::_read_personal_conversation": "4ddf1a1693d983b04dee83c61e90a3fc12764555850d81d38488ea343b0a119e", + "application/single_app/functions_saved_analysis.py::_analysis_artifact_parents": "b253e83ae006f50320be2090d6f612c081fada02ddbf3dd4fb643620b880d9fb", + "application/single_app/functions_saved_analysis.py::bind_native_analysis_artifacts": "dc1649545eaeaf6ac399751adc9eec8b468ad5ba0601505f7d5ef2700de519b5", + "application/single_app/functions_saved_analysis.py::_bind_analysis_projection_contexts": "89e9cb200ff65fb81cf661310cfad1a1bb7e9657e8f69eca998d571f6c3c23e6", + "application/single_app/functions_search_service.py::_authorize_chat_upload_conversation": "04e8545ab0377ffbf9d0bba0087f6a1084cbe050fa8d5df238aeb41c9037f73d", + "application/single_app/functions_search_service.py::_resolve_chat_upload_context": "b0db70098c15cd1ad6d7300000cd6b12d4d76ca12401c153281644ebd2b9025c", + "application/single_app/functions_settings.py::_get_app_settings_store": "c32884d48c1fcedf090ce5fe1898b41650a8764e2de6ebaa55fa5a0ad76e8a56", + "application/single_app/functions_settings.py::get_user_settings": "1eac7bca2255d23bce7f43b1ca84626fff5fc88da6a103495040bbe90d444d34", + "application/single_app/functions_settings.py::read_user_settings_snapshot": "f685c0cc5e67754797157174148bdcd09ddf0394079cc7967d026cb4c5270e0a", + "application/single_app/functions_settings.py::update_user_settings": "75b3764b98f200b1b0cb5310c893edd26f8a98cedcb96aceefc016d28270b0e8", + "application/single_app/functions_settings.py::get_user_search_history": "12dd0d7ddaa2c096a8163b80c8740e03d03741ebe74acda49b94d7a327012d90", + "application/single_app/functions_settings.py::add_search_to_history": "14f1f0bb6356b9a487bcd788af174b529b31846b090c88656c20cc995448b00d", + "application/single_app/functions_settings.py::clear_user_search_history": "844518191cf0e1bfe4cfefe206176d3029a01b6169ff6d545abb3e0c6e72ebbb", + "application/single_app/functions_shared_cache.py::get_shared_cache_entry": "af2b42b667c1fd471de64bff1ff053d0d4abdc49357060c74fcae8ed2557ac8f", + "application/single_app/functions_shared_cache.py::get_shared_cache_version": "d0784f8f867d64d7e3052c1d1d45e8b20c6c6e0a89179682a72d943399487aa6", + "application/single_app/functions_shared_cache.py::ensure_shared_cache_version_doc": "28bd35630eb9e2832fe133fb3bf27c4bc4b2e60c1c7e0241a5618d4cdb9c87da", + "application/single_app/functions_shared_cache.py::bump_shared_cache_version": "930ad1e81d001ded49ba2b61e44c46cee587ecc1b799021ce78c569306afbb59", + "application/single_app/functions_simplechat_operations.py::fork_personal_conversation_for_user": "3ad2ab9ce9e09bdb50ca909a0e86685a78fc0a8bf225539ba4d6f5bf9e234ba1", + "application/single_app/functions_simplechat_operations.py::add_conversation_message_for_current_user": "fec3968679053c94637bc3594f8eb1e2a5dd6cac5d8cb691ca8415cfa20726a3", + "application/single_app/functions_simplechat_operations.py::delete_generated_chat_artifact_for_user": "836a989fe71564bceee5fabc6fce3db2f1c3ffa7e36f6a08dedd013c7c402d61", + "application/single_app/functions_simplechat_operations.py::delete_staged_orchestration_chat_artifact_for_user": "24b7ccf7e07d999f526adadb0b31ed7805c4a208d84c275644ff2653ba5bb80f", + "application/single_app/functions_simplechat_operations.py::delete_blob_backed_chat_message_files": "a416f95e08285462e8cd704b750582cfc37af994fbae76b084ef0d7bfcda595d", + "application/single_app/functions_simplechat_operations.py::_get_latest_personal_thread_id": "2cd56cccff768a2c4b2056d09f9b7210aea54a0cc020465cb47a34b9fd19eaef", + "application/single_app/functions_simplechat_operations.py::list_pending_generated_file_approvals_for_user": "9bcb26f4a97fca41cc9f31a83ed12c3ee849b41d0fa5f65db77eb1590a767b25", + "application/single_app/functions_simplechat_operations.py::resolve_generated_file_approval_for_user": "3a13002b12dfe90446890e8a8c0ea8239b9b5fcd7cf6c9159eb238ca67b459f6", + "application/single_app/functions_simplechat_operations.py::attach_generated_file_approval_state": "bdd93787595908116d656a3fc448a7b148382def7f835f4bddcac74bb45cd5b1", + "application/single_app/functions_simplechat_operations.py::_upload_generated_chat_artifact_for_current_user": "878ee9bf1ca871eea38c859bb4df8aa5f5f8bdd2f47b913e96c66693a3d950e4", + "application/single_app/functions_simplechat_operations.py::_upload_generated_chat_artifact_for_current_user.reauthorize_write": "63f6777e0a6214cdfa0eab14df3f853e6bcd0a25b736f74cf3fcbfbc9883e07e", + "application/single_app/functions_simplechat_operations.py::assert_generated_chat_artifact_is_published_for_user": "d66a031be4dc02d8c2e2d2ed39a1b5290e86884e7ce4769ca89d667289f594d9", + "application/single_app/functions_simplechat_operations.py::commit_generated_chat_artifact_publication_for_user": "99dd5c86eb63a3380ce98cea49d8237018c9dce679f3ea3d811c671171fe155c", + "application/single_app/functions_tabular_generated_exports.py::_authorize_tabular_export_run_conversation": "05f3fd2909cf45e3317dfd0b53f846ba5cff6c34547a2f6991b9be33cfc1a1ba", + "application/single_app/functions_tabular_generated_exports.py::_authorize_tabular_export_run_execution": "56a006ca21b75f7cff9a55adc8c704fa5851679ffd38a9cff60df08f07eb6b88", + "application/single_app/functions_tabular_generated_exports.py::_query_scheduler_candidates_by_status": "24d03e4ca306eaff41cda3f2a37d1b0f31ca6fce7f38e8c03210dfbafc1bf443", + "application/single_app/functions_tabular_generated_exports.py::get_tabular_generated_output_run_status": "5023ef6e61cebd6447bbac4c0e88185dbed0c159b2d8f7e44f2c14baeabd18d5", + "application/single_app/functions_tabular_generated_exports.py::_read_run": "ad6c62ac31ed11cd30b4fb3e505f487470f0c7ec36c596b95af6f9d89805407f", + "application/single_app/functions_tabular_generated_exports.py::_replace_run": "39c7814062c3b09084d628c3fa86853aa3b5a5f9d0beef21dafcce5d382922d3", + "application/single_app/functions_thoughts.py::ThoughtTracker.complete_thought": "d2d4196faa7ad8201fce499290ababb5dcd1e46f985fe62a6af4d73e073a3f95", + "application/single_app/functions_thoughts.py::_visible_chat_thoughts": "0c876891412f40df99f3a2b54e40fd6283784524bf3b69019220d5f7a82865b1", + "application/single_app/functions_thoughts.py::get_thoughts_for_message": "f9acf410e21f2b3b2b42ed6e597bf972e13419789241657db825e24df7523cfa", + "application/single_app/functions_thoughts.py::get_pending_thoughts": "f85d5447504e2a31b52688be081be28bfa7d3f43c7c8d5e836be3c2dc1637858", + "application/single_app/functions_thoughts.py::get_thoughts_for_conversation": "17fdb138dd59ebe66492745f2d0f111655ee6e10714504ea137824a21d374288", + "application/single_app/functions_workflow_assist_limits.py::CosmosAssistLimitStore.read": "e38f530dd1bef4ba82fdc57f68096ad8426e4c7f992a80cf5b99eb75b8762b11", + "application/single_app/functions_workflow_assist_runtime.py::read_workflow_base": "1be9f68968bc2828a5b0088b7e9afab4610f95d6d2c9c880cc1e972f09b45151", + "application/single_app/functions_workflow_definition_store.py::save_workflow_definition_record": "78c26fbe4d26cdfa86bad30dcc59829d8d883a52749179906824d129451e9fa4", + "application/single_app/functions_workflow_definition_store.py::create_workflow_definition_record_if_absent": "52d7e92b83453a9caf96bbb108673810fd48caa03ab729dd1ad1fff085cd1339", + "application/single_app/functions_workflow_definition_store.py::update_workflow_runtime_record": "f41b5161ec9f6f56e4990f3cc55d457d966ee9f2d08a8deae6dd88013acc2e57", + "application/single_app/functions_workflow_plan_replay.py::_read_conversation": "095dd8c0e848b2a4c8c1b4aa842f8abe35744bb069b5dd99246055ebb552fc98", + "application/single_app/functions_workflow_plan_replay.py::_read_message": "43b9148d6257ab1c496d44a2f6b2fc9e7709497d02e54eabd9c732d6843f5362", + "application/single_app/functions_workflow_result_followup.py::_latest_thread_id": "230e0a4f0f18101155c5d5108211f1ed4b46cc9428eb657ed6e7954299895660", + "application/single_app/functions_workflow_result_reader.py::_point_read": "8e5fef329d00bf47ee25d58a8c494ca44ee2f936042e986548a0ee9110b6f19c", + "application/single_app/functions_workflow_result_reader.py::_task_rows": "36048a3df4909105e3a76e8f18a865be3397c50a7e5271178a5e5acb07a885a3", + "application/single_app/functions_workflow_results.py::authorize_workflow_run_read": "b40275b233a2a367a6f99499797bfcf5764b473c7b641ac2b1896509c3d0b9d3", + "application/single_app/functions_workflow_runner.py::_hide_run_posts_superseded_by_reply": "3ba6640db3f204668065b13b66d125fe833c349c778a8b6a0a8d9fa09c3703c3", + "application/single_app/functions_workflow_runner.py::_hide_workflow_conversation_after_delivery": "48a263f15ae59463be38ecb2dcc44e7bd6fe1982139789cced028ffcfe4faf76", + "application/single_app/functions_workflow_runner.py::_mirror_assistant_message_to_personal_conversation": "e0a6ee8681988fafd7ca1b8aee69631587d3606b4d2ec841db1cd3b6e6285061", + "application/single_app/functions_workflow_runner.py::_ensure_workflow_conversation": "76859ac3918c316936a3009641287b98364faa2ef360ce3d342c43bc430be8e1", + "application/single_app/functions_workflow_runner.py::_get_latest_thread_id": "867a58a7099d2af43e7fc9bcecdbab2df27c250f250d70bc90f2c57bbfd1bc09", + "application/single_app/functions_workflow_runner.py::_create_user_message": "878293c4ec50e168cd44ac9e34877ed06894de72eb792246964fc8eaaf51128b", + "application/single_app/functions_workflow_runner.py::_query_recent_documents": "dc0c5d6e87b4763b42aa04ceb55e8b6e74662a51a8fcbd4882998572237ac513", + "application/single_app/functions_workflow_runner.py::_query_merge_candidate_documents": "193d7528b5d1f0573b3717ddd68fbd2339ec93e96a0fdfc0f039b4f931daf8b5", + "application/single_app/functions_workflow_runner.py::_run_authorized_workflow_impl": "c924575a64ee0bd91013e8812f8478a77862e5be91e5009b54748fb3a2fb5cc2", + "application/single_app/functions_workflow_runtime.py::_bind_active_run": "c28638230873e3091ce01c82d98f6f0e2a4a007b8e540e9934425a92a3cfbc73", + "application/single_app/functions_workflow_runtime.py::queue_durable_workflow_run": "8e6526f8027c87663aa743ec219cf31c01deaf5803d857cec499e5c8bee50354", + "application/single_app/functions_workflow_runtime.py::_project_runtime_run": "e8162285bd41e9ba1c213134b5ff855318f999eb69b99d0165cdc4b2ae6c79d7", + "application/single_app/functions_workflow_runtime.py::workflow_runtime_status": "8c10bbf579e3821eb754568fca526a1544856b37a9c0fa9d9414d6036896ce83", + "application/single_app/functions_workflow_runtime.py::continue_durable_workflow_run": "c5724894e4669dac94ebf85eefa40eebc5188b84a01d874708122f403087d6c3", + "application/single_app/functions_workflow_runtime.py::resume_m365_durable_workflow_run": "1dd377c316f5534e622651c7f8f3ce5fa421f1ac1b03c3bb42def6e81f3228af", + "application/single_app/functions_workflow_runtime.py::check_durable_workflows_once": "d84af53974ef2b68b653d28b92c8be24339853ab408763a437932dd109cf70fe", + "application/single_app/functions_workspace_authoring.py::read_editor_record": "9627037648870f5fe0338a80fb6476ccdf8fe40a64b0cf9b24571b8fa27262d6", + "application/single_app/functions_workspace_authoring.py::list_editor_records": "b10d2639d00f90e560a69bf66331bbf39674ed5f5e840de1ebe958b6d82311fd", + "application/single_app/functions_workspace_authoring.py::_cleanup_replaced_secrets": "62a8d52cdbd9caa6eb2b57f27ad04e4e08693f2c0216131a9eac8f2286200ad4", + "application/single_app/functions_workspace_authoring.py::_sync_editor_reminders": "d3fec75c06b51c9aba43675b952be86b91b5c7cfe2d29c51fbf85d7a49cdd7b6", + "application/single_app/functions_workspace_authoring.py::save_editor_record": "f6244e23c7bd09fb9702063204a79c00df06f129f391e552fc8f17fd5be6348b", + "application/single_app/functions_workspace_authoring.py::read_group_editor_record": "0f34598d5c6c46b12673b31c4a2d443dd340dcd15f6368c20fd5768d37a174bc", + "application/single_app/functions_workspace_authoring.py::read_group_merged_global_record": "f7aabe56edb2cefadd4bf681188fc1a473b31d727bb4874f8a2f7934e45d7c9a", + "application/single_app/functions_workspace_authoring.py::list_group_editor_records": "889a39c4ad546b8e5b135797994d272dadc313cad160de4f5f65fa48860bb924", + "application/single_app/functions_workspace_authoring.py::_assert_group_available_name": "a503c32e250707c98290c0a9973fdbb6c4d045270b8cb55164ad49f4dbac5237", + "application/single_app/functions_workspace_authoring.py::save_group_editor_record": "aefa8c9b1f702102555135df952164855a7d0207d9237523d55cb63cf36ae468", + "application/single_app/functions_workspace_authoring.py::read_global_editor_record": "4727d2efda172275caa660e1426a9d63db61cb48e10a767d73e14afb184ed0ab", + "application/single_app/functions_workspace_authoring.py::list_global_editor_records": "19634b0afb1e3691922fc402c169a7bd2a9caf5cee3f2e26a2c96b5e319cbc33", + "application/single_app/functions_workspace_authoring.py::_assert_global_available_name": "b6923e866f1e01a28b8e85395084b697bdb90cf9855d5296a88d6971e33950f1", + "application/single_app/functions_workspace_authoring.py::save_global_editor_record": "96d36d2900a3da68dc8ec1d41557949f82b9f117f6f9cde9223b5cb6c7efe9a4", + "application/single_app/functions_workspace_authoring.py::_assert_available_name": "9e729b2e15fe012c62dccb152a8c73449a3ea7dfae2c841abbad48d1ed9c9120", + "application/single_app/functions_workspace_identities.py::list_workspace_identities": "4c3c59d6b050d1fca8dd925d846ca0880b8654300c4f9818660c747430faa9a5", + "application/single_app/functions_workspace_identities.py::get_workspace_identity": "a5001270da312f91f9558bab35792ca1c774f97b8d182e3a99b205065e82b9f2", + "application/single_app/functions_workspace_identities.py::update_workspace_identity_conditional": "b21cc17006b4298302dd08e500576fd1e66b326e5bd75074f18249e93be0665a", + "application/single_app/route_backend_agents.py::_load_all_agent_records_for_default_migration": "23a840625a3965fe6f6fcd03519321ca9af7ad1e4b81b587e208da787afce90b", + "application/single_app/route_backend_chats.py::_get_user_message_image_context": "4dd0e8dc61de33fba33d6e9f2e6ef10f973142ec6e1c8819cc80c23b05f0ee36", + "application/single_app/route_backend_chats.py::_read_recent_assistant_messages": "aff744388fee1a2f526865ab3de73bffd99d5b6780f5acaee187297dae1f2b1a", + "application/single_app/route_backend_chats.py::_read_agent_citation_artifact_payloads": "760c136550b10967520cd947ae5a7275ce47b3a8cbe0ff85c5e52a6f0733c142", + "application/single_app/route_backend_chats.py::_resolve_chat_selected_document_metadata": "92dba0d1ca8977222ee4d876cd27214d9497f1bb2b727fc4937dfca91d49afe8", + "application/single_app/route_backend_chats.py::_resolve_authorized_conversation_context": "ed36ddb8756056ba924b8084dbb6500ac4410e77ee4bc94e0d2edfb3bcf1b26b", + "application/single_app/route_backend_chats.py::_load_user_message_response_context": "e4bf88307ddec13b885982ab50d610c8332239af73dd38fee27ce93b1b7e8923", + "application/single_app/route_backend_chats.py::_build_tabular_related_document_catalog": "cdc0f8e04a04b3d2bb9656a403b221245b45c417e536cc07e61006dd9533305c", + "application/single_app/route_backend_chats.py::_save_chat_user_metadata": "3a16c24d6a7866b0da433f1ee8388e358b2aa24acc9095c50c3d25df9cfdd446", + "application/single_app/route_backend_chats.py::register_route_backend_chats._resolve_document_action_selected_documents": "a623179aa00cb852ef107309845e6e7c75af1aab96fa438a1ff80972700d9c7e", + "application/single_app/route_backend_chats.py::register_route_backend_chats._get_latest_chat_thread_id": "fb1d9a5d373fc51c862566551a1c9abcb1b92a58d1ceab15ce242f06d4cc590c", + "application/single_app/route_backend_chats.py::register_route_backend_chats._load_or_create_analyze_conversation": "4a670796d37d7fe9eaffbe8ff2986f1cf20223db310870d64e8454a26d40837a", + "application/single_app/route_backend_chats.py::register_route_backend_chats.execute_saved_analysis_chat_request": "49cfab0cd08b3c4d7094787fe588b2c28d00218326b91c1e8295fdd5e21732f8", + "application/single_app/route_backend_chats.py::register_route_backend_chats.execute_document_action_chat_request": "b1c12e459fd95790e53b737932368c262681da8fe968c0abdfcfe917e21880b7", + "application/single_app/route_backend_chats.py::register_route_backend_chats.generate_image_from_proposal": "c66e2bf1b7d04065a5a4da1f3dc17ca2936b1a31d263bd3bd6ded739bef66669", + "application/single_app/route_backend_chats.py::register_route_backend_chats.generate_image_from_proposal.read_conversation_image": "19693a51c420ac8f3b85458da0d20837f46cade6aa2cd348498dd0cf7e728158", + "application/single_app/route_backend_chats.py::register_route_backend_chats.image_proposal_status": "3125be935bd3b497fb487a7f57d869e101d5595e8fdfd292b571e196f71a3dbd", + "application/single_app/route_backend_chats.py::register_route_backend_chats.chat_api": "7b62a538441519b9fd7d180731717bff0e1e06b30d145e94dd7988db83f9f657", + "application/single_app/route_backend_chats.py::register_route_backend_chats.chat_stream_api.generate": "db6f2d86c297e2599ff83bdc2d9e9c475df28a3917bf61a626b441ada0306cda", + "application/single_app/route_backend_chats.py::register_route_backend_chats.mask_message_api": "d23cc3a5cc6803ad0256f8af8ae8bc44a49213070bc615df625a40871e8f915e", + "application/single_app/route_backend_chats.py::register_route_backend_chats.set_message_visual_style_api": "52dcb8af3745c395e7b517df197695a96ccd291fbf2ae0ef893d1ade4f056ae2", + "application/single_app/route_backend_chats.py::register_route_backend_chats._load_block_revision_message": "be26bc2ebf68b98a36b3d97c098c2912066fd8acf48b10365a55f225c9d352be", + "application/single_app/route_backend_chats.py::register_route_backend_chats._find_originating_user_request": "69b5ef6b7c79f197dd463044ad6d9fc723c00e78c8685c1a601648d7973dc4d4", + "application/single_app/route_backend_chats.py::register_route_backend_chats._answer_raced_block_submission": "d66f74bf333aa0b52f1d9d7f74cada540396e25d6cb98fb284ff4440f9ea577a", + "application/single_app/route_backend_chats.py::register_route_backend_chats.add_message_image_revision_api": "546d1c71d327da40dff6b9acf9c17a0010a67c081b56ba73a2d7fd58816d3fc5", + "application/single_app/route_backend_collaboration.py::_read_source_message_doc": "5d0160630390a148ed5eda28cb03eeb0089a6231f2eb274561d89d35429fde33", + "application/single_app/route_backend_collaboration.py::_sync_collaboration_mask_metadata_to_source": "690239415e92bce6acc5ac0d8bfd1d401c539bdf6d78b8639b35958e991b2c54", + "application/single_app/route_backend_collaboration.py::_sync_collaboration_block_revisions_to_source": "11bfc552a7ac4d90e4128bcfc46c20f4c1969f46f2f46a56d1e130b4fb01f096", + "application/single_app/route_backend_collaboration.py::_find_collaboration_originating_request": "a696f050ee172546aed5a25e31ab19ec50d2574191fb7c33a30f38d91760b28b", + "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.add_collaboration_image_revision_api": "d5fc873f0aacd162c67ecc313e2e0896bd807f69049523285191d978584a2b15", + "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.stream_collaboration_message_api.generate_stream.transform_event_block": "69bdabb8c98414cfa5149c952da450c76c6833e77be4d0e1e4a68ae2a93a9f93", + "application/single_app/route_backend_content_screening.py::register_route_backend_content_screening.content_screening_update_configuration": "5e28a46d1592f13669c6eee30e048d1892f8677980b123d419b42414d4243a05", + "application/single_app/route_backend_control_center.py::get_group_token_totals": "423516e4c1b2d4e000d2adf4e4ec82b9fefd7794667f80dbdea1889244c5c431", + "application/single_app/route_backend_control_center.py::get_group_name_map": "b739fa7523308c1ddfb2586a9d1b1930da3b897d27c5d4e5403567434a7e237d", + "application/single_app/route_backend_control_center.py::get_public_workspace_name_map": "277c0f087dee170e7f3e810cbfe4a9956995a6e70fb7a6c4c3bc2c58f1c1a427", + "application/single_app/route_backend_control_center.py::get_distinct_token_filter_values": "8987fd24ee69f7c23be4c3d7ba36ee5e7ff264b385140d1334c8429fd03971dd", + "application/single_app/route_backend_control_center.py::get_activity_log_user_details": "dc5ba27e81937b71d9a752d3ca356a62f41045f97f6114f2d434ca75eb0443a9", + "application/single_app/route_backend_control_center.py::enhance_user_with_activity": "5d352e3feb35f32f734692869dbf5aa7031254664e550477586bb775be7fee4c", + "application/single_app/route_backend_control_center.py::_control_center_count_users": "a9b77d0f7521cafc59b40f3f89e2d5884442ec7785b8e99491299b099c306001", + "application/single_app/route_backend_control_center.py::_control_center_query_user_page": "7822c3640b9fcb0b58215b35390d838045b19527ce8884efae5a2ef06bd98e9f", + "application/single_app/route_backend_control_center.py::_control_center_iter_users": "d6e706933c48bc54563f87a04ee6b287667d7d6af87c79e3fda363c0124a44fd", + "application/single_app/route_backend_control_center.py::enhance_public_workspace_with_activity": "9e5f1af3a1a066ad3e0c6f4cb3163b996eaf2185378f6032d62cd717ac4a0930", + "application/single_app/route_backend_control_center.py::enhance_group_with_activity": "86cd5b73680c37f7d068b0bd1025e4672f919cff5726236a0c8f811e1900b33d", + "application/single_app/route_backend_control_center.py::get_activity_trends_data": "c4ac303ba8156a87501a2deae2a364848a086a377f89e7f6505f0b7f6752bd8f", + "application/single_app/route_backend_control_center.py::get_raw_activity_trends_data": "8cac823f98d4f6d85004313f6d0dc5490e3144a2203aebc76df73c6a12107a26", + "application/single_app/route_backend_control_center.py::get_raw_activity_trends_data.get_user_info": "2f39f20d86c664b3be0f49998be44fc0a7b6677cf2df99b3ea785e69211e3694", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_all_users": "7491ed41b8ac684abd7b74b3949064a68b39eabb4848d78c72206a65c3ade0b1", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_user_documents_admin": "f385d0693caabedfbdd2157add7970e58972a230d78130539851cdb163a4ddf4", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_user_detail": "2895d3112709cda5de3f0160be253c4b2ce272c27408212ce95d3b03ebd84c7a", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_users_bulk_action": "56f9a62a4c52f259da101009900246cd87be90223988f74e06b3db8caa745c5b", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_group_detail": "cc53d41992dfd7b6fa2402d6fca86fa66d2b5836a77b45d4f17b88b323f09859", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_all_groups": "10eddb88ff7981a0088a02cd1060fa3102479efc8d7fe6fbd074840533123cd8", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._update_group_status": "78d4fb9dde47cd2fe5b3a3833ab4f4350b0b2a6ecf3c7dbedd68af6d0bc87db6", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_group_details_admin": "b1cbaff9b76e3a170f7ad4a01736ab78e6236f7aa1b13e7eb0ca584f6d61474b", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_group_admin": "f437e612e8df51347d8dec90be4249d2ea26fb8bb61d6421350464921cae73a2", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_group_documents_admin": "f6cb8c889829fa9b15fa59ef6c1cd2154adcb1c623b3d89348381041b4d2f376", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_group_members_admin": "3e9f090f9d8e9690ec027692f5d822cb0bc8b78cccda1292942a4fe8a6539953", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_take_group_ownership": "8352cde08485a77a543a2d031ec30cb75b129cfce3870b1fd34487e9c3253c50", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_transfer_group_ownership": "100f686ef815c81c1b15d5575c035a00398b79a050e04a0419d72d44a663b2d7", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_group_member": "82f9774088e2bc44e9445cece804e63166a89a292fb6dc81642a2ba03eefe31d", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_get_group_activity": "0bbbf914df72d1f3913121901c760880922df50505a1a1e4e4bc47eb65ba1da4", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_public_workspace_detail": "2b8eee631a541612c322e31ec3da8c08047e57d024ee6b9e8f7fd7679d517304", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_control_center_public_workspaces": "8f9b253018b2c4e599777c2b4a2ede3112eeefb802de036ceb93461712bbd750", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_update_public_workspace_status": "d29becbdc74ac4a055b4c2a0da303267934447a146abfcfe383da60d652f3e4b", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_bulk_public_workspace_action": "78ebc9d1b511723f64de29a67d083e141db70f5324ac6449218f622174327ca7", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_details": "77f6f7ae1f5f80e669d9ba9e096945573240ca962052a27fe7c786fe35205ae4", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_members": "ced8e9f2c03c618b018b4771435cd7f192e1122bd006bac95988ab9af62db520", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_workspace_member": "64d0430c14fa59c233061e09dbe6562c37a93af5a6646385ac1f8db705b0cdcc", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_workspace_member_single": "6496b2cec0b3939140c1126c1cb9508471fa404bc8ce3f88a3e6571a68475349", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_activity": "6a098271219b7c37f02ba2d756fc7ee52e3db2430fdeddca0dce52dbde837a64", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_take_workspace_ownership": "95fdfc4a78725be38fb2db4afb541a1c4c7d55ba95bb918b3a1d641764370014", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_update_public_workspace_ownership": "13fc0aefb3ab593cb773bf87de39680697a40a22f2b1dad1beeacf74860409fd", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_public_workspace_documents_admin": "a9a1d6bea92f5d6280abcc3bf3f3f71eaf1ea4160e303fc9a4ddbfb64bbf15e9", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_public_workspace_admin": "2dfe989f91fbecb37ac83fd8dd55311f8582263d8cb6eaaa4e3118ecdc3c591b", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_dashboard_chat_readiness": "393d7bab72591ef12b1dc2565ffcda9c0a4497df329d2a702cea55bebb05a78e", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_token_filter_options": "767cfe8e260b5a1238a3bc983bebd21d9ffb83851c19485f397f7737ffe92efc", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_refresh_control_center_data": "39220db6cea9ba9874da83db6bc1857821fb96ddbf63d24b1ae9125938b8e5b9", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_activity_logs": "85938428bd38221bedce8a5d7de7e314edea7370aebc8886a950cf5c2239dfba", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_export_activity_logs": "7b0f1e5aec29b7106183ed85346f6f4ba5b48187c35a584cf8d042d515e1f9f4", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_take_workspace_ownership": "b1367da4393fd93a1a52c6e062a7c049b84e3d88a88169d1e4ca239ddfdc2086", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_take_workspace_ownership._resolve_user": "4c6d533a5376b37d7fd38eb15ad98b4b53176cd6ce2b3736cda1418bcf5c31d4", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_transfer_workspace_ownership": "b3066fd823cafe3a8e9579e3fe0778391279fda4d4789a94bf48e2e9d8e5b0c2", + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_transfer_workspace_ownership._resolve_user": "4c6d533a5376b37d7fd38eb15ad98b4b53176cd6ce2b3736cda1418bcf5c31d4", + "application/single_app/route_backend_conversation_export.py::_load_exportable_conversation_for_user": "ca4f7705686b225dc75a93cf8f1e95682478fd1cb9cb25b99a51bfb95790812e", + "application/single_app/route_backend_conversation_export.py::_load_export_message_for_user": "b423a5373bedddedf3035705845bd9e8279573b342112c56518810ce633556c3", + "application/single_app/route_backend_conversation_export.py::_load_generated_image_proposal_assets": "e0a4bc16710f97f752cd231daee89f7263feccf9e6ce645de27896ddc667b529", + "application/single_app/route_backend_conversations.py::_query_matching_messages": "bd67bcd916b4d3fef1b7085358b7a4fada8b94904b9193a3852addbdbb198c98", + "application/single_app/route_backend_conversations.py::_query_legacy_conversations_for_feed": "cf3b0af7c14447ff7866ac74e97db726969ae1c0ce0ec7848552b467ee12fc68", + "application/single_app/route_backend_conversations.py::_count_hidden_legacy_conversations": "4d305e9f69c1d9f9ea5ce79a1c6f98aaa0e3603962afa56c0c3973baceb416a1", + "application/single_app/route_backend_conversations.py::_load_unread_collaboration_notification_map": "a8f036748f23e9b10225de8a768982776a975cc77886b39f2e3f4db7911afa59", + "application/single_app/route_backend_conversations.py::_collect_child_message_documents": "ff1d4330f278ca5fc5fe12fdaffd2feef73a1a22548afb76c588c537e170452b", + "application/single_app/route_backend_conversations.py::_promote_remaining_thread_attempt": "17b5297700a889293692dea0bc4aa50c8ee01694713617e400ecbf37023a28a8", + "application/single_app/route_backend_conversations.py::_authorize_personal_conversation_read": "1a760f636b7fcc04309c1bd58c8b0917f85e755035c32cbbd3d3c54d84c9c19f", + "application/single_app/route_backend_conversations.py::_list_personal_conversation_generated_documents": "3386210857478ef4bdd0c8e85438c569be8e5315ce70ed60be62897c313a21e6", + "application/single_app/route_backend_conversations.py::_load_scope_lock_conversation": "f3fb15e9dac79f689d80184c22b1d1b520111e91b406cd73020862ab127bd442", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.api_get_messages": "35b92bca28ce1e9497e5df23d706756e0002b090a81bb860e8e2a7084df3d8d8", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversations": "c0b0ee534e32bdbbe20a5a71e51a7ba648b79b9c77f37ddefb424e7060d55710", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.update_conversation_title": "cdb3602338782a1b843876bf4561e6db620d80737c0064540acb00e74affd2e2", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.toggle_conversation_pin": "6e91ad276946a1ceec5fec3175386d916616a30fcc4f2885d82855f576ad9552", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.toggle_conversation_hide": "d3205eb93784767f6c53bf208f4fe0f76477c06dfa1bbb7f5f672b801fac1cec", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.bulk_pin_conversations": "73b9ac90a0b2df2cccb594511be435c1e099a5d99803a9d144d3ac1799a82308", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.bulk_hide_conversations": "62c38fb0c174ac755afa8fbe2f5cb0619687ca3e3d136f7787c87091ddc1ebfc", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversation_metadata_api": "40031fe0d8412ad41a92001c783ab21d96cf24c260f2f73c26cf948aa0be0f08", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversation_kind_api": "7a0eff800ca6b15d1b4a512201d67ab5dbaae696948f8b9ecba8598730427fd7", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.mark_conversation_read_api": "b47e6aaee897a1e1af275af54f2d9d7bccf56a1524031ff105bb7ba7103f6ffe", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.generate_conversation_summary_api": "7ff7eba0bbab9aea3dffb5adc7493cef9ae8c1c44fabe991cb37a7ffbc2436fa", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_user_classifications": "91a7442f804e0dba28ad2962edcecd0e808d452c70f20c48b9daf0cae2997b74", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.search_conversations": "22716d3bea7e927300299218c515a69bf2aa5b20349f758b7fb50e2d8a667cc9", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.delete_message": "50c338fd82cef1394cb64e4a9b6b4653c99d08a477aa8ecdf76a7c8064fa719c", + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.switch_attempt": "7da244c36ded68e83e17208cb38ef6f3f6b93d55f75d3185f56c96c084e84b0e", + "application/single_app/route_backend_documents.py::_load_accessible_personal_documents": "c30706d4a4f55e432daf154e9f56ff6937167cfb89682658c1fecacec0d4b6f4", + "application/single_app/route_backend_documents.py::register_route_backend_documents.get_file_content": "68a6779aa45f86f39b70204731c10eb41dcf31c9602a14cbbfefb625148a025e", + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_get_user_documents": "b81faefe7664165df55537ee7dbb81b7a6fc70b24285b217e68bac72caa03bcc", + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_bulk_tag_documents": "f275b79c37f49904ba026995bded04bf6e080de97e98f1f4cd996a54b1e80345", + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_update_tag": "15ce812213181ad82cab2088baa21e2c6007dad4ab3bc3753ffaaad70113dfb6", + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_delete_tag": "5e8b87a738b333a977f79c982e7b0beba82cfffec209859f97c2d6f6a2b6b7a6", + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_share_document": "3f596961340f7c38c7672acf447020be3deabfcbb259c4d370e18192bacaa4ef", + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_unshare_document": "1a600bc5aea1d28e62c67c6c23a118975c8a956b43299060d7eb4db8834917b8", + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_remove_self_from_document": "440a94d1d29bcb460e985f9931913042a73e30a9d3dfbf76dc4ab53529be58cf", + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_approve_shared_document": "f81a4d9059cfb878117c73af41fb61b924b25e6998b9f1f744abff8330e44083", + "application/single_app/route_backend_feedback.py::_authorize_feedback_conversation": "503eebf0fd7a1c3f29ea3aea00f580303bd7b9be9b8e60315b2942736a04d7c4", + "application/single_app/route_backend_feedback.py::_query_feedback_items": "252878ebe98d82d375991e2091193dd17e4005cc7a3d522b51ad2ff0e09ac857", + "application/single_app/route_backend_feedback.py::_apply_feedback_review_update": "54c1024e778b5d8bcf60470ec1945faa6befa362d0f85634e72e9d2ca941fc08", + "application/single_app/route_backend_feedback.py::_archive_feedback": "cc77e1e00c5d3aeaca393a46667704fce90f6e2c13cf1be2888b0126d1c6b864", + "application/single_app/route_backend_feedback.py::_delete_feedback": "da115d51c7bdfc5a06e7056ddcec3cb010f691d0de6b63719411c5ff56e0b8e8", + "application/single_app/route_backend_feedback.py::register_route_backend_feedback.feedback_review_get_single": "d0a0a5069290df0c4d69799291ae92fd56f634ddbf723698729c436f8441ecfe", + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_get_group_documents": "b6778fd74936353c1eadc8b822265a267e2f66deaf6de6d89d0dc7cfd8e64815", + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_delete_group_document": "602cdb6976dff436cb7a86ba3e39cf98ac4840cc59bee321afbdc9a5f093b818", + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_bulk_tag_group_documents": "07ae5fc457a4d09d9d3ce1b581c73e40984c75b9109ec2bb0c424787ea794796", + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_update_group_tag": "0e18487be91cb9b2b48e80e6517dc8e139ae1c510298ebc7c6cd2d09418b0a45", + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_delete_group_tag": "9e2049c3d8ad45fd190080c5a8d955395e5b2e1caae3237e473624e1be4665f2", + "application/single_app/route_backend_groups.py::register_route_backend_groups.api_group_activity": "b68cf13c1361c5df6a62e49dd97426deeacf9389b2889dcb7efc02697d528696", + "application/single_app/route_backend_groups.py::register_route_backend_groups.api_group_stats": "99baefcd65410b84b8eef2e3c7a2113dc43b3a16444f930e077e4c9311f98cf7", + "application/single_app/route_backend_m365.py::register_route_backend_m365.list_m365_waiting_requests": "a08dfc34823a0019c09d30bf38f7e25ac1dfd6e81944665f3912f2e4daa7a73f", + "application/single_app/route_backend_orchestration.py::_load_ledger": "b357e0ed06bcbd5c4c05ba3e0d5880f51f6cc85b2cfa92c249b295231706ae16", + "application/single_app/route_backend_orchestration.py::_authorize_context_conversation": "8b319a23b132fe5a74781d4588acb97d8f98a366505f04552c8706ba489756c4", + "application/single_app/route_backend_orchestration.py::_load_regeneration_snapshot": "961acd489e27b0e17285cbffd8a7cd2fcc13284049e418b2469c029890f33958", + "application/single_app/route_backend_orchestration.py::_link_regeneration_thread": "f29030a01f8bea411281355214c714e64732dd013d7b1df5fe4c95a71d657c5c", + "application/single_app/route_backend_orchestration.py::_load_conversation_snapshot": "3500321d32448a7b9d72e6fde2a31ed4e96710eabb43e8d755bddd49db202339", + "application/single_app/route_backend_orchestration.py::_validate_saved_conversation_context": "96d03c916384f783c266fd1f25d881eaadc9e7530e5bfb082189f33a799fb3dd", + "application/single_app/route_backend_orchestration.py::_conversation_context_for_run": "dc5ccbb792e52fb9d132c68c0f4e9c3ab0e7864885b236bbd6ed4c34620ed92c", + "application/single_app/route_backend_orchestration.py::_ensure_conversation": "ad39a61ca6d75d734a7cb9ab1feb08d5e3a249671f5dd2ba5a497de37d1a8c23", + "application/single_app/route_backend_orchestration.py::_mirror_planned_turn": "456b1aeaf2bb712973dd90f016a778bfb4ae9928deb01d64f7d098d3f2167259", + "application/single_app/route_backend_orchestration.py::_persist_planned_turn": "15302dd953b0e4805d7b84cd60e11eb606fa3577e3ace194463abbb7540ff6a4", + "application/single_app/route_backend_orchestration.py::_save_turn_message": "05f1f7e6bea87481d2152914467671d5139c44f18c8eaf8bc53e9cea0a0540a7", + "application/single_app/route_backend_orchestration.py::_touch_conversation": "785d71237d18b92269fb287f0efa5c85d4ec32ec027fdcc43c7dfa51bf97357d", + "application/single_app/route_backend_orchestration.py::_run_response_removed": "8f67cd9aea5fe4d256450c1f2154edd21bae33f4951a29a0940a6e88eccd52b0", + "application/single_app/route_backend_orchestration.py::_validate_checkpoint_artifacts": "3ba819deb0325ec83ff22f22ff21b0e3ddc43094954db6393fac862a66f21914", + "application/single_app/route_backend_orchestration.py::_checkpoint_artifact_versions": "1f879fbce6e7528314527a5b3e85272fc7bb75a838c53aecc4a308ac9285b380", + "application/single_app/route_backend_orchestration.py::register_route_backend_orchestration.orchestration_plan": "ef569091b1ec9c85e4304487d363cb779e3e58b124962b9d2f0940d397bdc06c", + "application/single_app/route_backend_plugins.py::set_user_plugins": "6521a2fc13713578fcabc57c611d5a73467630fe3b4006082b579cb1dc7db82a", + "application/single_app/route_backend_plugins.py::edit_plugin": "e4294468015daedc797eb287aa58c9066c8efe91a9f593a07936b55da9e3e1b1", + "application/single_app/route_backend_plugins.py::test_cosmos_connection": "2914add8869a52f46cf5639d26e9dda1a163ab1b980935aa459b85a760b3c9be", + "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_list_public_documents": "b0b7cc677cb6d11d97c1f0d775014169a291ec9898422143eec7fd4ada86cea9", + "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_bulk_tag_public_documents": "a2968b28e7f8056dd6499b1ca7a36a97b94f36f8b2d81b12122f266de48e1fda", + "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_update_public_workspace_tag": "9b3fd3ebf2c212c75b3c01eeee72bb397b575ec95df85841a31b64bac6483aa2", + "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_delete_public_workspace_tag": "64de1e558404a1b27191144c3971208ec10ae0ffda24f7a979e9ff1a33cc896b", + "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.discover_public_workspaces": "062c6c6441e6af64ba3ad877183fbe0c6e5b1b7557e4d98888d37ebb255c2300", + "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_file_count": "81af253b9f8a788afaa40eed182e0a941eab4c63290cf512516a0ccd8ae29ec8", + "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_workspace_stats": "0c7b1bca8b55d4380e5fede0efcf6f785f8e4657006c7b65e2e2eb02627c294c", + "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_workspace_activity": "e2be6afdea86463c00a38feb38c3c8448c470ae1f16068b0842a9e4160ff997c", + "application/single_app/route_backend_safety.py::_query_safety_logs": "b988e96c8a9ce9ad80d6794c8fe2af4fe9e3665682594e97f385b058032c8249", + "application/single_app/route_backend_safety.py::_count_other_user_violations": "2697e8c1f3aa4acf8dba9bddabc99f519d6b7afc5e08feb80d9c5c8b59a64198", + "application/single_app/route_backend_safety.py::_archive_safety_log": "db45f5fdd95f86ac70a29fe147a96e477ce0a5bbbad6e24a57a1b20ff0bf26e8", + "application/single_app/route_backend_safety.py::_delete_safety_log": "46d8f4014550900eb2d8a5d2e4e8e7fc72dbab7c6fce3ea065a5e1a235b5be7b", + "application/single_app/route_backend_safety.py::register_route_backend_safety.get_safety_log": "9b3ff1421aa8c1bc25ba3797ff818689b21593bceaeaf58490e29c77af312408", + "application/single_app/route_backend_safety.py::register_route_backend_safety.apply_safety_review_update": "0a2d2a0b9c4cdd2983c1b5577db6811df1f3f7b62e85f33bf3321c6aad7a80ef", + "application/single_app/route_backend_safety.py::register_route_backend_safety.update_my_safety_log": "de00204b03e3d3fc15c98272d6adf829082d6cef7957d851566d7346fbb485dd", + "application/single_app/route_backend_users.py::_has_shared_document_profile_relationship": "15549f8856420bd960a302173716b3bcb72f504c7b8b3439f08eda74788543e2", + "application/single_app/route_backend_users.py::_has_collaboration_profile_relationship": "f5232db56d8a0fd0fe07850ebb7b8eca9513adf2726c3b209eb8d60b587536bc", + "application/single_app/route_backend_users.py::_read_authorized_user_profile_document": "e688d444fe9c984a5ba523afdcf389eb3dcf607bd1aa75d299224d20cbf9d6d7", + "application/single_app/route_backend_users.py::register_route_backend_users.api_get_user_info": "d8d706d12b688508e1b6d3ef6c2015ab8a3c4f99f3fa404bebdc6c3805f78cfa", + "application/single_app/route_backend_users.py::register_route_backend_users.api_collaboration_suggestions": "aa7205083648342089c7b7d6ab2d17e54e0947471f882ebe5115c933c09d296a", + "application/single_app/route_backend_workflows.py::_load_workflow_conversation": "05c1f20c8ca70f207d639096b281f5a012b3fa5af4bddd15db1f39a62044bfdb", + "application/single_app/route_backend_workflows.py::_load_group_workflow_conversation": "19f4c69cd41c04d4a57a04d7c1a726790ea8886c95955b02778b7e9cf0357721", + "application/single_app/route_enhanced_citations.py::_get_authorized_chat_artifact_message": "b2d9c0fc54c4cf9545a6c46bb93b71c0e1a69d429c8ef1c05ba3fb071582bc4b", + "application/single_app/route_enhanced_citations.py::register_enhanced_citations_routes.get_enhanced_citation_tabular": "ff7e5776314ddaf82390e3ac0817fb8270307d32da2b29a7bf4f4c7ef529d61e", + "application/single_app/route_external_public_documents.py::register_route_external_public_documents.external_get_public_documents": "7a2cab5fcb36b8d80f2733e2a3fa2df33e04fbeeea7095bec72bf185778aef02", + "application/single_app/route_frontend_chats.py::_resolve_chat_upload_context": "ffacf10e9ecdb47901fa0deb6665e82bcdf06b7cb701feb024f76ab6db06d854", + "application/single_app/route_frontend_control_center.py::get_control_center_statistics": "6fd3ab6692fe40b5e63490edcdae51eae7ebeb8067996c361cde4cac14c296e6", + "application/single_app/route_frontend_conversations.py::_authorize_frontend_personal_conversation_access": "a8650a20c098eb598306d3827dce49f4b4c1501404cbd3b200d4887b1fbde552", + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.conversations": "a1d6c7ed62f7b68cb59058ec65e83993ef1f9756d129e439a9bccdc2377ea365", + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.view_conversation": "5605cc08339c44a4a6d96ecd2867502c7f72a1d14e3345b097694f37c3c475d2", + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_conversation_messages": "311bb87fbbd1decbdf0fbf2f38b07eb2f53ae4b63a6427ea174fe2633092b1a0", + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_agent_citation_artifact": "251ee3cda0bc51a737286bff3edd5d5e6798c2d56decfa53e857dcb042a12dfb", + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_message_metadata": "449aaa2f5eefc43ed0e79538d4e8b96e597606385bbd7bcce6c1a5721089307c", + "application/single_app/route_frontend_group_workspaces.py::register_route_frontend_group_workspaces.group_workspaces": "858b1f3fae6f620c188deccae45fbc0bb36c547b256eb2778674a61d5b457a14", + "application/single_app/route_frontend_profile.py::register_route_frontend_profile.get_user_activity_trends": "4e77fa404db34a04c1ff629be4a1f9750983cc51d7e6b4b7cd6b3a45005c3796", + "application/single_app/route_frontend_workspace.py::register_route_frontend_workspace.workspace": "f4aa40b5dfd477a28b7aa42a7814c6e40cb2c18b3716422ff98bd2e7a17809d6", + "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore._persist": "058544a18a2fa5d0a002dc86ed006881ba5f7d62af85eaea5980b840ae78c557", + "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore.get_fact_item": "d598bf39e54ffc8deffb80f8849af5be09c95298e2e8ec924cc5cf20ac2fc643", + "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore.get_facts": "c47f491a6b30d544c701fadbe40bbfa9e98087580acdc8a5279b057e286b214c", + "application/single_app/utils_cache.py::get_personal_document_fingerprint": "7ab8b6a433436d886a2b98a3f0336d83a179fbb9baa8e48b9a9b67bde72bc786", + "application/single_app/utils_cache.py::get_group_document_fingerprint": "c7e5e536a8fce0c6ba3c69f828b3652eaf6e03bc2c6153ba5fad02b44c71bf04", + "application/single_app/utils_cache.py::get_public_workspace_document_fingerprint": "cf44b6a756886f8d14cba57767472dad83703709de8b9a31377f1440439d7055", + "application/single_app/utils_cache.py::get_cached_search_results": "4c24784d719d93138cc238294bcbb48495017d5fab9bcd3116b46956508789fe", + "application/single_app/utils_cache.py::get_cache_stats": "f48421c3d10e9a46c24928c2fbcc589d0fc2f4c1da2c3c57deb1c5b5c027c3e8", + "application/single_app/content_screening/access.py::_read_authorized_document": "1d5f877cb1966e170726afb1af4174077088ed736e251b2485907233a22cc61b", + "application/single_app/content_screening/access.py::_require_release_proof": "a5741b6d5b477f9040b26d00ed7d5d27fc6a08b163131661e82c3590cac3a44e", + "application/single_app/content_screening/access.py::_resolve_native_evidence": "da94507496871c2b4e67641081394c0c40c9f3aae56397973dda60e583df516d", + "application/single_app/content_screening/access.py::_resolve_blob_document": "80fd674151d89e0534045aacda28226a04cc3e26232a805d39b963d5bd74f8cf", + "application/single_app/content_screening/model.py::_resolve_settings": "31bcf63da58ac891b769e32614ab769c5e69b5c6a68162fbcc1ce3cf5258677a", + "application/single_app/content_screening/repository.py::_read_page": "fb3ed3b2186fa1ea0b0a3e6150dd2d4c4601869e69cb52adc807c24390037b4e", + "application/single_app/content_screening/repository.py::ScreeningRepository.get": "a004a1206c78da432cf2645df25146f7d1f120786f0f56494caec38472cef0b8", + "application/single_app/content_screening/repository.py::ScreeningRepository.create": "44951648de6d005e0e729ac179e240dd3b0443c02a949af147e44fc502596783", + "application/single_app/content_screening/repository.py::ScreeningRepository.replace": "c573bc829ab09aec635667fed1d36f82fc0e3f9877420575061cd429b09707fd", + "application/single_app/content_screening/repository.py::ScreeningRepository.count": "c7618b8a8001e74d1a9993be4ccb88d44d2accace184d13703bca73d9a284a96", + "application/single_app/content_screening/repository.py::ScreeningRepository.read_document": "519efcc10e1e1b7c77602a26f9541b66af67cfd0a3c1a48e93614e4aee1245bf", + "application/single_app/content_screening/repository.py::ScreeningRepository.update_document": "1d952006fe70177b47a8461efe01e3f51ccb0097898eb44927ca69247d81b52b", + "application/single_app/semantic_kernel_plugins/cosmos_query_plugin.py::CosmosQueryPlugin.execute_query": "f152f3d02d6f16db68314a2b3abdf0f5980750a43429dc4ce71080e20cced7fe", + "scripts/resolve_multiendpoint_gpt.py::fetch_settings_from_cosmos": "f4455768ece848c45391f567540ecb90c3aa85e10ef1da84b880a326af7b79f8", + "deployers/bicep/postconfig.py::": "ab2f59030e95975bf89a77fc91e4bd1067570f8287b14795505d1e0d080f1561" + }, + "owners": { + "application/single_app/app_settings_cache.py::_read_cosmos_cache_version": { + "boundary": { + "sha256": "ee8d7a9b4f1e28bcb5e92a7079a51a38a58985900c62778a5557ce1f4dcc728d", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "31c7d8fe101b95f85850202b5116bf45762fcf33c66bea61aba74fb51a36468c" + }, + "classification": "sdk-compatible", + "contract": "_read_cosmos_cache_version: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/app_settings_cache.py::_bump_cosmos_cache_version": { + "boundary": { + "sha256": "94fb0eb8a5eee38d044e6ed3f7db37c3fbf2cea2db3f829fc53d063bbde6de16", + "points": [ + { + "method": "upsert_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "31c7d8fe101b95f85850202b5116bf45762fcf33c66bea61aba74fb51a36468c" + }, + "classification": "response-unused", + "contract": "_bump_cosmos_cache_version: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/app_settings_cache.py::_set_cosmos_cache_entry": { + "boundary": { + "sha256": "64c1263f1410ca12ff48600ebc167a6e33588a2148b5c7c8033e3ccff6dfd7a6", + "points": [ + { + "method": "upsert_item", + "receiver": "_get_cosmos_cache_container()", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "31c7d8fe101b95f85850202b5116bf45762fcf33c66bea61aba74fb51a36468c" + }, + "classification": "response-unused", + "contract": "_set_cosmos_cache_entry: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/app_settings_cache.py::_get_cosmos_cache_entry": { + "boundary": { + "sha256": "d41e20b1a45eaae5cd9d8288f398ac59ec6796f671457f4b6f7d35e7b535a018", + "points": [ + { + "method": "read_item", + "receiver": "_get_cosmos_cache_container()", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "31c7d8fe101b95f85850202b5116bf45762fcf33c66bea61aba74fb51a36468c" + }, + "classification": "sdk-compatible", + "contract": "_get_cosmos_cache_entry: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/app_settings_cache.py::_delete_cosmos_cache_entry": { + "boundary": { + "sha256": "c7470f5d5ecc0525f11daaa1b6e2acf5a4a1ddd302a2dfe27d67830404cb8e34", + "points": [ + { + "method": "delete_item", + "receiver": "_get_cosmos_cache_container()", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "31c7d8fe101b95f85850202b5116bf45762fcf33c66bea61aba74fb51a36468c" + }, + "classification": "response-unused", + "contract": "_delete_cosmos_cache_entry: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/app_settings_store.py::AppSettingsStore._read_cosmos": { + "boundary": { + "sha256": "36aed858c8e90028d1d8ceb2f78f2e373d463d6fa8f7f6f257fd523582c1f09e", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5001ed2aff39810164525a95297eb373816d653959c2589a161ecf2039ac6277" + }, + "classification": "sdk-compatible", + "contract": "AppSettingsStore._read_cosmos: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/app_settings_store.py::AppSettingsStore._write": { + "boundary": { + "sha256": "2d33863c40cf1154b7ee36b48349a1f5d95922756f99658071f8565a66c1c164", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5001ed2aff39810164525a95297eb373816d653959c2589a161ecf2039ac6277" + }, + "classification": "sdk-compatible", + "contract": "AppSettingsStore._write: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/background_tasks.py::acquire_distributed_task_lock": { + "boundary": { + "sha256": "a6fb81a6f542346f77124dde4190a8a52a13aabc0e6f7f1f60d5aac6013d3170", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_settings_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6e2ccac24a828d77e3f60c57fe00a74e8f541bd943c9e5b54bf9d40fc44f7b83" + }, + "classification": "sdk-compatible", + "contract": "acquire_distributed_task_lock: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/background_tasks.py::release_distributed_task_lock": { + "boundary": { + "sha256": "db34f1f61e312fbe0f21f5f67348acc052e0836093aba6cc31e76bd716bbda52", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6e2ccac24a828d77e3f60c57fe00a74e8f541bd943c9e5b54bf9d40fc44f7b83" + }, + "classification": "sdk-compatible", + "contract": "release_distributed_task_lock: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/conversation_memory_runtime.py::resolve_memory_context": { + "boundary": { + "sha256": "1ef346ae3abbebf2650c76a61cb86d9ae9924bf443e8679ff9c2a7f344917af7", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5e9da644ef7c8aedcd45f11d0cc44a315e69bcd6ee2bdc026da10ee91db40201" + }, + "classification": "sdk-compatible", + "contract": "resolve_memory_context: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/conversation_memory_runtime.py::resolve_m365_memory": { + "boundary": { + "sha256": "ea6bc48a41c8be5c3e4957b1515891506ec7435e75f0a07c125926a9236f007f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5e9da644ef7c8aedcd45f11d0cc44a315e69bcd6ee2bdc026da10ee91db40201" + }, + "classification": "sdk-compatible", + "contract": "resolve_m365_memory: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/conversation_memory_runtime.py::register_memory_artifact": { + "boundary": { + "sha256": "6c699ba7f4ed701eda5e93d8009f2106784be7426a25d3e277a108503a12a0fc", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5e9da644ef7c8aedcd45f11d0cc44a315e69bcd6ee2bdc026da10ee91db40201" + }, + "classification": "response-unused", + "contract": "register_memory_artifact: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/foundry_agent_runtime.py::_collect_recent_chat_upload_file_inputs": { + "boundary": { + "sha256": "a29b57f7e4c84fbc8d598d0dcaba8727634debb59967609cf454a35a7e570c9f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9338053de31f2d2fe025fd18ac0198293c2c4cdef2e6860ef042d6a4ebe5f528" + }, + "classification": "sdk-compatible", + "contract": "_collect_recent_chat_upload_file_inputs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_action_catalog.py::_stored_actions": { + "boundary": { + "sha256": "58b88c32f9ed67dbe2ccf5e93216b98f417600f1a5793438fe712e5e7e959f87", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(scope_type)", + "response": "returned" + }, + { + "method": "query_items", + "receiver": "_container(scope_type)", + "response": "returned" + } + ], + "batches": [], + "module_sha256": "7ac0b85cba780b4f7101876cf5b3615f7cefbe62aea97fc933c00268d03f39b6" + }, + "classification": "sdk-compatible", + "contract": "_stored_actions: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_action_catalog.py::resolve_action_manifest": { + "boundary": { + "sha256": "b782347ae9ed41b1e30fe8d8bf70124cc9692c38918845e121023d468a2c9144", + "points": [ + { + "method": "read_item", + "receiver": "_container(scope_type)", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7ac0b85cba780b4f7101876cf5b3615f7cefbe62aea97fc933c00268d03f39b6" + }, + "classification": "sdk-compatible", + "contract": "resolve_action_manifest: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_activity_logging.py::_create_activity_record": { + "boundary": { + "sha256": "5fa92ae61ade75abfcf12fb6e4217a86bcfcdafee5130cb26aa835ddc195bbaf", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_activity_logs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "sdk-compatible", + "contract": "_create_activity_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_activity_logging.py::get_user_login_activity_summary": { + "boundary": { + "sha256": "bda6607b4d6a540d7d953d7475a0a43216249a44972097138ea10bdeaf7b43a6", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "sdk-compatible", + "contract": "get_user_login_activity_summary: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_activity_logging.py::log_chat_activity": { + "boundary": { + "sha256": "418794b6666375c40c9fd6354ef8bb47e9b57f8dd0dd9527c4a74d268df2d611", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_chat_activity: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_admin_feedback_email_submission": { + "boundary": { + "sha256": "01a51c586b4ad56f5b572b7c1efba5661a26b0d0b329b0dfbcbb6d9c5c34efb4", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_admin_feedback_email_submission: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_user_support_feedback_email_submission": { + "boundary": { + "sha256": "9d6b753d72476feeb9435464956e314ff82e9b32c092414554b802f522d3770d", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_user_support_feedback_email_submission: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_admin_release_notifications_registration": { + "boundary": { + "sha256": "1153617683df3b617615a6e471928502ba7a28c69ae4bc76bad0abf24da093d4", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_admin_release_notifications_registration: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_web_search_consent_acceptance": { + "boundary": { + "sha256": "38c7b0d811a036c41aa3ec34707ab64b9956b6fbdfa4dd1cea5f7fd8b51bbef5", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_web_search_consent_acceptance: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_index_auto_fix": { + "boundary": { + "sha256": "ba78c7f212b1c46f70f21ec76f4b551162a6f4e857a5da32df7d5a865b73e570", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_index_auto_fix: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_document_deletion_transaction": { + "boundary": { + "sha256": "50b62b92d002934bbe9af4856f2e6e110df1f313ed507f6d8448a918bfdc857e", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_document_deletion_transaction: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_document_metadata_update_transaction": { + "boundary": { + "sha256": "70cd109f60c39637c5de2292dc9f36b88bc58cc3e331dfbb11eff1ee5c7991b5", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_document_metadata_update_transaction: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_conversation_creation": { + "boundary": { + "sha256": "a74f817a011cdcef8977b8624c961dbe92928c27939a6b78e9c2a9c21f4985fd", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_conversation_creation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_conversation_deletion": { + "boundary": { + "sha256": "fd6bf4b4850c9da90e7aac3f682c8538cc6facd9e8b90548858f2177203e4477", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_conversation_deletion: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_conversation_archival": { + "boundary": { + "sha256": "418cb1b61e079e2e8ac58c4c68fb0c523b5afc023dcb7b833bb7f9081bd01d71", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_conversation_archival: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_user_login": { + "boundary": { + "sha256": "d9343dd1deb514e24b360c991cee62ddb60cc5cb6a54d68cf269109bf14b70b7", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_user_login: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_group_status_change": { + "boundary": { + "sha256": "9590ede98bdbf35417ffb1aa00947318682cfb1d67ad94cfc8944d419d9a9e9f", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_group_status_change: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_group_member_deleted": { + "boundary": { + "sha256": "74635f98bfc4fcea754013d59b21970b32ba413e18db8aee26fb7a178d77a9f8", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_group_member_deleted: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_public_workspace_status_change": { + "boundary": { + "sha256": "5f6730fa511d00cc3b1f78ceddef9e962c2460c616404b2673e9123426b3911f", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_public_workspace_status_change: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_user_agreement_accepted": { + "boundary": { + "sha256": "19de27d0d6a1d9d0ce516cb569a517cc88ceb238816a0ce16c5a9cf8d897c44b", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_user_agreement_accepted: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_terms_of_use_accepted": { + "boundary": { + "sha256": "9d513d3ecfea9a53d0d3e0a267cd9e5d4070030c63ecfc536ee902fd3dac560f", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_terms_of_use_accepted: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_terms_of_use_declined": { + "boundary": { + "sha256": "70a89bf7cd9d23a50a32b297e275639504800e67cb61797df64030450c74d08e", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_terms_of_use_declined: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::has_user_accepted_agreement_today": { + "boundary": { + "sha256": "bb99b5974cbcc9a36a6709afc8a7d83d08042184b35369e1252afd8aec577353", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "sdk-compatible", + "contract": "has_user_accepted_agreement_today: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_activity_logging.py::log_retention_policy_force_push": { + "boundary": { + "sha256": "99487bf0657f926bd3591aa2d0c65285bafe3caf3fb18cf87d5f7c55b0cd66bd", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_retention_policy_force_push: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_general_admin_action": { + "boundary": { + "sha256": "4c8f035a0f99c6f7e9ee144bc984af87c67d7bd47bae97eafafd91361b45cea0", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_general_admin_action: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_file_sync_activity": { + "boundary": { + "sha256": "211209999492109f1a26866ed38f6538ce0f957b6593955291164222116a25db", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_file_sync_activity: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_governance_change": { + "boundary": { + "sha256": "62cd4f9f8b279eb1f0d861506ffbfa933027158d810955d734b7fb50d61848a7", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_governance_change: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_agent_creation": { + "boundary": { + "sha256": "ece1631f9bbab9ef08c1767afa34ffeeaedbc5d9600b10179d0f0bb1eb493552", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_agent_creation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_agent_update": { + "boundary": { + "sha256": "6aad74f57312a5559c8784fb563d4d8f7494b5ed1caa5da8fffc9707c2c05d95", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_agent_update: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_agent_deletion": { + "boundary": { + "sha256": "ad261ce51845333df17afb50b73f86a78b934bb1b9351f57b58736b775a99464", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_agent_deletion: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_agent_run": { + "boundary": { + "sha256": "7c02f9d9e6e1fb82b4579d6e9fe218e5b8d7e8e312b4ae9488cb0e3a83bfdc5f", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_agent_run: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_action_creation": { + "boundary": { + "sha256": "f7509c3a12d75c2ff1bd08cbbf47d72e95ddfe58998b625ed4b0d9d76b9d27e4", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_action_creation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_action_update": { + "boundary": { + "sha256": "5551a2a36a51eed0f49588c65a45ecfb0d3b2aabc775b3094de835b49a378c58", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_action_update: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_action_deletion": { + "boundary": { + "sha256": "4d0bb19751c686a01c5d8f917d2fa9463e2d203c3e98c58a50f5f0a085243f2f", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_action_deletion: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_workflow_creation": { + "boundary": { + "sha256": "ce0748f41b0fa9b962dc858e544559c2e5d25969264276a0eaca176d8a7e235e", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_workflow_creation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_workflow_update": { + "boundary": { + "sha256": "80948206132be2c56d8f9ae1c462c5bcacd0e821ead3f975248b2bdaada06873", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_workflow_update: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_workflow_deletion": { + "boundary": { + "sha256": "ff317caa457224efa7cfe476e789f72f4c36b191cc6e0a1c7c5b28b0e22d6dca", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_workflow_deletion: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::log_workflow_run": { + "boundary": { + "sha256": "ad8356b5641fcd6a0c656a9789bbc56d5d388d6e1752a90ebb1ead7a215658a8", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "log_workflow_run: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_activity_logging.py::_log_agent_template_activity": { + "boundary": { + "sha256": "064a2913eaeed0b13b289d431ed72d006237f8c785a59de545a274407e37fb77", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3" + }, + "classification": "response-unused", + "contract": "_log_agent_template_activity: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_agent_catalog.py::_load_agent_usage_counts": { + "boundary": { + "sha256": "bae2950c9dc21db667dfdea85821650fae621e65cc669bb682ea42787379237d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9678f137bd6af3c521cd0ca363a4530dce54ea4c5b6dc6e0ea29cf6b200aab25" + }, + "classification": "sdk-compatible", + "contract": "_load_agent_usage_counts: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_agent_delegation.py::_read_agent": { + "boundary": { + "sha256": "806d2c2c3ed46ec36ce4dd5a2e8e81c8a979c8d81f7663c85dd1a7cf7a4962e8", + "points": [ + { + "method": "read_item", + "receiver": "_container('agents', reference['scope_type'])", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "645b282bbc371329db329ec0d8abd53331ac0a652751e6e462fb040435a558e0" + }, + "classification": "sdk-compatible", + "contract": "_read_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_agent_delegation.py::_list_records": { + "boundary": { + "sha256": "cdb5cc89f851bc5315804dfbb05517071982e4b634dbd300dcce0200bdb5825c", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(kind, scope_type)", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "645b282bbc371329db329ec0d8abd53331ac0a652751e6e462fb040435a558e0" + }, + "classification": "sdk-compatible", + "contract": "_list_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_agent_delegation.py::update_agent_delegation_bindings": { + "boundary": { + "sha256": "89fb1ac1f40caea22e8db416d1ad0beac93ef1bb1ea16b2322c077ddf10ace39", + "points": [ + { + "method": "patch_item", + "receiver": "_container('agents', scope_type)", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "645b282bbc371329db329ec0d8abd53331ac0a652751e6e462fb040435a558e0" + }, + "classification": "response-unused", + "contract": "update_agent_delegation_bindings: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_agent_templates.py::list_agent_templates": { + "boundary": { + "sha256": "ae2334b5c0589b308d082a1e1f2b9193d092c590e0d868b938b146e2e5a201ac", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_agent_templates_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf" + }, + "classification": "sdk-compatible", + "contract": "list_agent_templates: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_agent_templates.py::get_agent_template": { + "boundary": { + "sha256": "af4c8e63c0c57481c222e3989ccfa530180affa20177e57e68ca77c73f3c468e", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_agent_templates_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf" + }, + "classification": "sdk-compatible", + "contract": "get_agent_template: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_agent_templates.py::create_agent_template": { + "boundary": { + "sha256": "e18ca916cd75ff9403bd688a6a2842e23872022025637fad24125474880837ce", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_agent_templates_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf" + }, + "classification": "response-unused", + "contract": "create_agent_template: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_agent_templates.py::update_agent_template": { + "boundary": { + "sha256": "7854fd3f17c229e9d5959bae8d9b6dd2c47db9f1bcda31a64b0b6b30b3ac1453", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_agent_templates_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf" + }, + "classification": "response-unused", + "contract": "update_agent_template: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_agent_templates.py::approve_agent_template": { + "boundary": { + "sha256": "cfc7197efbeccd890654d7851f1bcb52f14e3987fefe6d1e466aea8ca928f9a0", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_agent_templates_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf" + }, + "classification": "response-unused", + "contract": "approve_agent_template: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_agent_templates.py::reject_agent_template": { + "boundary": { + "sha256": "62de76d12a5e226e804e3485d5d4860f9c29aafd15e395ab7b4ce8a51d1c959b", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_agent_templates_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf" + }, + "classification": "response-unused", + "contract": "reject_agent_template: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_agent_templates.py::delete_agent_template": { + "boundary": { + "sha256": "fd966e009cdf9786a135116294e273533486a4f186b7014d7ed86284251f06fa", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_agent_templates_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf" + }, + "classification": "response-unused", + "contract": "delete_agent_template: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_app_maintenance.py::_read_maintenance_state": { + "boundary": { + "sha256": "d4270a918fbf1f6410e2be7e3ff0c1a9ac4a0d774f167c2cdf6abb8f6af77bc8", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c1ff82c3c5580deeb6c4b015783070f6503cae4f743b534f063329d68bdf00" + }, + "classification": "sdk-compatible", + "contract": "_read_maintenance_state: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_app_maintenance.py::_write_maintenance_state": { + "boundary": { + "sha256": "0fc03da1b6f10943d827558424ea61781e7f74a4cb7ee66a679b835b19c4d89b", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c1ff82c3c5580deeb6c4b015783070f6503cae4f743b534f063329d68bdf00" + }, + "classification": "response-unused", + "contract": "_write_maintenance_state: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_approvals.py::create_content_screening_approval": { + "boundary": { + "sha256": "af564c4ea7852e2381468bb86854ceadadcf01d8ae7fa4b2267600816ce36f84", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "create_content_screening_approval: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::resolve_content_screening_approval": { + "boundary": { + "sha256": "f31f134c31cab43376b320f1dd6c74bb3cd3c103956eccb4885434c8897b07bc", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "resolve_content_screening_approval: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::create_approval_request": { + "boundary": { + "sha256": "2fb8626f9686447742b3d4e4f83dfa8f4ad3d421d8c5e12ff1666768645036bc", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_approvals_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "create_approval_request: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::get_pending_approvals": { + "boundary": { + "sha256": "0926f7e86a2f632d4c56f9b38865bac1448b6d7b5374550ca7664bc3bac1894b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_approvals_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "get_pending_approvals: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::approve_request": { + "boundary": { + "sha256": "6ff0ed48b581e0afa7176cd6e8e6d7855b7d856fe6da6fefbdfd7e076ad05a1c", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_approvals_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "approve_request: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::deny_request": { + "boundary": { + "sha256": "e267b913fe0d81f735f2835ab740efa0e37cbd97840fba0aa1119e299984c1f3", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_approvals_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "deny_request: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::withdraw_approval_request": { + "boundary": { + "sha256": "fa8ec6484fffd0abcdbc5f4d51f2928cca4c627d47ada7b748c3b98df5a266c7", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "withdraw_approval_request: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::mark_approval_executed": { + "boundary": { + "sha256": "61c9fa792af2d74bcd477b90cff174d283d66f341fb94dd6bc96862eb7b9c7f8", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_approvals_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "mark_approval_executed: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::get_approval_by_id": { + "boundary": { + "sha256": "fd174ad502b79e10da257b235f4fe78e576d27bc59220a1122b60b4e6ad06458", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_approvals_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "get_approval_by_id: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_approvals.py::auto_deny_expired_approvals": { + "boundary": { + "sha256": "d361e352eb4f02e117d7b693dcce03d4c5d8c520f3b0f7306a9cd28e09f6ad07", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_approvals_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968" + }, + "classification": "sdk-compatible", + "contract": "auto_deny_expired_approvals: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication.py::_authorize_artifact": { + "boundary": { + "sha256": "5719bffa176b3c26365f2f6105da071b77088d898e158b0c132c5273dbcd6c3b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "sdk-compatible", + "contract": "_authorize_artifact: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication.py::_receipt_change": { + "boundary": { + "sha256": "a9c242d16faf07289edb76c44d0a18130bbdc5fe8eb54527b6f48176a496b170", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "sdk-compatible", + "contract": "_receipt_change: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication.py::_destination_document": { + "boundary": { + "sha256": "610e561c365659a78180ec3aa9418740f20c12779e8c48b840c461d93c690ad5", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "sdk-compatible", + "contract": "_destination_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication.py::_notification_exists": { + "boundary": { + "sha256": "5869e8e8ba01518297e3d5e88b9a8cf816aeb3b09ebf1b3c14c09d4e45e990d0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "sdk-compatible", + "contract": "_notification_exists: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication.py::_replace_publication_destination": { + "boundary": { + "sha256": "3facb3956ed614bf624ce87a6ebf31ff5689ed76e9d78d3f0bd5c7526853a458", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "response-unused", + "contract": "_replace_publication_destination: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_artifact_publication.py::authorize_publication_status_read": { + "boundary": { + "sha256": "3793a005eca85a5ce73fabe9b1fbc595fb716e78ec46de85741ebf4d0a1f8a75", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "sdk-compatible", + "contract": "authorize_publication_status_read: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication.py::read_artifact_publication_request": { + "boundary": { + "sha256": "5986fb92cd3f09a2591cdaa77b534d8881f3eef8d2c1945d694d3c6c7384e1b0", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "sdk-compatible", + "contract": "read_artifact_publication_request: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication.py::enroll_legacy_artifact_publication": { + "boundary": { + "sha256": "0ec2fb07f2a589e45843282f1f6894113b84a465227cc75cd0d79ca5ddcf9756", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "sdk-compatible", + "contract": "enroll_legacy_artifact_publication: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication.py::_decide_artifact_publication_with_content": { + "boundary": { + "sha256": "ee71a54d40fee7288220587959506fa7d83ecbaaf6074368c9036732952daad2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b" + }, + "classification": "sdk-compatible", + "contract": "_decide_artifact_publication_with_content: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_artifact_publication_readiness.py::_processing_change": { + "boundary": { + "sha256": "c5d6e4320bd7775761dd791f9f55d12c0e6c741402af27e7ec262c99d3c553bd", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d1a482cdeeba15ff9fc408c8fffd8095bfaec64c51d4362b48e6dbe3d21eeb75" + }, + "classification": "sdk-compatible", + "contract": "_processing_change: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_assigned_knowledge.py::_query_documents": { + "boundary": { + "sha256": "48f00de2cbcfc7da02faed68efbf48aa0fb536806ad441932a4fd0acdf3cc311", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "fee757eb652bcc9eefb888719f5ca0d90b7cbe2413299f3f5cc70863d14c9e66" + }, + "classification": "sdk-compatible", + "contract": "_query_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_content_review.py::persist_chat_reply": { + "boundary": { + "sha256": "69754dde20720b25e3379003b04878aa335d3c1f345dff88d4799102d1679bc2", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "returned" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "returned" + }, + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "74a9fbc3c7b73af75c9cb5371fe21a11e2316ecaa206e8f815769f4764bdf607" + }, + "classification": "sdk-compatible", + "contract": "persist_chat_reply: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_content_review.py::refresh_checked_message": { + "boundary": { + "sha256": "1d330973c1e3fe407dd8f87b48a03010e276844a9264612329f8b62920a1a3c4", + "points": [ + { + "method": "read_item", + "receiver": "stores.message_container('chat' if mirrored else source)", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "74a9fbc3c7b73af75c9cb5371fe21a11e2316ecaa206e8f815769f4764bdf607" + }, + "classification": "sdk-compatible", + "contract": "refresh_checked_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_content_review.py::retracted_stream_payload": { + "boundary": { + "sha256": "3fcda556833af5c0f58dd44ff29127ee7fa203143fc6787cb50f5241764660d7", + "points": [ + { + "method": "read_item", + "receiver": "stores.messages", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "74a9fbc3c7b73af75c9cb5371fe21a11e2316ecaa206e8f815769f4764bdf607" + }, + "classification": "sdk-compatible", + "contract": "retracted_stream_payload: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_content_review.py::count_unchecked_chat_content": { + "boundary": { + "sha256": "5ffe66db196286c6b5ad6b1156d9d7d1034d5a6d3fcb274c8140f6dddfa08194", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "stores.message_container(current_source)", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "74a9fbc3c7b73af75c9cb5371fe21a11e2316ecaa206e8f815769f4764bdf607" + }, + "classification": "sdk-compatible", + "contract": "count_unchecked_chat_content: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_content_review.py::recheck_chat_message": { + "boundary": { + "sha256": "dc330f66b8488a179f6ba9b2efb2981512e3213ea064c949254f6f59a0d23b7e", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "stores.conversation_container(source)", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "74a9fbc3c7b73af75c9cb5371fe21a11e2316ecaa206e8f815769f4764bdf607" + }, + "classification": "sdk-compatible", + "contract": "recheck_chat_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_content_review.py::record_chat_content_incident": { + "boundary": { + "sha256": "8903fae6096441c584e4753908ac305b16f7ecd9c1f228944de5bf5464e118d0", + "points": [ + { + "method": "create_item", + "receiver": "stores.safety", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "74a9fbc3c7b73af75c9cb5371fe21a11e2316ecaa206e8f815769f4764bdf607" + }, + "classification": "response-unused", + "contract": "record_chat_content_incident: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_chat_content_review.py::_clear_conversation_projection": { + "boundary": { + "sha256": "4e30e4949334e4e6b84adf43440484dca2d5e3fb79c58b975968170d517cdce0", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "74a9fbc3c7b73af75c9cb5371fe21a11e2316ecaa206e8f815769f4764bdf607" + }, + "classification": "sdk-compatible", + "contract": "_clear_conversation_projection: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_content_review.py::propagate_chat_retraction": { + "boundary": { + "sha256": "f9d6ab9ea38b46c8aa1fb7d80cd786ef03809174540fa7a89c65fb87a725a46f", + "points": [ + { + "method": "replace_item", + "receiver": "stores.shared_messages", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "stores.notifications", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "stores.shared_messages", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "stores.notifications", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "74a9fbc3c7b73af75c9cb5371fe21a11e2316ecaa206e8f815769f4764bdf607" + }, + "classification": "sdk-compatible", + "contract": "propagate_chat_retraction: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_message_metadata.py::patch_message_metadata": { + "boundary": { + "sha256": "dfe08559e3f224b68702bee6fda2faac510e7c397e266f3cea938e563e16eb0b", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b7a4ef66ad104ea9e69e48a6dd27ac36c41c77da286cfcaaba3c7ad88ddda0b4" + }, + "classification": "sdk-compatible", + "contract": "patch_message_metadata: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_retry.py::load_owned_retry_message": { + "boundary": { + "sha256": "4364cc6ee3f259dccf77ed56316d2bfd5335a7c1bef9bfee1d1a68a3623c46eb", + "points": [ + { + "method": "read_item", + "receiver": "conversations", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "messages", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "862a867593565934209249de42af138960830ee3b8cdb3ab87d9f7150cdf0b6e" + }, + "classification": "sdk-compatible", + "contract": "load_owned_retry_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_retry.py::retry_source_user": { + "boundary": { + "sha256": "306917b7302e1e24d4e187f35a43993da176f3e4ff7b3d501781605a9c3c25e4", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "messages", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "862a867593565934209249de42af138960830ee3b8cdb3ab87d9f7150cdf0b6e" + }, + "classification": "sdk-compatible", + "contract": "retry_source_user: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_retry.py::retry_thread_messages": { + "boundary": { + "sha256": "ad96d44d131dec6b6752736bcf2a8261ec9269657805bc6d9665e31b587b8029", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "messages", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "862a867593565934209249de42af138960830ee3b8cdb3ab87d9f7150cdf0b6e" + }, + "classification": "sdk-compatible", + "contract": "retry_thread_messages: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_retry.py::reconcile_prepared_retry": { + "boundary": { + "sha256": "fcf34dc17264670c134057f7015f4dfb6ef19fc140721e1ca681b52fa36dc6e2", + "points": [ + { + "method": "read_item", + "receiver": "messages", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "862a867593565934209249de42af138960830ee3b8cdb3ab87d9f7150cdf0b6e" + }, + "classification": "sdk-compatible", + "contract": "reconcile_prepared_retry: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_retry.py::_publish_retry_attempt": { + "boundary": { + "sha256": "f390eea6e9384a64239f384046225facb7b30f8f7760e9c631b745b82d3f3383", + "points": [ + { + "method": "read_item", + "receiver": "conversations", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "conversations", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "conversations", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "862a867593565934209249de42af138960830ee3b8cdb3ab87d9f7150cdf0b6e" + }, + "classification": "sdk-compatible", + "contract": "_publish_retry_attempt: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_retry.py::prepare_retry_attempt": { + "boundary": { + "sha256": "f3e2bd48ab37525f8a65eb11edfb8a2a7968725cc0d52e403e57f6f56e8e1303", + "points": [ + { + "method": "read_item", + "receiver": "messages", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "messages", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "conversations", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "messages", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "conversations", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "messages", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "messages", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "862a867593565934209249de42af138960830ee3b8cdb3ab87d9f7150cdf0b6e" + }, + "classification": "sdk-compatible", + "contract": "prepare_retry_attempt: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_retry.py::claim_retry_attempt": { + "boundary": { + "sha256": "8c920b34063e7ddf57233d64c86b2043ba843e64e58c29428453dfa78c4fa8cd", + "points": [ + { + "method": "read_item", + "receiver": "messages", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "conversations", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "messages", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "messages", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "862a867593565934209249de42af138960830ee3b8cdb3ab87d9f7150cdf0b6e" + }, + "classification": "sdk-compatible", + "contract": "claim_retry_attempt: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_chat_retry.py::set_retry_attempt_state": { + "boundary": { + "sha256": "c96ae0b730d13ae7b54fc362c424502f5411de761af8c78b20b33133826974e0", + "points": [ + { + "method": "read_item", + "receiver": "messages", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "messages", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "862a867593565934209249de42af138960830ee3b8cdb3ab87d9f7150cdf0b6e" + }, + "classification": "sdk-compatible", + "contract": "set_retry_attempt_state: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::get_collaboration_conversation": { + "boundary": { + "sha256": "866583a39854bcfa8102f3e571e757fa43c39f139c5e813f22362ea9672b3bf3", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "get_collaboration_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::get_collaboration_user_state": { + "boundary": { + "sha256": "28086684a7cf53d5b0a1ef5c7fdfce7a4e66ca6fffae759c8a97de769d06b80b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "get_collaboration_user_state: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::get_collaboration_message": { + "boundary": { + "sha256": "0c47f9a6ebf8f9cd0f1f49c93591c51d97569fa68435aff7cb86c3ab5e209e46", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "get_collaboration_message: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::get_collaboration_message_by_source_message": { + "boundary": { + "sha256": "bc1f7d59e8e75864743c71d20a733193b42dd6ce20233f789ac13d1057fd868d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "get_collaboration_message_by_source_message: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::ensure_collaboration_user_state_for_participant": { + "boundary": { + "sha256": "904271bb717290fe6b248e9b101d8d40f973fa55371c6f44f186ec49adc50d88", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "ensure_collaboration_user_state_for_participant: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::_bootstrap_collaboration_user_state_from_participant": { + "boundary": { + "sha256": "577ce40f786242a05f92e41ec0b02fa83cff2d95ac04f4f8dba869818c89f67b", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "_bootstrap_collaboration_user_state_from_participant: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::_get_collaboration_source_message": { + "boundary": { + "sha256": "b82bfcf53198224843c2733e77b4d61cf941cfc7a92b71fefdf0a8975caf2d83", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "_get_collaboration_source_message: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::get_personal_collaboration_conversation_by_source_conversation": { + "boundary": { + "sha256": "adff32b0374b47eccfd00eeddf676cae9a0afb351286d7f9673fe975287a963a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "get_personal_collaboration_conversation_by_source_conversation: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::_copy_legacy_personal_messages_to_collaboration": { + "boundary": { + "sha256": "930b4ee260fe13406d205cd7e726f15a19c1efe47e5dd14f48fd76657eb73947", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "_copy_legacy_personal_messages_to_collaboration: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::ensure_personal_collaboration_for_legacy_conversation": { + "boundary": { + "sha256": "002aacd001365411ac0c47e248e4c5cc0592caad8b30f388450d4d1336417fba", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "ensure_personal_collaboration_for_legacy_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::_copy_legacy_group_messages_to_collaboration": { + "boundary": { + "sha256": "2b02d0f1b9ebd63ca9dd9d31133208d1dad7545d405f66c29227791c16c154b8", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "_copy_legacy_group_messages_to_collaboration: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::ensure_group_collaboration_for_legacy_conversation": { + "boundary": { + "sha256": "abd066096ace21b74533c074ad8e8ca4d9dd4166e86818d9eba247f2f65db925", + "points": [ + { + "method": "read_item", + "receiver": "source_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "source_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "source_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "ensure_group_collaboration_for_legacy_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::create_personal_collaboration_conversation_record": { + "boundary": { + "sha256": "ff7887ff75e36e44dc3581df1b3d0df4f0b69b0a86859d2abba7586f193a2038", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "create_personal_collaboration_conversation_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::create_group_collaboration_conversation_record": { + "boundary": { + "sha256": "6f25147f1be3d7e312df554777bf43f426d53b09d91d83fbaf3f752dd7802e8e", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "create_group_collaboration_conversation_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::list_personal_collaboration_conversations_for_user": { + "boundary": { + "sha256": "3f3ac6e1f3e60f09b023653aaa69cae0bbcf73f0f4f5776c60d32ae258fbc4a9", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_user_state_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "list_personal_collaboration_conversations_for_user: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::list_group_collaboration_conversations_for_user": { + "boundary": { + "sha256": "80fab44f5f25e2d3f721677035aff8dca59ac643528773f508c218688f8723a7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_user_state_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_collaboration_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "list_group_collaboration_conversations_for_user: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::record_personal_invite_response": { + "boundary": { + "sha256": "3380758094440f34831259d54f9c05f5da368142a4fdec77aae12c7005d6e0c6", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "record_personal_invite_response: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::invite_personal_collaboration_participants": { + "boundary": { + "sha256": "3db8744eda651c7584c75ca816992bcaee8569075530095484f23c0b66083118", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "invite_personal_collaboration_participants: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::remove_personal_collaboration_member": { + "boundary": { + "sha256": "5cbed7c3b1ff19787ba39e398bdd1ad5e5b89ad97ff5bc8f9bb3f36502abced5", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "remove_personal_collaboration_member: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::list_collaboration_messages": { + "boundary": { + "sha256": "f16cfa607f078cddd4df2a3e45e23cb204a2fed9c05cc10bd36b427c51103a56", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "list_collaboration_messages: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::_save_collaboration_message_doc": { + "boundary": { + "sha256": "a81e117416c952874391e9e7fb47e4d5c7d0e90c358a99895437072616745909", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "_save_collaboration_message_doc: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::sync_collaboration_conversation_metadata_from_source": { + "boundary": { + "sha256": "e365dbfdcce9bedbba517cd376661c64191fb0ba4fbc23ed1564bb32fe5bece9", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "sync_collaboration_conversation_metadata_from_source: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::ensure_collaboration_source_conversation": { + "boundary": { + "sha256": "47dfa73c3818e34312dcfeef0f0d3ef21fefeab70d9cd152efd6a1ef2ccfae96", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "ensure_collaboration_source_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::_refresh_collaboration_conversation_message_summary": { + "boundary": { + "sha256": "5d81bc4b52e77c0e1fa14f3050ee1d0ff8e3bddaa64d526ad4e84aee256b0a9e", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "_refresh_collaboration_conversation_message_summary: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::delete_collaboration_message": { + "boundary": { + "sha256": "33c10080f836879d8a797efe249f38232e275ec1496a17bd08ec2944753a53fa", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "delete_collaboration_message: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::update_personal_collaboration_title": { + "boundary": { + "sha256": "570233af974a971f1b05cb316faf6f5db852980661ec3b8f16a136999df7ba91", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "update_personal_collaboration_title: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::toggle_personal_collaboration_pin": { + "boundary": { + "sha256": "45fb670b46ba303bc530b77085380a22aa6d96f8056722ec6b0b141e2ae45b7a", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "toggle_personal_collaboration_pin: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::toggle_personal_collaboration_hide": { + "boundary": { + "sha256": "95a38cdcd42710990218e8b2676eabd2c6e81816e67ce229fa6971ba231e2cfe", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "toggle_personal_collaboration_hide: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::update_personal_collaboration_member_role": { + "boundary": { + "sha256": "6aae48795aa56b110a9eed86c6d392e8e9283105e688cb20cdf2365461c737f6", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "update_personal_collaboration_member_role: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::leave_personal_collaboration_conversation": { + "boundary": { + "sha256": "6ddcf44088ac01bcdd7895db69c7a2af5527a30b1ac68b718838acf414d3a07f", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "leave_personal_collaboration_conversation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::_archive_collaboration_item": { + "boundary": { + "sha256": "81a9ec1f7877ceacb49f8231426fcaba4468d5ce6c600351ce9e5a523a12f722", + "points": [ + { + "method": "upsert_item", + "receiver": "archive_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "_archive_collaboration_item: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::_delete_item_if_present": { + "boundary": { + "sha256": "922d805b6ddc6fd28a0f584c7fa86c33cc89481258fac94efb17dd856168f5ef", + "points": [ + { + "method": "delete_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "response-unused", + "contract": "_delete_item_if_present: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_collaboration.py::_read_linked_collaboration_source": { + "boundary": { + "sha256": "e6c2b651fad21fbc95fb160130bd0fbdacc1ffb4ccd6b8a0a2940196c6f36a1c", + "points": [ + { + "method": "read_item", + "receiver": "source_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "_read_linked_collaboration_source: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::_cleanup_linked_collaboration_source": { + "boundary": { + "sha256": "f42aff0f85d0b4feefb96cbe06b6ff15377ecc7f6bd9a318401b85e862152cdb", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "source_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "_cleanup_linked_collaboration_source: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_collaboration.py::_delete_collaboration_conversation_records": { + "boundary": { + "sha256": "d77fcd784b9320bd57f03d97b4f0e9c0154a150a16eed3a7d32d866363ac8a26", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_user_state_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_collaboration_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4330cbff63c48149484e5bb12b7300fbee5ef694f94fa725503a65b4a61c3be5" + }, + "classification": "sdk-compatible", + "contract": "_delete_collaboration_conversation_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center.py::execute_control_center_refresh": { + "boundary": { + "sha256": "d8caf75e602f3775b0ad1cd5aacbc3cbd8acd6156abe485cc7ac86634070ccc1", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "7a79c884556ed01b465e2566c774425a4683d198ea793099c7dfe64f1557ee0f" + }, + "classification": "sdk-compatible", + "contract": "execute_control_center_refresh: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_activity.py::query_activity_rows": { + "boundary": { + "sha256": "73bae9411a3447423b5fd0101ea59fb4abe9d7bbc93f3a7cd185973b9f6d51fd", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da5b3c6c30b9a262a0a798c1137d263854addb4ebe11dbd0875d7de37d8f982d" + }, + "classification": "sdk-compatible", + "contract": "query_activity_rows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_activity_display.py::_lookup": { + "boundary": { + "sha256": "0c9f4ecff5338b6d35d2bd774f5c2b1ac59738d4a0b152838293b1b64aabf980", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "5b3dd4420c82279a33a0a4b67d05857127f8da61e9dcce7b7432ce57c21f3ae9" + }, + "classification": "sdk-compatible", + "contract": "_lookup: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_activity_display.py::search_activity_people": { + "boundary": { + "sha256": "6a220bb4f8ab27e5411d30c4bd4ce5b66a7b8762a8a1556b510cccbb900c703d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "5b3dd4420c82279a33a0a4b67d05857127f8da61e9dcce7b7432ce57c21f3ae9" + }, + "classification": "sdk-compatible", + "contract": "search_activity_people: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_activity_display.py::search_activity_workspaces": { + "boundary": { + "sha256": "7f9639ab8e28d246d2f6ba5c602ee455e5632ace045fd9236ac26500d88d0aa3", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "5b3dd4420c82279a33a0a4b67d05857127f8da61e9dcce7b7432ce57c21f3ae9" + }, + "classification": "sdk-compatible", + "contract": "search_activity_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_dashboard.py::query_count": { + "boundary": { + "sha256": "5e2b6d54da9233dd9265ddcbe0c60a4aadacd5b65ea0cfb8b77bf951525d1899", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a" + }, + "classification": "sdk-compatible", + "contract": "query_count: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_dashboard.py::count_active_users": { + "boundary": { + "sha256": "b86af7cfafbe5d86283097a33215e20c47d19ececb127bb93c4e3da7e9f7f282", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a" + }, + "classification": "sdk-compatible", + "contract": "count_active_users: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_dashboard.py::status_rows": { + "boundary": { + "sha256": "119b39edbe363ecdafa500d0f9c0f73f2426272acea903d67b0189d5a2b04bc7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a" + }, + "classification": "sdk-compatible", + "contract": "status_rows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_dashboard.py::token_total": { + "boundary": { + "sha256": "fac261d07016254a3e47d89a0579595be3c51cee2f430a3dd925e97394c57454", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a" + }, + "classification": "sdk-compatible", + "contract": "token_total: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_dashboard.py::aggregate_token_usage": { + "boundary": { + "sha256": "db35d6287c013be62ac94b07517632aba190ee1756b31f3ae3902900a9df8a41", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a" + }, + "classification": "sdk-compatible", + "contract": "aggregate_token_usage: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_dashboard.py::_activity_rows": { + "boundary": { + "sha256": "a8655e13c345829f02a6f442fa869b60bfe41367114ba2ac528d9db46d62b8ce", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "returned" + } + ], + "batches": [], + "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a" + }, + "classification": "sdk-compatible", + "contract": "_activity_rows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_dashboard.py::resolve_entity_names": { + "boundary": { + "sha256": "c8f524d26bafd6c6b2885d349f22bb6e0d6f59e318675b290f13371a53b90c64", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a" + }, + "classification": "sdk-compatible", + "contract": "resolve_entity_names: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_dashboard.py::find_entities": { + "boundary": { + "sha256": "8b505be3272d17253639ec644888f7122169ae4cce8d67bbc8d045f4bf983398", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a" + }, + "classification": "sdk-compatible", + "contract": "find_entities: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_groups.py::load_group_inventory": { + "boundary": { + "sha256": "4ba8b911cb2bbce99265fc4537fdfb968c6ac39eb315a9936d6dd839dc51bef5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "groups_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "activity_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "activity_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "eb5639bf4ed1cd12d049f6ef89393d4fa3e2ec8d4c72313bbfa717e2816b6859" + }, + "classification": "sdk-compatible", + "contract": "load_group_inventory: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_public_workspaces.py::query_workspaces": { + "boundary": { + "sha256": "ec65c274f2fb229d898b500d814e1b7260f9a0f690f0059cfe58ac3435d3c55b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "78a6ac31d53792c94dcce6108a0a38d7ff6fd4b0f330828c7a84e2f0be40ba20" + }, + "classification": "sdk-compatible", + "contract": "query_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_public_workspaces.py::query_workspaces.count": { + "boundary": { + "sha256": "969aeca37363676fca053170f21a4a5bd349691fe384a69bf5036dc4e91d0720", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "78a6ac31d53792c94dcce6108a0a38d7ff6fd4b0f330828c7a84e2f0be40ba20" + }, + "classification": "sdk-compatible", + "contract": "query_workspaces.count: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_control_center_public_workspaces.py::select_workspace_ids": { + "boundary": { + "sha256": "9e191a39e04da45e984790048eda45fd92202a185568efa9c1e7c195c9352499", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "78a6ac31d53792c94dcce6108a0a38d7ff6fd4b0f330828c7a84e2f0be40ba20" + }, + "classification": "sdk-compatible", + "contract": "select_workspace_ids: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_conversation_metadata.py::get_user_info_by_id": { + "boundary": { + "sha256": "7e82f787191a5d365a846d782a96038c2ed6faff7152b443f2ab07289acca780", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "9d06ea2e1bd4898240ef755876b12020a42f3baaec6a7fe636ea406ac72db171" + }, + "classification": "sdk-compatible", + "contract": "get_user_info_by_id: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_conversation_metadata.py::_get_conversation_item_with_source": { + "boundary": { + "sha256": "108b7ecf80baca15f5d66dbf1aa825c8b982dd9aced5d1ebdfff477dd09e5e0f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "9d06ea2e1bd4898240ef755876b12020a42f3baaec6a7fe636ea406ac72db171" + }, + "classification": "sdk-compatible", + "contract": "_get_conversation_item_with_source: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_conversation_metadata.py::update_conversation_with_metadata": { + "boundary": { + "sha256": "b87726d597d3c231d56f40eab20c58ef9b6aecdeb38b01e031c1383366b0a667", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "9d06ea2e1bd4898240ef755876b12020a42f3baaec6a7fe636ea406ac72db171" + }, + "classification": "response-unused", + "contract": "update_conversation_with_metadata: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_conversation_unread.py::mark_conversation_unread_guarded": { + "boundary": { + "sha256": "9a6a22e304b0f93a7ece564c1863f1b6bad2f0b539daa93058eded758c06e79b", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c7921edaf1e71076cd3c28fe6c1514a210e30459fdc8e6e88027d4457c9cea99" + }, + "classification": "sdk-compatible", + "contract": "mark_conversation_unread_guarded: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_cosmos_stale_cleanup.py::_query_stale_cache_cleanup_candidates": { + "boundary": { + "sha256": "8f9cbb27fdb8121e53e059d91c07bcac9861e5f88dcb989e640d8be3b099ee86", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "445b30fe80983fc814fc8f9dee450c9fcbf5ba460e3d26615b2f18909ae0ac08" + }, + "classification": "sdk-compatible", + "contract": "_query_stale_cache_cleanup_candidates: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_cosmos_stale_cleanup.py::run_stale_cache_document_cleanup": { + "boundary": { + "sha256": "576f70c3b5cb4a08a309a37509040c79abf1f058340f3d3ad152306dfbb96061", + "points": [ + { + "method": "delete_item", + "receiver": "cleanup_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "445b30fe80983fc814fc8f9dee450c9fcbf5ba460e3d26615b2f18909ae0ac08" + }, + "classification": "response-unused", + "contract": "run_stale_cache_document_cleanup: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_custom_pages.py::_list_cosmos_custom_pages_source": { + "boundary": { + "sha256": "96bea1b8ec1b985d279c627b3eab0042c1ceef18a193b8776a477baff34ab5c1", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_custom_pages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "244e011c9c06f121e90f93ab4b92e7cc8a25b94bcdae369a9505887383f3d466" + }, + "classification": "sdk-compatible", + "contract": "_list_cosmos_custom_pages_source: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_custom_pages.py::get_custom_page": { + "boundary": { + "sha256": "075f565b6b1bce33d2d6e89284a4cf7453756b9156d5b39882fb81c4f246fed3", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_custom_pages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "244e011c9c06f121e90f93ab4b92e7cc8a25b94bcdae369a9505887383f3d466" + }, + "classification": "sdk-compatible", + "contract": "get_custom_page: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_custom_pages.py::save_custom_page": { + "boundary": { + "sha256": "91e8a4ab3f9b31dd9ceec8ee6d6b53e7adf1b38710847abcea363a41ccab74f4", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_custom_pages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "244e011c9c06f121e90f93ab4b92e7cc8a25b94bcdae369a9505887383f3d466" + }, + "classification": "sdk-compatible", + "contract": "save_custom_page: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_custom_pages.py::delete_custom_page": { + "boundary": { + "sha256": "3bf47107b89033774e659dfcb87c8334c79eae3adb82eb7241f3e5d46e9d7841", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_custom_pages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "244e011c9c06f121e90f93ab4b92e7cc8a25b94bcdae369a9505887383f3d466" + }, + "classification": "response-unused", + "contract": "delete_custom_page: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::get_data_management_settings": { + "boundary": { + "sha256": "4af686e7bc36eb1b8650421e3069e0bebea7b313ad1fa04cdbefe478b7afcb03", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "get_data_management_settings: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::update_data_management_settings": { + "boundary": { + "sha256": "0a05821ae275bc5a6fe68887a7c7a2f4dc8ca8a5c57d9f8fb708a2869fe757d2", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "update_data_management_settings: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::generate_data_management_encryption_key": { + "boundary": { + "sha256": "8ed68ebcc3bcd79c697c369d1b8bd1164823356fc7dddd81a5796f12607feeab", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "generate_data_management_encryption_key: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_get_completed_migration_baseline_candidates": { + "boundary": { + "sha256": "d636563fbb9de29cd722e3ec0e452eea9615992bceba8aaa8c03973cceb60685", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_get_completed_migration_baseline_candidates: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_verify_target_cosmos_container_access": { + "boundary": { + "sha256": "7804d18a425bc8e407c02eb34c07260e12fabb835b4ccbe05712ec4f68dfb0ed", + "points": [ + { + "method": "create_item", + "receiver": "target_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "target_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "target_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_verify_target_cosmos_container_access: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_preflight_target_cosmos_migration_access": { + "boundary": { + "sha256": "b179e99653bdbc8b0d93ef5ef27638ddcc05eebbc6fc0338d3c26bf17568d5a9", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "source_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_preflight_target_cosmos_migration_access: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_iter_selected_cosmos_records": { + "boundary": { + "sha256": "2fa98318fb30b819166ac94434cdc5a69626ca14597eb330363c11e08ed41235", + "points": [ + { + "method": "read_item", + "receiver": "source_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "source_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "source_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_iter_selected_cosmos_records: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_iter_selected_screening_records": { + "boundary": { + "sha256": "135582b4945c575838b7799b1ad217a4590da766e13076bf8a5f3216016de7e5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_iter_selected_screening_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_get_target_cosmos_document": { + "boundary": { + "sha256": "5952597833a75301059e0dccb894ce2acb12fe380cb01bf932e0b0f59e6b46a4", + "points": [ + { + "method": "read_item", + "receiver": "target_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_get_target_cosmos_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_write_cosmos_migration_record": { + "boundary": { + "sha256": "54c827540111b7418e25b36c84c8e136e192cec58eb9056bf7f4f827c135436e", + "points": [ + { + "method": "replace_item", + "receiver": "target_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "target_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_write_cosmos_migration_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_iter_target_cosmos_records": { + "boundary": { + "sha256": "f2da1129ac4f0c455c369c8452c5da246cc55cae3dc9470b14a83a4fd8ec1a31", + "points": [ + { + "method": "read_item", + "receiver": "target_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "target_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "target_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_iter_target_cosmos_records: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_delete_target_cosmos_record": { + "boundary": { + "sha256": "781c62d44e44210e46c311c94883691572bf9f269111b177d8a98a9f0a6e78e2", + "points": [ + { + "method": "delete_item", + "receiver": "target_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_delete_target_cosmos_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_source_cosmos_document_exists": { + "boundary": { + "sha256": "356166331d45027946bd9094906b7b2d343b39083e6ef95af201ed8256bd314a", + "points": [ + { + "method": "read_item", + "receiver": "source_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_source_cosmos_document_exists: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_source_blob_reference_exists_in_plan": { + "boundary": { + "sha256": "53244c5892e56b7962b081f37c627c4a3058fb93a06cf1d7a959a1c81d45720d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "source_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_source_blob_reference_exists_in_plan: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_source_cosmos_identity_exists": { + "boundary": { + "sha256": "794a2fb15e890905bb13f43f0d8343905c8433f2fec473a3e0d4ff8cb5fe1a00", + "points": [ + { + "method": "read_item", + "receiver": "source_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_source_cosmos_identity_exists: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_validate_mirror_deletion_candidate": { + "boundary": { + "sha256": "73b4d035cb8fb3dd503d59be8b8fbb35a412877adfd67fac82a38419c036526f", + "points": [ + { + "method": "read_item", + "receiver": "target_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_validate_mirror_deletion_candidate: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_read_job": { + "boundary": { + "sha256": "2b581dd2f2d287c71774edb59900c0f9d8c5fbf323f530e5c0a4b3af0794c85e", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_read_job: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_acquire_migration_destination_lock": { + "boundary": { + "sha256": "299274a63ac0020626e8f08a82cb0a12e8079724c3718d5adf1f90f9621eb09a", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_acquire_migration_destination_lock: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_renew_migration_destination_lock": { + "boundary": { + "sha256": "6b3cfbdfc441ae263404480a9ff3563a0c7fb03f159cb9cf45e21118c3430b43", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_renew_migration_destination_lock: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_release_migration_destination_lock": { + "boundary": { + "sha256": "4209b88c551063d216198beb0a30ddd4d23bc140dfe22133cc45d812e0416d8a", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_release_migration_destination_lock: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_acquire_backup_source_lock": { + "boundary": { + "sha256": "1156f5023afd7cc69267d1f7718d9a9b72583b64f4e256206045e9023cba71ef", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_acquire_backup_source_lock: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_renew_backup_source_lock": { + "boundary": { + "sha256": "dfacc8e61875120bb7e6b7d5588972f38013e4ddc7081991f34f6371eb97913b", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_renew_backup_source_lock: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_release_backup_source_lock": { + "boundary": { + "sha256": "cfa10f2cedfaa89a00868f18d0216359c9a756563f9a2c7b3c8d215d082638c8", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_release_backup_source_lock: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_replace_job": { + "boundary": { + "sha256": "e76a497989a82d4599637d065d2d664b4160549ed6c8f5550c4af3fc9c609617", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_replace_job: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_log_data_management_activity": { + "boundary": { + "sha256": "b7e44093cc95b85b05d3bd3f9295f79613b9243ca093924afe970ec365509df7", + "points": [ + { + "method": "create_item", + "receiver": "app_config.cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_log_data_management_activity: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::create_data_management_restore_review_authorization": { + "boundary": { + "sha256": "344262a83ee347b301942441f02a4bd532b4a521fee3834e1a37dd2ecaca4c19", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "create_data_management_restore_review_authorization: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_read_data_management_restore_review_authorization": { + "boundary": { + "sha256": "2bc7eb15578af5daaa770ea4d8fbfa4c2f9e2aa8174c85f902cdd307255a3e0d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_read_data_management_restore_review_authorization: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::reserve_data_management_restore_review_authorization": { + "boundary": { + "sha256": "3b5c80bef29e42f5a4a9644f2ff87ccd50497f8663f3bbe65a75cd877ea4b56b", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "reserve_data_management_restore_review_authorization: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::release_data_management_restore_review_reservation": { + "boundary": { + "sha256": "17e494bff0d2f822470ac56f18e2aa8a712d52bbaa058c4a71b6a5f8c6a4b1bd", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "release_data_management_restore_review_reservation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::consume_data_management_restore_review_authorization": { + "boundary": { + "sha256": "d2fbe50ae2193666287cd5c3e055f052d059881c5a5a31dcd1f8562a3656879a", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "consume_data_management_restore_review_authorization: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_iter_backup_manifest_entries": { + "boundary": { + "sha256": "6d36ccb0cb47684ecc2b67d25c56a23c0ce8eba85afda071e9ce51c58b264fc9", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_job_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_iter_backup_manifest_entries: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_target_cosmos_container_has_records": { + "boundary": { + "sha256": "7c827945ce36b2ded7946406b2b03ab0ccd191ebe9e7137a1f00e9259d31fe1b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_target_cosmos_container_has_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::queue_data_management_job": { + "boundary": { + "sha256": "d91c461782433ba4acb19f9638930604eec90949283a5effe89467a4ca6b1ab9", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "queue_data_management_job: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_query_data_management_history_items": { + "boundary": { + "sha256": "2c75156094cb1eb33a7844e0b8ac4f174a2b62e15fde95ed7dc58e6a48706492", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_query_data_management_history_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::get_recoverable_data_management_jobs": { + "boundary": { + "sha256": "ac49ad705d6a1cca94028607b3ce516a773419361f4192a0d8a8a691c41e3d79", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "get_recoverable_data_management_jobs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::get_data_management_job_items": { + "boundary": { + "sha256": "823b89d8fde5d636efcb149f42264a53a1bd830c33e9cb953b2bb5792b72d276", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_job_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "get_data_management_job_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_delete_backup_latest_item_states": { + "boundary": { + "sha256": "889ed474f8cea7037e6a655f688e130eb1348c863a92691eddced6c72b015e97", + "points": [ + { + "method": "delete_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_delete_backup_latest_item_states: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_delete_data_management_job_items": { + "boundary": { + "sha256": "8277843ecb2038d86fc93d326cf98867b0c01c7eb53c13ae0082132be6491267", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_data_management_job_items_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_job_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_delete_data_management_job_items: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_delete_data_management_job_record": { + "boundary": { + "sha256": "3dc2be8aedaa0bb2e8dbeae52c07a8c1ba0a229f7b8038582dc12964afb2997f", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_delete_data_management_job_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::_get_latest_successful_full_backup_id": { + "boundary": { + "sha256": "e8d3e2a2cd4b6e1444de26528721369d890a4dd324b9d70199f681192922db3e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_get_latest_successful_full_backup_id: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_get_backup_retention_candidates": { + "boundary": { + "sha256": "cc00d86174ba4f9053b30d048f4d289cf4c9941efcd88b1383042a16789be8ab", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_get_backup_retention_candidates: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_record_backup_retention_cleanup_run": { + "boundary": { + "sha256": "8fd38eb240db47293fe72f079c645cb17c6ab04dbb63fb343529fd7b94a8e3cf", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_record_backup_retention_cleanup_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_query_migration_catalog_count": { + "boundary": { + "sha256": "31db2d1049192891f1935e6fbfdef72fcec02c35dcaabadd8af5ff08ef0263ab", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_query_migration_catalog_count: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_query_migration_catalog_page": { + "boundary": { + "sha256": "06422e6ad296c14a49acd5f3456161134243c89edbdae7f4bfb709d10ccbe477", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_query_migration_catalog_page: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_count_documents_for_scope": { + "boundary": { + "sha256": "50de559c56c361310d5322b8ce0eae56afd451a61d0b311c58d050c400575c00", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_count_documents_for_scope: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_count_migration_scope_documents": { + "boundary": { + "sha256": "45df2674c1e38ff2022d816ea6b9443a9e54c2fd1d80efee1bafa81a86330256", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "document_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_count_migration_scope_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::create_data_management_migration_review_authorization": { + "boundary": { + "sha256": "83aab229f6cefb0d7ccc7d20d43bf993ac77920c2b42b6e2a6e3d4c788c9064d", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "create_data_management_migration_review_authorization: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_read_data_management_migration_review_authorization": { + "boundary": { + "sha256": "ddde2af5d9923fc184a09e1050126ee9b201cedd11432372450fa2c2f3cf3129", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_read_data_management_migration_review_authorization: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::reserve_data_management_migration_review_authorization": { + "boundary": { + "sha256": "8e23aaef88d9a6137e58b91865d022631a786328d0331973e4fd5d9c1684df21", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "reserve_data_management_migration_review_authorization: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::release_data_management_migration_review_reservation": { + "boundary": { + "sha256": "d0ae4d3171075d383d5b0cb26638b17aee5acd1f79d52d5541b4dc7fb16a783d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "release_data_management_migration_review_reservation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::consume_data_management_migration_review_authorization": { + "boundary": { + "sha256": "b8845bf44b2ae5fde1c398ba4b250741ac40277ec14a7be6c07f9238d81f75fa", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "consume_data_management_migration_review_authorization: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::resolve_data_management_migration_manifest_item": { + "boundary": { + "sha256": "f4b05d857447554829f55fc52fb29240fff9df67cf656cd0eae08e4bf29475ab", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_job_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "resolve_data_management_migration_manifest_item: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_write_migration_manifest_batch": { + "boundary": { + "sha256": "e22445ac2b74236524d03f99ade1081433d45a99a975c6dab157e2d4ffc7c48f", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_job_items_container", + "response": "helper-reference" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_write_migration_manifest_batch: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::iter_data_management_migration_manifest_entries": { + "boundary": { + "sha256": "7ebe18fff20d8cfe3aa3641340ecdd33dc1ca3ae1c9d9d10a6d91bcfd2215bbf", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_job_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "iter_data_management_migration_manifest_entries: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_write_mirror_deletion_candidate_batch": { + "boundary": { + "sha256": "a4d7e8bf307d8b4955b2c080d24b140600817620537e1c8599386d743d0ee7ac", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_job_items_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_write_mirror_deletion_candidate_batch: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_iter_mirror_deletion_candidates": { + "boundary": { + "sha256": "d82f49b371357ea9e0352016fa9651b2389835eee3556e70ddfd4e7628506613", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_job_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_iter_mirror_deletion_candidates: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::create_data_management_job_item": { + "boundary": { + "sha256": "80b4711fcb134c2cf37dedd100ee57f6eae6477261cc27088dfb7f61004a64b0", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_job_items_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "create_data_management_job_item: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::log_data_management_cosmos_editor_activity": { + "boundary": { + "sha256": "4c1b61f70a7cbb3dd410ca6ca31e7b93d9e8f8c67d3a4378a56c1a3693ec80a6", + "points": [ + { + "method": "create_item", + "receiver": "app_config.cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "log_data_management_cosmos_editor_activity: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::query_data_management_cosmos_editor_documents": { + "boundary": { + "sha256": "7fd0f0f087a69c9bc8abf14ee693b83039b2df70666c28d09a97ac17649c722b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "query_data_management_cosmos_editor_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::get_data_management_cosmos_editor_document": { + "boundary": { + "sha256": "5f4a015de1d86a9a2875b50f3d224c0c86d27a0029a8d64908a352db2fd91a2e", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "get_data_management_cosmos_editor_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::save_data_management_cosmos_editor_document": { + "boundary": { + "sha256": "587602962d41293d7d6299dad87478944bb9b05813e2dd942abea8703c138199", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "save_data_management_cosmos_editor_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_save_data_management_job": { + "boundary": { + "sha256": "65c51b134236c83a4075237a5dad16bc66657372ec3ef2a4da36b7c368ae9ca7", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_data_management_jobs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_save_data_management_job: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_iter_cosmos_container_items": { + "boundary": { + "sha256": "0ed8aee4d69ff66892b314fd06679dfe83f2f7b65be94db5949e7122f22ed42f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_iter_cosmos_container_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_can_skip_unused_screening_container": { + "boundary": { + "sha256": "e96117fdb98d7178acd9d3fcf1cfb908892d39a622f4215a7890e466893760ac", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_can_skip_unused_screening_container: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_read_backup_latest_item_state": { + "boundary": { + "sha256": "635eaf0b2b1deaab051fd92811f7eeed77b163140b743042864eda9e9f9cf891", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_read_backup_latest_item_state: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_record_backup_latest_item_state": { + "boundary": { + "sha256": "9f42a9f36f33f2543272e99b01217d4c5d9a980fc5b0386956345ab19b050dea", + "points": [ + { + "method": "upsert_item", + "receiver": "_get_data_management_backup_item_states_container()", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_record_backup_latest_item_state: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_sync_backup_latest_item_state_from_manifest": { + "boundary": { + "sha256": "8c81923fcae42d7d185f39394c532e3a89d704ec85ceb53ea51ffb2af1d98178", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_data_management_job_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_sync_backup_latest_item_state_from_manifest: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_write_backup_manifest_batch": { + "boundary": { + "sha256": "fc9c2aed0977f161771b762fdde3ecd99ca32fce24f9484aa72a487a3d74f001", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_data_management_job_items_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_write_backup_manifest_batch: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_iter_backup_cosmos_source_items": { + "boundary": { + "sha256": "53a729a50c19515e34484503cc4c33da0a3a7eb608cb2a8be0b942c9fcc5cd8c", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "sdk-compatible", + "contract": "_iter_backup_cosmos_source_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management.py::_execute_restore_cosmos_resources": { + "boundary": { + "sha256": "b714b68b7302a6be058daaf49db0770ce54093c5d04c700fb09bef16067db516", + "points": [ + { + "method": "create_item", + "receiver": "target_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "target_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "target_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "target_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "_execute_restore_cosmos_resources: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::execute_backup_job": { + "boundary": { + "sha256": "071880facfce8080ed983e8468d83f0e9efc4743ace35ef35e28c6aca10a6797", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "execute_backup_job: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management.py::check_due_data_management_jobs_once": { + "boundary": { + "sha256": "cf3be808a8de94c1cda12dee5e99fa85d9b4d61c5725ee2d0e270448f327a9dc", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f" + }, + "classification": "response-unused", + "contract": "check_due_data_management_jobs_once: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_data_management_search_write_fence.py::_read_gate": { + "boundary": { + "sha256": "3ef200cc300f5d740fd76e762e2c34323f0b37971ed423972647c738f537a234", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8" + }, + "classification": "sdk-compatible", + "contract": "_read_gate: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management_search_write_fence.py::_create_or_read_gate": { + "boundary": { + "sha256": "f50ff429e07619dbd7a7096911c3958b755dcb9f8eb70b01db8aa9d9cf881a04", + "points": [ + { + "method": "create_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8" + }, + "classification": "sdk-compatible", + "contract": "_create_or_read_gate: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management_search_write_fence.py::_replace_gate": { + "boundary": { + "sha256": "9274f1b8d7578a0097e33f3dd32d28ddbf37cb2fadab58ef6c53864a39fc9544", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8" + }, + "classification": "sdk-compatible", + "contract": "_replace_gate: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management_search_write_fence.py::_read_target_migration_coordinator": { + "boundary": { + "sha256": "11a26ea7441237e83255ee4a10965210efe572236f3833e69b2fe1d627e8333a", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8" + }, + "classification": "sdk-compatible", + "contract": "_read_target_migration_coordinator: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management_search_write_fence.py::_replace_target_migration_coordinator": { + "boundary": { + "sha256": "d5d8acd8ce4dd17eb62405ec3337da9637d273aa2371821676988b3bab9ce381", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8" + }, + "classification": "sdk-compatible", + "contract": "_replace_target_migration_coordinator: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management_search_write_fence.py::acquire_data_management_target_migration_coordinator": { + "boundary": { + "sha256": "23684c81874120629e13589240c2a717076f7ae9788de74ae7859263af768d8c", + "points": [ + { + "method": "create_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8" + }, + "classification": "sdk-compatible", + "contract": "acquire_data_management_target_migration_coordinator: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_data_management_search_write_fence.py::release_data_management_target_migration_coordinator": { + "boundary": { + "sha256": "4d03da0f8b06a81d403edc9b4d6ba4740718f3778e08710e3239c3b0b37583e9", + "points": [ + { + "method": "delete_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8" + }, + "classification": "response-unused", + "contract": "release_data_management_target_migration_coordinator: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::query_items_with_cosmos_diagnostics": { + "boundary": { + "sha256": "4dc78ff31a7b57e6cb9b08a53a5fc799ca4e4ab8f74019a9a6f5bf6f7033f3ce", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "query_items_with_cosmos_diagnostics: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_resolve_document_access_hashes_from_projection": { + "boundary": { + "sha256": "a569287f5ed85909d7c74194533c5c902ce01d3eb472bb2ff7d2bb9e0dc66000", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_document_access_index_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_resolve_document_access_hashes_from_projection: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_resolve_document_access_hashes_from_workspace_container": { + "boundary": { + "sha256": "3cf110f8bb65007a8c562d2c55b4f733a755e84d905acff4f6edca20a0d2475a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_resolve_document_access_hashes_from_workspace_container: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_resolve_document_access_hashes_from_user_settings": { + "boundary": { + "sha256": "f7dad0cdd0f58d7051e86e4871e68c4f3af05e680ebef46914145eb729f346cc", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_resolve_document_access_hashes_from_user_settings: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_query_existing_projection_rows": { + "boundary": { + "sha256": "c71a4f56c996ca945f8000c579498a4e24c1610a6738b286560dd8ec44a3b33b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_document_access_index_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_query_existing_projection_rows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_read_shadow_validation_state": { + "boundary": { + "sha256": "50dad82a3d3e6baa52f892dc8b3603a471b38bb82fe4d13ee8d879ae2c41fe09", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_read_shadow_validation_state: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_write_shadow_validation_state": { + "boundary": { + "sha256": "c0994f7aebf51d9cc94bff1c7641abbe97c3fd4b94d2d4e911edb0f11e010e0a", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_settings_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "_write_shadow_validation_state: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::_query_bounded_projection_rows_for_scope": { + "boundary": { + "sha256": "e1830e3973536307050df785c58ed729f99e949663a7a602af0d021d6f37434d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_document_access_index_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_query_bounded_projection_rows_for_scope: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_query_legacy_projection_rows_for_scope": { + "boundary": { + "sha256": "dff57e5e253788565b376b51360b9da63a4035cfbdf3045a505154b81187c29e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_document_access_index_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_query_legacy_projection_rows_for_scope: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::iter_document_access_index_candidates": { + "boundary": { + "sha256": "f061e6671678d8ea86cc36d219ded7b99051ba75dd7277b101d5f6800b7f25ab", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_document_access_index_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "iter_document_access_index_candidates: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_record_projection_repair_required": { + "boundary": { + "sha256": "ff007353d58e115fbdcd6cb1fceeae8d26c57dcde9ed4f408fd5e44968389d60", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "_record_projection_repair_required: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::_clear_projection_repair_required": { + "boundary": { + "sha256": "38ec6cbebe1be981cd41584a5997e5f096deb8ca79fa7dd7e8c2ebb6030e207c", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "_clear_projection_repair_required: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::_sync_document_access_index_projection": { + "boundary": { + "sha256": "0f1a1f9074bb9bcd890039e26545b5a449af8db37a687d8f65324f4bbf091388", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_document_access_index_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_document_access_index_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "_sync_document_access_index_projection: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::delete_document_access_index_for_document": { + "boundary": { + "sha256": "52644d9557bdfd97faa061d1b93dc7a566c97b59a21ec9e2e9a87d285671ed96", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_document_access_index_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "delete_document_access_index_for_document: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::_write_repair_backlog_state": { + "boundary": { + "sha256": "29dc2df417ff07cf0ee6b0f2fff6d3f615c8907ca1b5dd7c14e9ab4056c274d6", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "_write_repair_backlog_state: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::_try_delete_repair_backlog_state": { + "boundary": { + "sha256": "1702e98792e3a27af929008ae6e6f937c69b14da163cd357a361d4d0ac2c352e", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "_try_delete_repair_backlog_state: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::_read_repair_backlog_state": { + "boundary": { + "sha256": "81c6e35019af4cb08dd1cccb109c5ec9be1bff57ee7f52b148ba5a9058eb894c", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_read_repair_backlog_state: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_query_repair_backlog_exists": { + "boundary": { + "sha256": "b5e3d24a1a7ce494b60d160463b307dffb7a6b79d36437945d4984a6c440eccc", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_query_repair_backlog_exists: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_query_first_page": { + "boundary": { + "sha256": "2b1bd421469df142ae8dfce5e8dbf9c86967adc68ac84b4507dd7ce38037f234", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_query_first_page: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_read_backfill_state": { + "boundary": { + "sha256": "a099c50ca2f5e74d1b11fed91ae1603e3c6746880b7ccaf77f479572840cd27c", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_read_backfill_state: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_write_backfill_state": { + "boundary": { + "sha256": "ae496ec3b2ac6f1fdb380d742497a523256735b80bdc4a8cab55f452139d2a51", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "_write_backfill_state: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::_read_source_document_for_repair": { + "boundary": { + "sha256": "c57435205aad7679ff63bb4113695a03323e8ddb03f7912a276ed04ca4d056f6", + "points": [ + { + "method": "read_item", + "receiver": "source_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "_read_source_document_for_repair: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_access_index.py::_mark_repair_document_failed": { + "boundary": { + "sha256": "d605ff5723345563252ca0201f333a4293de2dd50c061ad4bfefb40f07a61c2e", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "response-unused", + "contract": "_mark_repair_document_failed: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_document_access_index.py::count_document_access_index_repair_documents": { + "boundary": { + "sha256": "953597428d5594077d01cf95fb0c17ba1d6d71bb0a7d5558a4a2bd5d1d1eabbf", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f25b65b06cb2141e85ac4ed7f1cbcc97e3c6570f3d0d57a16dcef939c30759e" + }, + "classification": "sdk-compatible", + "contract": "count_document_access_index_repair_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_document_provenance.py::_read_conversation": { + "boundary": { + "sha256": "d5ee19382f399f303fa7f372b09eda5613126561a76ec75c3c0354c44645a2c4", + "points": [ + { + "method": "read_item", + "receiver": "import_module('config').cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63e92c8afe6afb506cda20cc3c6b842bb0b58f93cd498cbd707ab26744c99abe" + }, + "classification": "sdk-compatible", + "contract": "_read_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::_upsert_document_and_sync_access_index": { + "boundary": { + "sha256": "e215959ab9fa10e469442e417ccd240be0dd7eb7ab385e821884b5b4e76fb9bc", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_upsert_document_and_sync_access_index: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::_get_document_family_items_from_document": { + "boundary": { + "sha256": "ec1b93f4d777ae5c73e2a4997abe457baeafbf2167b88eb79488b0c73e579ea4", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_get_document_family_items_from_document: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::create_document": { + "boundary": { + "sha256": "41edb8ce70519083ef17097e8374b0e3697465be2b7e8d2f05c5a73ced918336", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "create_document: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_document_metadata": { + "boundary": { + "sha256": "50f4f12805831ed91a9eaabde8f2aafc5553c864f4cefc2ec22da2612e1fcc8e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_document_metadata: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::update_document": { + "boundary": { + "sha256": "044b9f8633e1c5f242d861baad67d86126f2ae8592d96b3c49465ae3a46718fd", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "update_document: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_document_metadata_for_citations": { + "boundary": { + "sha256": "719651b8c1b641cb70e21fe348aaa41f7e93b82abe3fc22b6a285fecab0c7b29", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_document_metadata_for_citations: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::_rebase_document_after_fenced_acl_projection": { + "boundary": { + "sha256": "c5e634e7d7e38ecd2ee6b4d42ede0d0e8c9fcab3a718c0d900dcb5e9ee702bc2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_rebase_document_after_fenced_acl_projection: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::_read_document_search_sync_record": { + "boundary": { + "sha256": "2e9ba4d4866819ca7d08e1f28b96e6dc5629f47f757c44f1507fd3fd8c4d5e45", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_read_document_search_sync_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::_replace_document_search_sync_record": { + "boundary": { + "sha256": "2b1cb69832d1d235352d83413ff13d390454e2bb7b558046584b73a40af137ff", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_settings_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_replace_document_search_sync_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::request_document_search_metadata_sync": { + "boundary": { + "sha256": "1336d2d59773a39766319a1954736cb47ecbe880ba1b5b2f2c2b053ada253324", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_settings_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "request_document_search_metadata_sync: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::_complete_document_search_sync_pass": { + "boundary": { + "sha256": "654185c5c128616f6b63210b34e7c804cee3a0804b8287488b8cc46faa87d64e", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "response-unused", + "contract": "_complete_document_search_sync_pass: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_documents.py::_delete_document_search_sync_record": { + "boundary": { + "sha256": "8d6d9b68dce2a8ab056369c2ed898d816252274801a64ae872a7728d587c2045", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "response-unused", + "contract": "_delete_document_search_sync_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_documents.py::_read_document_for_search_sync": { + "boundary": { + "sha256": "5e8dcfcc2120c9def7f146d70b2bab779860e3adae71a1262006f45be27671e6", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_read_document_for_search_sync: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::process_due_document_search_metadata_syncs": { + "boundary": { + "sha256": "6d76a26aa27824db1490b89b30e6a8cdf81798ce06dd5bd318482e5dc9f83b4d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "process_due_document_search_metadata_syncs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_document_record": { + "boundary": { + "sha256": "d6d6b42a39041dec387feaca5a93d30ce8a7fbf91f954cb42e3a9a3ee9aa3ba4", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_document_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_latest_version": { + "boundary": { + "sha256": "cc04f1dafe1492114a7ca876bc5ba7cc13c48c7bc26abd9619f7be70297838a3", + "points": [ + { + "method": "read_item", + "receiver": "_get_documents_container(group_id=group_id, public_workspace_id=public_workspace_id)", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_latest_version: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_document_version": { + "boundary": { + "sha256": "6b922c02208b14e19fe6737168003af7f8dfb3a956978bdd47d432d3b92fdfa3", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_document_version: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::delete_from_blob_storage": { + "boundary": { + "sha256": "d05a616530ee73dd65c4c3257b4fea48d635d2ad2f500d39b63b56c4ede1a6ee", + "points": [ + { + "method": "read_item", + "receiver": "_get_documents_container(group_id, public_workspace_id)", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "delete_from_blob_storage: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::delete_document": { + "boundary": { + "sha256": "080105834da852cd36f85bc6ca2aecac5fe7519a943cb16e35338ff2bcb3bd38", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "delete_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::delete_document_revision": { + "boundary": { + "sha256": "51cf9dfa1d339ecf03164baafc284a67acfe6a7ffb764e147ea0f36904c7f115", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "delete_document_revision: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_chat_upload_workspace_documents_for_conversation": { + "boundary": { + "sha256": "98bf7c64d9289eb14bd650fc31c7d6929b2d757269d68a999b01bc3ff9c7f4b6", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_chat_upload_workspace_documents_for_conversation: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_chat_upload_workspace_documents_for_collaboration": { + "boundary": { + "sha256": "c16bf7bb3b0fa032ea22da402d8e40198392a9ab9638385c3604ad8824bda524", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_chat_upload_workspace_documents_for_collaboration: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_document_versions": { + "boundary": { + "sha256": "f34971cdd3079788a681ef68a2fccc2bcc5f26da0c2d2cd6fe17ba9f8483d20d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_document_versions: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::detect_doc_type": { + "boundary": { + "sha256": "dddbfd376f104b13bb5f4f42f6d1ea36914ab49db5468f348e2dbf27667f20fc", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "detect_doc_type: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::extract_document_metadata": { + "boundary": { + "sha256": "ec2dd5ba25b21527f078438b62ce27312315a684b1ad31f8ab07970fc024b90f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "extract_document_metadata: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::upload_to_blob": { + "boundary": { + "sha256": "7613fdefb9145c32a3a956dc010fd5e959e4fb4815a7e7164a9ab3bb508d72a6", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "upload_to_blob: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::_query_current_xsd_documents": { + "boundary": { + "sha256": "bf31439f4af25c7409ba0a94b2562c462dc4e085389bf02d3a47d23f79089742", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_query_current_xsd_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::_workspace_file_name_exists": { + "boundary": { + "sha256": "2453c1487564b57fcec6a67d0dee6c81ac31e2fd460458e0c2dc0d2eea7106b3", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_workspace_file_name_exists: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::sync_chat_upload_workspace_attachment_status": { + "boundary": { + "sha256": "09c5ca2827893e9ef281632ea66c43a442a6564dbf45692e7d81844839f42cc5", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "sync_chat_upload_workspace_attachment_status: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::queue_personal_workspace_upload_from_temp_file": { + "boundary": { + "sha256": "27f614403f07168929349ef55bc7ad2bd0332cfd1bda97327bd8258f69dd1cb1", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_user_documents_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "response-unused", + "contract": "queue_personal_workspace_upload_from_temp_file: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_documents.py::queue_group_workspace_upload_from_temp_file": { + "boundary": { + "sha256": "3e007ce8568e3903e99060fe93ad61d881a00138613e6dd4c731c2612c625a3c", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_group_documents_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "response-unused", + "contract": "queue_group_workspace_upload_from_temp_file: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_documents.py::_process_document_upload_background_impl": { + "boundary": { + "sha256": "63e6f44098ed1ced02ef4757434a5285830c6b555b534105ae5827f7707e0573", + "points": [ + { + "method": "read_item", + "receiver": "doc_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "doc_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "_process_document_upload_background_impl: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::upgrade_legacy_documents": { + "boundary": { + "sha256": "47d6438d391342da56149d055b746083726437fbfc1928306e2bd5e9475e1487", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "upgrade_legacy_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::share_document_with_user": { + "boundary": { + "sha256": "760e770c84deadfaedc79bbd31439ace24f23e8e1abc740b7ba2c15fc8296766", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "share_document_with_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::unshare_document_from_user": { + "boundary": { + "sha256": "370e66fb1f9fec1e723389f2740ae2391fd398a4297a27be99e6084a2c5da837", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "unshare_document_from_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_shared_users_for_document": { + "boundary": { + "sha256": "4310744622100849cb2b2c3672c3f0e80ee94ec3266e96f626dc8afff701d6a2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_shared_users_for_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::is_document_shared_with_user": { + "boundary": { + "sha256": "106028a0c5281ca34395762136ea992c44f871be104eab31ff80095484154c9a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "is_document_shared_with_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_documents_shared_with_user": { + "boundary": { + "sha256": "ee16826f954976b2df2c07a4c2f6ad8c8b06da064c1cce7696d0273112106c0f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_documents_shared_with_user: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::share_document_with_group": { + "boundary": { + "sha256": "2839cd5b82f4d582c9df75aad9abaad842fa4bfaf97fba20681bc5f94f875ad6", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "share_document_with_group: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::unshare_document_from_group": { + "boundary": { + "sha256": "7486a21b13c8d984fd06f6ca4c243f93996dbb45a16d186395bfc83748621f7d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "unshare_document_from_group: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_shared_groups_for_document": { + "boundary": { + "sha256": "01b32bd43ca152aa680d0e4513d9f40cdab8647d9b3043a39e59a2368c6a2c6a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_shared_groups_for_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::is_document_shared_with_group": { + "boundary": { + "sha256": "b664d0af54c0f57deaf7582d33a4fcedb4a54974b776248ad6047fe55cceda78", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "is_document_shared_with_group: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_documents_shared_with_group": { + "boundary": { + "sha256": "b137a34d4a1c3ceedcba29896c79d02bc3a7fc18b35aafdf638937787e83e0e8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_documents_shared_with_group: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::get_workspace_tags": { + "boundary": { + "sha256": "5a8c2b30bc50b707d78e62588cd334a028661e0c4bdb9dda01f76acce3c4d33e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "get_workspace_tags: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_documents.py::propagate_tags_to_blob_metadata": { + "boundary": { + "sha256": "a252c7057e5a7d9b6e2021936fb51fb17337e4313562d9473b262867794cf3c0", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f04f340b58fc0d660c03a0f218a6024fba70af8e9e5337a4ef6ea5519895f49" + }, + "classification": "sdk-compatible", + "contract": "propagate_tags_to_blob_metadata: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_embedding_compatibility.py::inspect_empty_embedding_stores": { + "boundary": { + "sha256": "f5bff887c0e375421b000aa9992db31519d14f16628e35f050354c6528e9266a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "facts_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "71fe1b8f5e3e548be9f057d959b28b2f985430f6da03bc3e68837c95748ca790" + }, + "classification": "sdk-compatible", + "contract": "inspect_empty_embedding_stores: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_embedding_compatibility.py::persist_fact_with_embedding": { + "boundary": { + "sha256": "5f84ef0e7495641ff891d7a5daea698a8cd6c7e06e6bc6993d27a51883cbeb84", + "points": [ + { + "method": "upsert_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "71fe1b8f5e3e548be9f057d959b28b2f985430f6da03bc3e68837c95748ca790" + }, + "classification": "sdk-compatible", + "contract": "persist_fact_with_embedding: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::_write_with_etag_guard": { + "boundary": { + "sha256": "e94dd9f3af36ebe03ed770d742f559d7443aa0d30326fa60b6bbd025a90d4e5e", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "returned" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "_write_with_etag_guard: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::get_authorized_sync_source": { + "boundary": { + "sha256": "b489d71bee733870574ae480e0bce7dc24717f032b37505d28d8b1922993b0cf", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "get_authorized_sync_source: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::list_file_sync_sources": { + "boundary": { + "sha256": "7f6d99469fe2b70c3cfcb08d3599d76075ba116bdb994324c7633dc0887b3982", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "list_file_sync_sources: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::create_file_sync_source": { + "boundary": { + "sha256": "4a29ec8b6b55930c1be8c9e075a47969fdc5c80f9af47f50a9c67e21c491bda5", + "points": [ + { + "method": "create_item", + "receiver": "_get_sources_container(scope_type)", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "response-unused", + "contract": "create_file_sync_source: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_file_sync.py::delete_file_sync_source": { + "boundary": { + "sha256": "89cf46d55f9f99400925ec442d7b6be638312d03dce6c824965c0ae7fffcb5da", + "points": [ + { + "method": "delete_item", + "receiver": "_get_sources_container(scope_type)", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "delete_file_sync_source: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::list_file_sync_runs": { + "boundary": { + "sha256": "a2292b1e75d7679e7e2cfe5bc9e5bb52d36f002c82eb5934ea20d1aaf2227640", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_get_runs_container(scope_type)", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "list_file_sync_runs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::_create_run": { + "boundary": { + "sha256": "3cc96ae02b4dedffba1307397eae942a9556712e56db7d123cd9a055bea3ebcd", + "points": [ + { + "method": "create_item", + "receiver": "_get_runs_container(source['scope_type'])", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "response-unused", + "contract": "_create_run: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_file_sync.py::_update_run": { + "boundary": { + "sha256": "bdf3034569dac37190ea626b28a6c481f1320a864b12798305129e13ee85d3cf", + "points": [ + { + "method": "upsert_item", + "receiver": "_get_runs_container(run['scope_type'])", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "response-unused", + "contract": "_update_run: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_file_sync.py::process_file_sync_run_by_id": { + "boundary": { + "sha256": "6124d481313fe57e8660500690dd2b0801e59ea262a07954e55f7a1927c579d2", + "points": [ + { + "method": "read_item", + "receiver": "_get_sources_container(scope_type)", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "_get_runs_container(scope_type)", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "process_file_sync_run_by_id: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::_load_existing_items": { + "boundary": { + "sha256": "205276fef67372c1d48d43aafcbf74a953b7b22ee3e365d552d53bd1dc4649a2", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_get_items_container(source['scope_type'])", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "_load_existing_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::_count_active_runs": { + "boundary": { + "sha256": "0a002574af668bb25fe75c28165774524a298e1033fa651987f1ca0cbddd9e61", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_get_runs_container(scope_type)", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "_count_active_runs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::_source_has_active_run": { + "boundary": { + "sha256": "421f529adb9102d224e216c8ff478b400fe30c3db6ef346afdce3c716f30fd38", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_get_runs_container(source['scope_type'])", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "_source_has_active_run: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::_get_due_sources_for_scope": { + "boundary": { + "sha256": "2a2fc9683cf5553b82d959720f5bd5cc3adbf041f52d4df7f757b746c78503f5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_get_sources_container(scope_type)", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "_get_due_sources_for_scope: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_file_sync.py::_read_file_sync_source_for_document_action": { + "boundary": { + "sha256": "a5fe10c45e9cda96611ec1a8dbeba7e467207478b8b2f2e18860f19906b75392", + "points": [ + { + "method": "read_item", + "receiver": "_get_sources_container(scope_type)", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "63f161c702a4c01e757e3f99b171d7e1de1d0d7b19c97895e0452ca5c29abd58" + }, + "classification": "sdk-compatible", + "contract": "_read_file_sync_source_for_document_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_generated_file_approvals.py::list_expired_pending_generated_file_artifacts": { + "boundary": { + "sha256": "93ba8d8aad1721d4f52a9db66526b8497ac4d0c59961199595aaddc341b8dfb2", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0e6fdc72af6ae3b1b7f13be057ddee12d65a2fbc6c6520f83bb0cf37bfe6ecdb" + }, + "classification": "sdk-compatible", + "contract": "list_expired_pending_generated_file_artifacts: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_actions.py::get_global_actions": { + "boundary": { + "sha256": "f48ca62db481735fc54480d260220aa50798edc793ab117d6af6241439b5fe50", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1" + }, + "classification": "sdk-compatible", + "contract": "get_global_actions: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_actions.py::get_global_action": { + "boundary": { + "sha256": "06beac7729d9219e19620c807432d190d6da6777320a107999d741cf177cd3b2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1" + }, + "classification": "sdk-compatible", + "contract": "get_global_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_actions.py::save_global_action": { + "boundary": { + "sha256": "5156bc4729ca3084851df4eaabf5f14a95c890501dc73a6152e665e925fbd911", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1" + }, + "classification": "sdk-compatible", + "contract": "save_global_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_actions.py::delete_global_action": { + "boundary": { + "sha256": "7674102fc2d2dc82e72d05c3d00c889c7ed3e680144537345bf078ff55e5bc67", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_global_actions_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1" + }, + "classification": "sdk-compatible", + "contract": "delete_global_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_actions.py::update_global_action_enabled": { + "boundary": { + "sha256": "363fba9a82a206cdd254ce69b9b3a78b48dcca10d63a9047ab7cc4727abc96ab", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1" + }, + "classification": "sdk-compatible", + "contract": "update_global_action_enabled: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_agents.py::get_global_agents": { + "boundary": { + "sha256": "a07d6cde0c50937ef62c8b2c0def934eda710891b52de7e0e7f08d789f240dbb", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768" + }, + "classification": "sdk-compatible", + "contract": "get_global_agents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_agents.py::get_global_agent": { + "boundary": { + "sha256": "87466d43743b0a517723561263491de813d1cf54a06185a4ecb474fe85b43b8a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768" + }, + "classification": "sdk-compatible", + "contract": "get_global_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_agents.py::save_global_agent": { + "boundary": { + "sha256": "dd1b2de959dd1064989f66ae7f68116f31c2f55978a9f4b74929a24bd8e3e563", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768" + }, + "classification": "sdk-compatible", + "contract": "save_global_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_agents.py::delete_global_agent": { + "boundary": { + "sha256": "fc5b63ea44747a8f8cac3ce50ffdd1a2001b133b84c7d3f99855c3be0211fb12", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_global_agents_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768" + }, + "classification": "sdk-compatible", + "contract": "delete_global_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_global_agents.py::update_global_agent_enabled": { + "boundary": { + "sha256": "dd247e225c4422edb5c07aa149c05d522353ceba224e71e0d5ffe2c0ce36d393", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768" + }, + "classification": "sdk-compatible", + "contract": "update_global_agent_enabled: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::_read_stored_feature_policy": { + "boundary": { + "sha256": "7ef077434901e851e9d5e0ce7d9fb1cc0da752db39d860d892abdb456898d7fe", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_governance_policies_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "_read_stored_feature_policy: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::_read_item_policies": { + "boundary": { + "sha256": "5ea52f69c3e1b771eabea40da752047e9e7b76af321b3103ef88cf3df8d8af23", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_governance_item_policies_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "_read_item_policies: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::_read_stored_item_policy": { + "boundary": { + "sha256": "75885bf8515dfe187aee2ef954cdd1621a7716e103bd08b827d61b1055f4fb71", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_governance_item_policies_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "_read_stored_item_policy: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::upsert_feature_policy": { + "boundary": { + "sha256": "f8ee2ee205f4d4cc4bbcb9c4e8ceec8b086908b95bb54cc7ff9e775cf40b2f02", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_governance_policies_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "upsert_feature_policy: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::upsert_item_policy": { + "boundary": { + "sha256": "bdfcfa8c51906b56ca681b1267e5fa6248e3fd4109d706b5b4e5d5dcaf2e2d03", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_governance_item_policies_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_governance_item_policies_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_governance_item_policies_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "upsert_item_policy: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::_read_existing_item_policy_for_delete": { + "boundary": { + "sha256": "7b1081b6d08d02d39c6d06bbed3df28166527dfccb6c0a302b957313e7d1d5f2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_governance_item_policies_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_governance_item_policies_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "_read_existing_item_policy_for_delete: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::retarget_item_policy": { + "boundary": { + "sha256": "a8aea44eb3c83ca87a4625165dbfd2c591f71d7046c47dc0dba1bf9d2cb23893", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_governance_item_policies_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "response-unused", + "contract": "retarget_item_policy: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_governance.py::delete_item_policy": { + "boundary": { + "sha256": "0bc0016c518eb833757dda5f1537acc800395bf0a182093e9d02dc09910e06c1", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_governance_item_policies_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "response-unused", + "contract": "delete_item_policy: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_governance.py::list_feature_policies": { + "boundary": { + "sha256": "34c57ce8e70aa88119be09ba446098784095f3ef59ff29df5064d2ee63752b05", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_governance_policies_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "list_feature_policies: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::list_item_policies": { + "boundary": { + "sha256": "d78236b0574cf23133b88ad582daca7f8bc8265e2f6930c77dc6b5a5e4aec55e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_governance_item_policies_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_governance_item_policies_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "list_item_policies: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::list_item_policies_by_policy_id": { + "boundary": { + "sha256": "bf3d817087f0733612da3a7c9aaf0159e0f2f58e982efc267c8cfdfbd329d0dc", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_governance_item_policies_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "sdk-compatible", + "contract": "list_item_policies_by_policy_id: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_governance.py::bootstrap_default_feature_policies": { + "boundary": { + "sha256": "c22d56a6e85b6004683f582ee6ad75bd4bc7fb020a7477f9285302418b5a6e5f", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_governance_policies_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d" + }, + "classification": "response-unused", + "contract": "bootstrap_default_feature_policies: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_group.py::create_group": { + "boundary": { + "sha256": "fba53efb319bf42254ccc86345e5980cf102ad8d80f7e45d963b566c3e6f55ea", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_groups_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "response-unused", + "contract": "create_group: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_group.py::search_groups": { + "boundary": { + "sha256": "2b410088ff1accc0e4aede5797db454700ba9aa3913bdbf679e063337999e001", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "sdk-compatible", + "contract": "search_groups: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group.py::search_all_groups": { + "boundary": { + "sha256": "7a345b4fa2344585390f67d858a0f3c85e9ce8c276b02ee3e2f603306cfccb00", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "sdk-compatible", + "contract": "search_all_groups: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group.py::find_groups_by_ids": { + "boundary": { + "sha256": "a3f4c6aad35cca9df64a6c9129730a5169502592566cfe98139e2cb04613711e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "sdk-compatible", + "contract": "find_groups_by_ids: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group.py::list_groups_for_admin_directory": { + "boundary": { + "sha256": "cd8e30dda80ad391ac364c2c1b7cfd1dbe554324d8df573998e8957e053b0bab", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "sdk-compatible", + "contract": "list_groups_for_admin_directory: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group.py::get_user_groups": { + "boundary": { + "sha256": "3738f18009c7d241642fb17e972b7290caca75c0e450d911ee0c972d9624c302", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "sdk-compatible", + "contract": "get_user_groups: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group.py::find_group_by_id": { + "boundary": { + "sha256": "364ab7847a8fd50ed4eb145de1f71ff1dc6a953009559de56b178596d7d90206", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "sdk-compatible", + "contract": "find_group_by_id: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group.py::discover_group_records": { + "boundary": { + "sha256": "4de430f31b8e3879fd06279f59176b375914b21ccd46bc6f61c1262939e40231", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "sdk-compatible", + "contract": "discover_group_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group.py::delete_group": { + "boundary": { + "sha256": "f32d321fc87859808cac4cbf3102d28e7d8d3c255d2e9456545679adcb71103f", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_groups_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "response-unused", + "contract": "delete_group: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_group.py::update_group_document_with_etag_guard": { + "boundary": { + "sha256": "7966f21ba0d02a709c499271cb163c42a3aaef53cc3d471932beba4a17a4ef59", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "11084bfa4a4824b6d1df9aeecc39d1b7f77c7dd5369ce43fa695df3080a78812" + }, + "classification": "sdk-compatible", + "contract": "update_group_document_with_etag_guard: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_actions.py::get_group_actions": { + "boundary": { + "sha256": "44257a71303f0aa964003704cb3bc1e4726c36897664d893d2614fc7239c8e1e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f974e05320904cc49bcbe9ae0b51ededa85733f01f391dc71f00801715f4fa20" + }, + "classification": "sdk-compatible", + "contract": "get_group_actions: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_actions.py::get_group_action": { + "boundary": { + "sha256": "c878130377dde9aa9f4944159b4d1d2b4f00435433a287c90e3daedc56ee85a5", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_actions_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f974e05320904cc49bcbe9ae0b51ededa85733f01f391dc71f00801715f4fa20" + }, + "classification": "sdk-compatible", + "contract": "get_group_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_actions.py::save_group_action": { + "boundary": { + "sha256": "398c6c9077307aab6ee002062bf0759f2d8691f1d7f54a2d58fa60e8e224c4c2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_actions_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_group_actions_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_group_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f974e05320904cc49bcbe9ae0b51ededa85733f01f391dc71f00801715f4fa20" + }, + "classification": "sdk-compatible", + "contract": "save_group_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_actions.py::delete_group_action": { + "boundary": { + "sha256": "d9c65156b7cb97d51c3b272647139823600a4ee7430d3ef1486dc92266d44631", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_actions_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_group_actions_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f974e05320904cc49bcbe9ae0b51ededa85733f01f391dc71f00801715f4fa20" + }, + "classification": "sdk-compatible", + "contract": "delete_group_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_agents.py::get_group_agents": { + "boundary": { + "sha256": "d66936b1c1fc4d0b112fc50651a71c0965166ba735a3a0168156b22e100ab7c3", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_agents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "bd655e3f50d7513a07458457de9d8c13b8a8384a1dbb2d7fbf0e76bd2382c5f1" + }, + "classification": "sdk-compatible", + "contract": "get_group_agents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_agents.py::get_group_agent": { + "boundary": { + "sha256": "6bbbde245c75f8b133db5f71da4a3d133f9377bdfb854555db2f94ff83ed5e1b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_agents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "bd655e3f50d7513a07458457de9d8c13b8a8384a1dbb2d7fbf0e76bd2382c5f1" + }, + "classification": "sdk-compatible", + "contract": "get_group_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_agents.py::save_group_agent": { + "boundary": { + "sha256": "07bbabbae7b011c45d81d1f18852e5531c8cf189aedacaf244628f1310425960", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_agents_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_group_agents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "bd655e3f50d7513a07458457de9d8c13b8a8384a1dbb2d7fbf0e76bd2382c5f1" + }, + "classification": "sdk-compatible", + "contract": "save_group_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_agents.py::delete_group_agent": { + "boundary": { + "sha256": "ed27863285b9b53309362f566f7ee69cd59a5b4df107560f48baf517d2068657", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_agents_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_group_agents_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "bd655e3f50d7513a07458457de9d8c13b8a8384a1dbb2d7fbf0e76bd2382c5f1" + }, + "classification": "sdk-compatible", + "contract": "delete_group_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_directory.py::list_group_directory": { + "boundary": { + "sha256": "366e7e0cc3180f9f4b66f7b5230ffc0f34d34f7c20187f393fcb14f0021e1ca8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "cb67c7e2d4ed87d04e4ea6e6997a8aba181b1dd9845a7041ed7eedac7cbd9693" + }, + "classification": "sdk-compatible", + "contract": "list_group_directory: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_access.py::read_group_document_record": { + "boundary": { + "sha256": "3a90a3fe17ea041fa63bfa59aac7b2d7a062512ab28b429cc23a2a6f8cefdef3", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "01063006a57ae3950f3263ed00928470b3abf5b821506df27b8d091043b54c4b" + }, + "classification": "sdk-compatible", + "contract": "read_group_document_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_access.py::group_document_cleanup_allowed": { + "boundary": { + "sha256": "19e8816ff30cbd57ea90ebf207916a6a07ebfeb4279e1bfa362857181a445743", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_content_screening_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "01063006a57ae3950f3263ed00928470b3abf5b821506df27b8d091043b54c4b" + }, + "classification": "sdk-compatible", + "contract": "group_document_cleanup_allowed: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_access.py::group_document_family_records": { + "boundary": { + "sha256": "4017d60b880bf52e622c7761eda48bf7d28fe23157c5179515a44af6bfe42c7f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "01063006a57ae3950f3263ed00928470b3abf5b821506df27b8d091043b54c4b" + }, + "classification": "sdk-compatible", + "contract": "group_document_family_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_collaboration.py::_replace": { + "boundary": { + "sha256": "e53730650c34e6ca0092bc2e5f7e846d09ac2ed52d6723a30cff183dcbb00929", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4c4e8a5b21d9f3178521192bead8cfd1815dbc3e3820daa872e2ad3e1fd6cccb" + }, + "classification": "sdk-compatible", + "contract": "_replace: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_management.py::_patch_tag_definitions": { + "boundary": { + "sha256": "965ea1f62d9876e817c7eb3fc5587e756dd0fa659a9e953bc686bffe4de4b936", + "points": [ + { + "method": "patch_item", + "receiver": "cosmos_groups_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a09154616e4a1bb4dc5372a63ff66d2cc0839efd0adb0e9c5f48c97f80de4eec" + }, + "classification": "sdk-compatible", + "contract": "_patch_tag_definitions: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_management.py::_current_owned_documents": { + "boundary": { + "sha256": "06f498d6e46ae44bc1bf500ac0b80de47ccb60cd9d82df3d109a947c0aef276c", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "a09154616e4a1bb4dc5372a63ff66d2cc0839efd0adb0e9c5f48c97f80de4eec" + }, + "classification": "sdk-compatible", + "contract": "_current_owned_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_projection_fence.py::_read_source": { + "boundary": { + "sha256": "6a82b334a000459e1ca892563c8ae3ecd61bd62d50fa267202c027e4fb1893a9", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "67c0cbf3306378b707ba938ff1deb96273f8738360181841211bf577b079d05d" + }, + "classification": "sdk-compatible", + "contract": "_read_source: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_projection_fence.py::_replace_source": { + "boundary": { + "sha256": "4488f7e94f4d8c9086cf8551f49360775f3f49c18c2c2bd94f72ea5305fb853c", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "67c0cbf3306378b707ba938ff1deb96273f8738360181841211bf577b079d05d" + }, + "classification": "sdk-compatible", + "contract": "_replace_source: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_publication.py::decide_group_document_publication": { + "boundary": { + "sha256": "907a5b60e3781b2fbe0a94e4ef1620c41b89f4b8e8fb89a08ad3b180d26c6922", + "points": [ + { + "method": "read_item", + "receiver": "publication.cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7cfee4023fee65493f57fed44a235331c454457dd9b2acb1c124422840ab64dc" + }, + "classification": "sdk-compatible", + "contract": "decide_group_document_publication: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_document_reads.py::_query_group_document_records": { + "boundary": { + "sha256": "aebe1a7978812e14b0c694400d5e63c33a6ec3f598c62a9f820295aaba608e30", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "72fea9c85ba865801bdd9e9bcf151820e6904addb1b37672b7a49c315550c8b2" + }, + "classification": "sdk-compatible", + "contract": "_query_group_document_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_endpoint_access.py::find_group_endpoint_references": { + "boundary": { + "sha256": "c12451273e949ee7773379755da4d5650093e37f876310bfc53c3572929a16bd", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_agents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "df122c97599e66467c6caa5acb336ab568500e788585183f260ede8d6edf91e4" + }, + "classification": "sdk-compatible", + "contract": "find_group_endpoint_references: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_insights.py::read_group_activity": { + "boundary": { + "sha256": "02a6ceb6137a7e3dfe75426d2768593c0dbfca8002a175c76e41bf83ac6bbb58", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "17771f87e419b3db9bd88ac22db9217fe38c251fa83c384cd0dee8f445d963c2" + }, + "classification": "sdk-compatible", + "contract": "read_group_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_insights.py::read_group_stats_rows": { + "boundary": { + "sha256": "286a81c4e2d06ca24524dd8fa29028c66e53bd0a20c31db7877a604c886e184a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "17771f87e419b3db9bd88ac22db9217fe38c251fa83c384cd0dee8f445d963c2" + }, + "classification": "sdk-compatible", + "contract": "read_group_stats_rows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_membership_audit.py::log_group_member_role_change": { + "boundary": { + "sha256": "8bb45ee8df6679ffc5afa1d8329430c6ff8e1cf445d80d2c7fad3072089f95a4", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7ac6ddacc88bfec1d8c21c378a6dfb92498274bb3d8f8bae5b6c428ed72f31ca" + }, + "classification": "response-unused", + "contract": "log_group_member_role_change: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_group_workflows.py::_normalize_group_workflow_conversation_id": { + "boundary": { + "sha256": "d2f0ac990a4b66131a7967389f9b6007ff10c89a473f12d4c81b3dadc4209c74", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "_normalize_group_workflow_conversation_id: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::get_group_workflows": { + "boundary": { + "sha256": "4f943219bcc99c0089a31eba95b585937d567abfbb4b48534b0bd6302494c1ba", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "get_group_workflows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::get_group_workflow": { + "boundary": { + "sha256": "3b19231886f2f1c7116d3883ae38a9e6b9e601ce11ca92204e64402ce753e5a6", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_workflows_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "get_group_workflow: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::get_due_group_workflows": { + "boundary": { + "sha256": "73c1e21224746b5331d2aaf760f615fd781bb6ba44563b212fcfb6af4acb0230", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "get_due_group_workflows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::list_group_workflow_runs": { + "boundary": { + "sha256": "0472f91b976597560df7fbc9e3ebd609e89d85233607450ef7eee0adee317000", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_workflow_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "list_group_workflow_runs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::get_group_workflow_run": { + "boundary": { + "sha256": "26a98a98b22a86265b43a5c496dd979cd51aa0d709d2d129f84a66599bfe3c4b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_workflow_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "get_group_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::get_latest_group_workflow_run_for_conversation": { + "boundary": { + "sha256": "2f346c495c5b141cce5c0a70672e675de3c1c667e8102f41fa92c477d2aada27", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_workflow_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "get_latest_group_workflow_run_for_conversation: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::save_group_workflow_run": { + "boundary": { + "sha256": "b3305f400e0d0814f32b00a3c043622a9f7c0b87efb6ebb8d980e3eebf3490ee", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_group_workflow_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "save_group_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::save_group_workflow_run_item": { + "boundary": { + "sha256": "d0b2a68046ed60569bfa48313ba29059609b4bf9ba47e41566e5b4de1b4522d4", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_group_workflow_run_items_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "save_group_workflow_run_item: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::get_group_workflow_run_item": { + "boundary": { + "sha256": "e1f1a0b97b96c5a070196bf252118f1a214026946691e9c3808187f9fc32bb06", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_group_workflow_run_items_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "get_group_workflow_run_item: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::list_group_workflow_run_items": { + "boundary": { + "sha256": "375cb94037bda4d7accfb133a40ca199cd512a18770883489c8ca43193f01e73", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_workflow_run_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "sdk-compatible", + "contract": "list_group_workflow_run_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_group_workflows.py::delete_group_workflow": { + "boundary": { + "sha256": "884453e79ebac453abf1aed5561e0810f281451507ca3ed29d42861818476613", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_group_workflow_run_items_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_group_workflow_runs_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_group_workflows_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_workflow_runs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_workflow_run_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8f774a2027d75fc8f2958f1c973a81e14e83875002d3cb28f8a040b0e5c0316a" + }, + "classification": "response-unused", + "contract": "delete_group_workflow: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_image_generation.py::generate_chat_image_message": { + "boundary": { + "sha256": "f84591ad3631ababa97bad8124d94b3998413f4d5e9d167cce2874d3c39be2a8", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a60da3943007a93c52417c75ce0b6f8d1b64407ef405a04d444b7b08e82bff5a" + }, + "classification": "response-unused", + "contract": "generate_chat_image_message: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_image_messages.py::get_complete_image_content": { + "boundary": { + "sha256": "3eabaf85d1d97c233907ebbe124e07a198bbf6a286e6234dd4fddee38bb4d181", + "points": [ + { + "method": "read_item", + "receiver": "message_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "message_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d8e7a7409e3f236cd5308741e0479e8dba94bbe130c816231bf17dc65b1a93aa" + }, + "classification": "sdk-compatible", + "contract": "get_complete_image_content: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_keyvault_reminders.py::upsert_key_vault_secret_reminder": { + "boundary": { + "sha256": "68a720386ee906ad81a21a0a2acedb862ab5c24d2a92a7dfa8fde5e82718a7ec", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_key_vault_secret_reminders_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_key_vault_secret_reminders_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0b40c4876a7a8a096d6ad9e399c0b79aa28a7f5726644ef91e82de544f07ad88" + }, + "classification": "sdk-compatible", + "contract": "upsert_key_vault_secret_reminder: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_keyvault_reminders.py::mark_key_vault_secret_reminder_disabled": { + "boundary": { + "sha256": "5764e630b5561ca10e06f1d83728cd36da5bc1263fbb83ec7dc66f1909d95b98", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_key_vault_secret_reminders_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_key_vault_secret_reminders_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_key_vault_secret_reminders_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0b40c4876a7a8a096d6ad9e399c0b79aa28a7f5726644ef91e82de544f07ad88" + }, + "classification": "sdk-compatible", + "contract": "mark_key_vault_secret_reminder_disabled: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_keyvault_reminders.py::list_key_vault_secret_reminders": { + "boundary": { + "sha256": "5adcef66bb2425c406e6f99e92d577c027a3fbb081fbb0810f6fde66893bcc1f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_key_vault_secret_reminders_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0b40c4876a7a8a096d6ad9e399c0b79aa28a7f5726644ef91e82de544f07ad88" + }, + "classification": "sdk-compatible", + "contract": "list_key_vault_secret_reminders: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_keyvault_reminders.py::check_due_key_vault_secret_reminders_once": { + "boundary": { + "sha256": "abcbc62dfbdf7b189d6dbc3f458a4a7d29be825e185dd81ef2725422616271f0", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_key_vault_secret_reminders_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0b40c4876a7a8a096d6ad9e399c0b79aa28a7f5726644ef91e82de544f07ad88" + }, + "classification": "response-unused", + "contract": "check_due_key_vault_secret_reminders_once: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_logging.py::delete_file_processing_logs": { + "boundary": { + "sha256": "bbd78ee77d657f7395637baddc19a0caf283cf78a0e566eca87e035c9bda20b6", + "points": [ + { + "method": "delete_item", + "receiver": "target_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "target_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "aa092f523b2fb4ebda6b7c1b090cde94256c078c11644cc5aac0151bc00cdc68" + }, + "classification": "response-unused", + "contract": "delete_file_processing_logs: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_logging.py::add_file_task_to_file_processing_log": { + "boundary": { + "sha256": "457beed78345bc6077c386c4b90354055396b1afc4f51175422f862709a0293c", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_file_processing_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "aa092f523b2fb4ebda6b7c1b090cde94256c078c11644cc5aac0151bc00cdc68" + }, + "classification": "response-unused", + "contract": "add_file_task_to_file_processing_log: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_agent_continuation.py::AgentContinuationJournal._job": { + "boundary": { + "sha256": "38a3c4a38b0331a58845de19f984151fc9b0644859ebab5c56a28728844bf4a1", + "points": [ + { + "method": "read_item", + "receiver": "self.jobs", + "response": "returned" + }, + { + "method": "create_item", + "receiver": "self.jobs", + "response": "returned" + }, + { + "method": "read_item", + "receiver": "self.jobs", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "777fe3b284e3ee4bab85f72d100a6ae8e1a9fad93c2dbc77587275bbd4efc6aa" + }, + "classification": "sdk-compatible", + "contract": "AgentContinuationJournal._job: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_m365_agent_continuation.py::AgentContinuationJournal._save_reference": { + "boundary": { + "sha256": "a43164912a9e5c34ae26e81f716e718b107d7dd7b6a9abd36be453a83fdeee4d", + "points": [ + { + "method": "replace_item", + "receiver": "self.jobs", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "777fe3b284e3ee4bab85f72d100a6ae8e1a9fad93c2dbc77587275bbd4efc6aa" + }, + "classification": "response-unused", + "contract": "AgentContinuationJournal._save_reference: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService._read": { + "boundary": { + "sha256": "bc411c2e1b68a6a96377e84a3318448de95a99c3c6a43391a719ab0ce8388631", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "sdk-compatible", + "contract": "Approval point records use mapping fields and conditional writes; operation receipts cross the separate normalized journal boundary.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_approvals_execution.py" + ] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService._create_once": { + "boundary": { + "sha256": "3109d7bce82022889d2382fae8c0f26be01e644af0d9c069418746a7c786fd24", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "sdk-compatible", + "contract": "Approval point records use mapping fields and conditional writes; operation receipts cross the separate normalized journal boundary.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_approvals_execution.py" + ] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService._batch": { + "boundary": { + "sha256": "a5ab035924002ea4a15830219c2e5ad3e303f4d222b9e689b2546b5584f10aa4", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "response-unused", + "contract": "M365ApprovalService._batch: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService._notify": { + "boundary": { + "sha256": "466bd8056f66c645605fde559c93aecf508ba30f35474d8798b729f4ac3ffabd", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "sdk-compatible", + "contract": "Approval point records use mapping fields and conditional writes; operation receipts cross the separate normalized journal boundary.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_approvals_execution.py" + ] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService._records": { + "boundary": { + "sha256": "2ff7c9aa0e0369858a1d516209fda03eebe2423b91210e17eee7e0812b61c556", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "returned" + } + ], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "sdk-compatible", + "contract": "Approval point records use mapping fields and conditional writes; operation receipts cross the separate normalized journal boundary.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_approvals_execution.py" + ] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService._create_self_authored_binding": { + "boundary": { + "sha256": "80bfd6d145a5964e670bc893d789b27685b070a52d3f3767ef1901f197c0aa9f", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "response-unused", + "contract": "M365ApprovalService._create_self_authored_binding: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService.claim_continuation": { + "boundary": { + "sha256": "7de9e649ab3052edd557e66f44d7d41aff69f6533f2f22a31c1c64cb1671bbf2", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "response-unused", + "contract": "M365ApprovalService.claim_continuation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService.list_records": { + "boundary": { + "sha256": "e79d493fa22a320459fc3847f5c94a13d62e57c11f68f9d9c9c61784ec771a8a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "sdk-compatible", + "contract": "Approval point records use mapping fields and conditional writes; operation receipts cross the separate normalized journal boundary.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_approvals_execution.py" + ] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService.list_conversation_audit": { + "boundary": { + "sha256": "e2b822f0ed7756df009298b18a1bbd8626957447613826e9cc63fbcaccfae817", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "sdk-compatible", + "contract": "Approval point records use mapping fields and conditional writes; operation receipts cross the separate normalized journal boundary.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_approvals_execution.py" + ] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService.expire_pending": { + "boundary": { + "sha256": "29e62460fcd984b36c7bb031b0ed4751102f21b0c13c4850f1971d2bc12959e8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "sdk-compatible", + "contract": "Approval point records use mapping fields and conditional writes; operation receipts cross the separate normalized journal boundary.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_approvals_execution.py" + ] + }, + "application/single_app/functions_m365_approvals.py::M365ApprovalService.list_pending_continuations": { + "boundary": { + "sha256": "14f6d1acfea9a20f8514ea1ad51af8f84c434b22a588d64532101cfd12a938dc", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5" + }, + "classification": "sdk-compatible", + "contract": "Approval point records use mapping fields and conditional writes; operation receipts cross the separate normalized journal boundary.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_approvals_execution.py" + ] + }, + "application/single_app/functions_m365_connections.py::M365ConnectionService._read": { + "boundary": { + "sha256": "5701c522de37b955d94183789200765c5f3742f65a153c522dd9fbec99b34461", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8034d50df9e8443b886517094846d07aea5e807e73346d9158252d91d2df1a48" + }, + "classification": "sdk-compatible", + "contract": "Connection point records are mapping-compatible; owner, tenant, ETag and partition checks remain unchanged.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_connections.py" + ] + }, + "application/single_app/functions_m365_connections.py::M365ConnectionService._replace": { + "boundary": { + "sha256": "2478fb2888e536ab40978c343ce2e659bf3e1c541359a479a360ffc19ac15398", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8034d50df9e8443b886517094846d07aea5e807e73346d9158252d91d2df1a48" + }, + "classification": "sdk-compatible", + "contract": "Connection point records are mapping-compatible; owner, tenant, ETag and partition checks remain unchanged.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_connections.py" + ] + }, + "application/single_app/functions_m365_connections.py::M365ConnectionService._ensure_connection": { + "boundary": { + "sha256": "185c6764d7621688b751295e06307e7c926116a1ddac1593d9e4aff963b7456f", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8034d50df9e8443b886517094846d07aea5e807e73346d9158252d91d2df1a48" + }, + "classification": "sdk-compatible", + "contract": "Connection point records are mapping-compatible; owner, tenant, ETag and partition checks remain unchanged.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_connections.py" + ] + }, + "application/single_app/functions_m365_connections.py::M365ConnectionService.start_connection": { + "boundary": { + "sha256": "f311893a8487e66263903cf506fbccc0c3b9ff28d189f013a2c58950d7efea85", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8034d50df9e8443b886517094846d07aea5e807e73346d9158252d91d2df1a48" + }, + "classification": "response-unused", + "contract": "M365ConnectionService.start_connection: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_continuations.py::resume_pending_workflows": { + "boundary": { + "sha256": "3accc15e22395eaf9789dd4558b5d24167ca3635b0894f746ee0f80d72a2f164", + "points": [ + { + "method": "replace_item", + "receiver": "jobs", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "jobs", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "jobs", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "jobs", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "jobs", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "db9760942b3f642015113ec6067879f6982a2ea06a0c040c66d1c2c36cedaa0b" + }, + "classification": "sdk-compatible", + "contract": "resume_pending_workflows: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_m365_file_runtime.py::resolve_m365_budget_run": { + "boundary": { + "sha256": "4fcd38af27c9c4047a3922353919555a9c378b648ab849c61d1d585f8d3549ed", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c621a160a202ca8e92cde73b76d8264f4165ae0859d2b90a7670ac8d5e8b444d" + }, + "classification": "sdk-compatible", + "contract": "File-runtime point records and checkpoint state use mapping fields; the SDK-default container covers returned writes without cloud access.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_file_runtime.py" + ] + }, + "application/single_app/functions_m365_history.py::M365HistoryService.prepare": { + "boundary": { + "sha256": "c54c18eaa7c82499a4350b150180e9469c436bc00bdbff7725df160148b00c77", + "points": [ + { + "method": "upsert_item", + "receiver": "self.jobs", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "self.jobs", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "self.jobs", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f7d090e10c507826cae67b1f5ed0e88a4cd92224f214c28241b7168732cd63dd" + }, + "classification": "response-unused", + "contract": "M365HistoryService.prepare: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_history.py::M365HistoryService.validate_decision": { + "boundary": { + "sha256": "f1d8dc5ceeee632d714e5a986d9638558753b3666eee6d23ee3c8cf364444b4b", + "points": [ + { + "method": "read_item", + "receiver": "self.jobs", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f7d090e10c507826cae67b1f5ed0e88a4cd92224f214c28241b7168732cd63dd" + }, + "classification": "sdk-compatible", + "contract": "History point reads bind conversation/message identity through mapping fields; sanitized public payloads are owner-built projections.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_history_publication.py" + ] + }, + "application/single_app/functions_m365_pending_delivery.py::notify_m365_pending_delivery": { + "boundary": { + "sha256": "b8964d89647848fdb5b3e0665e7c78d490d9e86b17a149cbff287e4299b717fd", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "15128fe4661fc4787674ac871b6ab36a4802b26dc74feac4b5d710522f595bb1" + }, + "classification": "sdk-compatible", + "contract": "Delivery status and leases use mapping fields; responses are not strict domain result envelopes or authority to repeat an effect.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_pending_delivery.py::_read_delivery": { + "boundary": { + "sha256": "cfbba8b15e3e52d0392d6a3fcb3025c1737203b2bba600c0eb64fcdfe6f0557c", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "15128fe4661fc4787674ac871b6ab36a4802b26dc74feac4b5d710522f595bb1" + }, + "classification": "sdk-compatible", + "contract": "Delivery status and leases use mapping fields; responses are not strict domain result envelopes or authority to repeat an effect.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_pending_delivery.py::_save_claimed_outcome": { + "boundary": { + "sha256": "302146ea297b590f1c950a68ff3589523afe51e50f20f611158b585706577aaf", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "15128fe4661fc4787674ac871b6ab36a4802b26dc74feac4b5d710522f595bb1" + }, + "classification": "sdk-compatible", + "contract": "Delivery status and leases use mapping fields; responses are not strict domain result envelopes or authority to repeat an effect.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_pending_delivery.py::dispatch_m365_pending_delivery": { + "boundary": { + "sha256": "65ac667ed3f6abd5675964c1324397791bcc68e46430fca42f8136c9209d49ce", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "15128fe4661fc4787674ac871b6ab36a4802b26dc74feac4b5d710522f595bb1" + }, + "classification": "sdk-compatible", + "contract": "Delivery status and leases use mapping fields; responses are not strict domain result envelopes or authority to repeat an effect.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_pending_delivery.py::dispatch_due_m365_deliveries": { + "boundary": { + "sha256": "f24659e984c4d20cd189dba27efb28849c31a7e0c858de84a4b4131cca24e12c", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "15128fe4661fc4787674ac871b6ab36a4802b26dc74feac4b5d710522f595bb1" + }, + "classification": "sdk-compatible", + "contract": "Delivery status and leases use mapping fields; responses are not strict domain result envelopes or authority to repeat an effect.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_pending_delivery.py::cancel_m365_run_deliveries": { + "boundary": { + "sha256": "93e74d510151c23e29b45eda5de74d8c10ec4c28fe430c2f8e7200aff029b1b8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_dependencies['container']", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "15128fe4661fc4787674ac871b6ab36a4802b26dc74feac4b5d710522f595bb1" + }, + "classification": "sdk-compatible", + "contract": "Delivery status and leases use mapping fields; responses are not strict domain result envelopes or authority to repeat an effect.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_pending_delivery.py::cancel_m365_conversation_deliveries": { + "boundary": { + "sha256": "fc4ff5f6544051c85fc2c6bf69d0bad7b5330af9b77736bbb2f437a6bd9b1b94", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_dependencies['container']", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "15128fe4661fc4787674ac871b6ab36a4802b26dc74feac4b5d710522f595bb1" + }, + "classification": "sdk-compatible", + "contract": "Delivery status and leases use mapping fields; responses are not strict domain result envelopes or authority to repeat an effect.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_request_resume.py::queue_approved_chat": { + "boundary": { + "sha256": "35b789fdb83fb382ba1c5964e714007b590f5622963b2ecca8116a513c67a1ea", + "points": [ + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a6f545de1ed2f9428c30a5c16a716da29742723dcfb0dcd23239c320ad502010" + }, + "classification": "sdk-compatible", + "contract": "Resume claim records use dictionary-compatible identity/state fields and conditional ETags, not strict outer JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_request_resume.py::get_m365_chat_request": { + "boundary": { + "sha256": "0b8d9f5421b663b3e82ec20e6b896c5815b89aa71bb85b1ae84a23da3222472b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a6f545de1ed2f9428c30a5c16a716da29742723dcfb0dcd23239c320ad502010" + }, + "classification": "sdk-compatible", + "contract": "Resume claim records use dictionary-compatible identity/state fields and conditional ETags, not strict outer JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_request_resume.py::_queue_chat_job": { + "boundary": { + "sha256": "30030c2ec8012411a10e5b5b1919a9ce13218c6ae525b07ee898715ddcb8e559", + "points": [ + { + "method": "replace_item", + "receiver": "jobs", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "jobs", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a6f545de1ed2f9428c30a5c16a716da29742723dcfb0dcd23239c320ad502010" + }, + "classification": "sdk-compatible", + "contract": "Resume claim records use dictionary-compatible identity/state fields and conditional ETags, not strict outer JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_request_resume.py::_execute_chat_continuation": { + "boundary": { + "sha256": "bca40cc675f16a2817b46f48162d5432a842c5776942db6df3aa2734d74c0a97", + "points": [ + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "jobs", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a6f545de1ed2f9428c30a5c16a716da29742723dcfb0dcd23239c320ad502010" + }, + "classification": "sdk-compatible", + "contract": "Resume claim records use dictionary-compatible identity/state fields and conditional ETags, not strict outer JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::_conversation_access": { + "boundary": { + "sha256": "e94df4808e4592ec18eb9010d8fcd6f09e3abc0903cee71514ff65d980e92f80", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::read_pending_m365_chat_request": { + "boundary": { + "sha256": "c35a9095736a4c9f4752403fb57273c2099bfa3dc7ffcf1bee0e49d3d4bcaf58", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::initialize_m365_chat_context": { + "boundary": { + "sha256": "78c3195f52aa2130c40796040e6dd9dbb131c76fdf54873ee894250de3977992", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "response-unused", + "contract": "initialize_m365_chat_context: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_runtime.py::ensure_m365_execution_record": { + "boundary": { + "sha256": "5848d54df3d21b12d05977ceb0ce9100152aa812107904cadc036b6df61b3fa7", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::_begin_step_m365_request": { + "boundary": { + "sha256": "1a0d49690da4403001806ce06036feab699410c719d35f3cfbc7bad0aa6967d9", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::_finish_step_m365_request": { + "boundary": { + "sha256": "dfbde90b1416ac2b5eec4dd32401533a2741fad99fa3883957faabbb7d6f0e0a", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::configure_m365_pending_delivery_runtime.capture_step_reference": { + "boundary": { + "sha256": "3d24fc1797cbd9b33122e2d9c2ab1960444691ab2889976308f9bf813aac7073", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::configure_m365_pending_delivery_runtime.delivery_context": { + "boundary": { + "sha256": "aaa98ff7ca4c425aa186a13e30f60ed691318dd0226ebfa3629ec389e4806d3a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::validate_m365_approval_decision": { + "boundary": { + "sha256": "4f826c8ed178865620e59ab6d82d67decd6beec8bacbeef0ce461230d69b4981", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::record_m365_auth_wait": { + "boundary": { + "sha256": "af8dd5ee33d78057062dbf8716aa293f6547a8fe074c1ced26ddcc95a7486758", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::configure_m365_history_runtime.read_conversation": { + "boundary": { + "sha256": "81f74cc8de28bd0ab1fb0ca3a7cc6b7a2b8516ff6857d19fdb0145d2141e641c", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::configure_m365_history_runtime.read_messages": { + "boundary": { + "sha256": "0865df916310260aa1726aa65944a839bed4e99d2f260ae3843cc73550c6e281", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "returned" + } + ], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::configure_m365_history_runtime.has_active_request": { + "boundary": { + "sha256": "6422ab69881531452236ad4c61df7b7fd31f6abf27ad7921a9759c45738d9611", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::record_m365_pending": { + "boundary": { + "sha256": "f6ea113efe3512445b7deb94d22934253f4433ee516f27256c4918792f396459", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::_save_m365_wait_record": { + "boundary": { + "sha256": "2797013dea000e9806d96b32c6e43c53ddc924102879b15533a1c48f4555de78", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "response-unused", + "contract": "_save_m365_wait_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_runtime.py::complete_m365_request": { + "boundary": { + "sha256": "3f7312d6e3535ba4ecb3b081d3ab6a64de5a2c16ef115231ecf667221b822727", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_m365_execution_runs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "sdk-compatible", + "contract": "Pending request and delivery reads remain mapping-compatible; strict result contracts receive projected domain results, not point wrappers.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_m365_runtime_adapters.py" + ] + }, + "application/single_app/functions_m365_runtime.py::cancel_m365_workflow_requests": { + "boundary": { + "sha256": "f92501ebe5ab9902fa3034ed1f67086ff91b31dac29aa8cdd142e8f93a59ad0f", + "points": [ + { + "method": "replace_item", + "receiver": "jobs", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "jobs", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f3c26da87cf765144801233fa2df5d037d93ce308d3a3f0a54ed13ab65d1d597" + }, + "classification": "response-unused", + "contract": "cancel_m365_workflow_requests: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_m365_workflow_checkpoints.py::read_m365_task_checkpoint": { + "boundary": { + "sha256": "3ecca6cc5278e1089576108f05fff9b2aa804f628e8ccfa2cfcf72ee051ac3c1", + "points": [ + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f45108154d13ed770437c100c697604b36f43f7085a02641d3f9253d17630bf8" + }, + "classification": "sdk-compatible", + "contract": "read_m365_task_checkpoint: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_m365_workflow_checkpoints.py::save_m365_task_checkpoint": { + "boundary": { + "sha256": "cf551d0f20fdbff945bd7d6b3132d0a136a309d8602740a0e83cf2cf84542ccf", + "points": [ + { + "method": "read_item", + "receiver": "jobs", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "jobs", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f45108154d13ed770437c100c697604b36f43f7085a02641d3f9253d17630bf8" + }, + "classification": "sdk-compatible", + "contract": "save_m365_task_checkpoint: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_mcp_server_enterprise.py::check_inbound_mcp_tool_rate_limit": { + "boundary": { + "sha256": "483022f6b457fcebf07a6930e11487c6a112930fc3d3165ecbb7a7414d4a1ed2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_settings_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "949892aba844ba1cc8d6dbbdcb15039f4b8ee065ed8746ac899a241b310044d1" + }, + "classification": "sdk-compatible", + "contract": "check_inbound_mcp_tool_rate_limit: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_mcp_server_tools.py::_load_legacy_personal_conversations": { + "boundary": { + "sha256": "e5cec58019e23a47d31e943d9e00679cf292f59703e32c5c33ea524de7ba8c3b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "1be21d1cdcb00f00f725f438b47a498872b52f44500d0afbd64e31535c9fd08e" + }, + "classification": "sdk-compatible", + "contract": "_load_legacy_personal_conversations: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_mcp_server_tools.py::_authorize_personal_conversation_read": { + "boundary": { + "sha256": "1c73b8fa565e26035e7c6b24a0f751a6bb5e44db78ee6df30be7a4ca316c4dfc", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "1be21d1cdcb00f00f725f438b47a498872b52f44500d0afbd64e31535c9fd08e" + }, + "classification": "sdk-compatible", + "contract": "_authorize_personal_conversation_read: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_mcp_server_tools.py::_load_legacy_messages": { + "boundary": { + "sha256": "d67081cb0a441b0e02a3c300d8144c2b12deba58d5d4de626bca00772c533557", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "1be21d1cdcb00f00f725f438b47a498872b52f44500d0afbd64e31535c9fd08e" + }, + "classification": "sdk-compatible", + "contract": "_load_legacy_messages: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_mcp_server_tools.py::_load_personal_prompt_page": { + "boundary": { + "sha256": "30188601d4e059b81d22788dac75e518528705060759ce10f3e599a57bf5ac34", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_prompts_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "1be21d1cdcb00f00f725f438b47a498872b52f44500d0afbd64e31535c9fd08e" + }, + "classification": "sdk-compatible", + "contract": "_load_personal_prompt_page: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_mcp_tool_pinning.py::persist_mcp_tool_drift": { + "boundary": { + "sha256": "5445fda53c145770c71c22611f6881b142f1db79d327117d9a045630af7f3575", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_personal_actions_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_group_actions_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_group_actions_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_global_actions_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_notifications_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0a11525ea1e7cd836555f9d347c5edd02bc33d7d298fb2846ce2e0688ded9082" + }, + "classification": "sdk-compatible", + "contract": "persist_mcp_tool_drift: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_msgraph_pending_actions.py::create_msgraph_pending_action": { + "boundary": { + "sha256": "1d9d4ffae8d44b910a48ba8c20a87ea71614070e3d9f9f07969548ab7678f992", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_msgraph_pending_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a30d57791c28e93355dade976da6df20a761c1b7a48da6d6c6b79ac75e666212" + }, + "classification": "sdk-compatible", + "contract": "create_msgraph_pending_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_msgraph_pending_actions.py::get_msgraph_pending_action": { + "boundary": { + "sha256": "928ffd83b5dc1e0703f407cd219d28b2d4c6be2b1151d342fa17ca8a75a96032", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_msgraph_pending_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a30d57791c28e93355dade976da6df20a761c1b7a48da6d6c6b79ac75e666212" + }, + "classification": "sdk-compatible", + "contract": "get_msgraph_pending_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_msgraph_pending_actions.py::list_msgraph_pending_actions": { + "boundary": { + "sha256": "15ed10422a707cacd8fe90801341251aee79cabd6d4bdb938a5d3e0347111c14", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_msgraph_pending_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "a30d57791c28e93355dade976da6df20a761c1b7a48da6d6c6b79ac75e666212" + }, + "classification": "sdk-compatible", + "contract": "list_msgraph_pending_actions: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_msgraph_pending_actions.py::get_pending_action_page": { + "boundary": { + "sha256": "da0a376596b373159a31fe339feff36bca2c917e51d1dcefaeded453c8698eb0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_msgraph_pending_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "a30d57791c28e93355dade976da6df20a761c1b7a48da6d6c6b79ac75e666212" + }, + "classification": "sdk-compatible", + "contract": "get_pending_action_page: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_msgraph_pending_actions.py::get_chat_pending_action_cards": { + "boundary": { + "sha256": "bbab2fabd0cacb6b0a20b65cab88c0f964ea3d8eb0f60d84aac548c50c5f1cb5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_msgraph_pending_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "a30d57791c28e93355dade976da6df20a761c1b7a48da6d6c6b79ac75e666212" + }, + "classification": "sdk-compatible", + "contract": "get_chat_pending_action_cards: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::_read_existing_notification": { + "boundary": { + "sha256": "91f109e5978ce611adfde3d1810c92a1d612b369c3ef866143ef1e599e275849", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "sdk-compatible", + "contract": "_read_existing_notification: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::get_notifications_by_metadata": { + "boundary": { + "sha256": "9a7f7f40b0ce2256a1d53f6b970370b3aa58a8d5edc42e3452858d6d6d9b3bac", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "sdk-compatible", + "contract": "get_notifications_by_metadata: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::delete_notifications_by_metadata": { + "boundary": { + "sha256": "ebe696cf10fdad9ae9c3881ea6dc7272f38a2cbccec6d45433f0fc04e3b7ca9b", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_notifications_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "response-unused", + "contract": "delete_notifications_by_metadata: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_notifications.py::create_notification": { + "boundary": { + "sha256": "8e738c70a6351fbb5e9adaa84d12b29f7c9a1164ad47f8e9dbe3803e5da5a93d", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_notifications_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "response-unused", + "contract": "create_notification: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_notifications.py::create_m365_approval_notification": { + "boundary": { + "sha256": "6d8edf59e166b10397125a57c21bbd95df7474f398cedde895a2070181011e0e", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_notifications_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_notifications_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "response-unused", + "contract": "create_m365_approval_notification: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_notifications.py::get_user_notifications": { + "boundary": { + "sha256": "4365755ffbdbfae671f831eb31a2ac4017b679db490241df0da22e29d5f4e418", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "sdk-compatible", + "contract": "get_user_notifications: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::get_recent_chat_response_notifications": { + "boundary": { + "sha256": "d017f4aaeacc33f61e287bc31de8fc9d8334acd76c107981d5f1dee53918dd5d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "sdk-compatible", + "contract": "get_recent_chat_response_notifications: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::get_unread_workflow_priority_notifications": { + "boundary": { + "sha256": "184a4fd4e4c2034403db1b273ceaed148f3169a9793015c5bcefcec3da455c4b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "sdk-compatible", + "contract": "get_unread_workflow_priority_notifications: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::_read_workflow_alert_page": { + "boundary": { + "sha256": "c429d07f2582a2923b1f1256d001b5e09b29f83b038fdaaff979d6d35720d7e5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "sdk-compatible", + "contract": "_read_workflow_alert_page: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::_read_notification_by_id": { + "boundary": { + "sha256": "f918298e0067c78c9684cd86cc9dab7120cff40f0424e15bdf006880a7e4e3d0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "sdk-compatible", + "contract": "_read_notification_by_id: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::_write_notification_change": { + "boundary": { + "sha256": "d7d2c599000ef6692485b174577169eca8250a18a4cc626c06377715153762bb", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_notifications_container", + "response": "returned" + }, + { + "method": "replace_item", + "receiver": "cosmos_notifications_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "sdk-compatible", + "contract": "_write_notification_change: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_notifications.py::mark_chat_response_notifications_read_for_conversation": { + "boundary": { + "sha256": "d4345ad54584954113bd610d8cbecb516021250745268e24d1abe3754cdf3008", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_notifications_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "response-unused", + "contract": "mark_chat_response_notifications_read_for_conversation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_notifications.py::mark_collaboration_message_notifications_read_for_conversation": { + "boundary": { + "sha256": "fadb4f22b28bd0df02f7cb359cb4edb906b4273c086f6e40ce4ef53dfacebb46", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_notifications_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "response-unused", + "contract": "mark_collaboration_message_notifications_read_for_conversation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_notifications.py::delete_notification": { + "boundary": { + "sha256": "0f4d57670580af7eb6750cba9bc6e2cf3a2055eae562b21d4f91e803500609be", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_notifications_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2591fec0a0ecf87004efb457cfa4468c0817d33ec4c452e95c4054636c59c846" + }, + "classification": "response-unused", + "contract": "delete_notification: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_artifacts.py::OrchestrationOutputCleanupService.cleanup": { + "boundary": { + "sha256": "24a8c72d38273b63e66bb7986d1c2b2ab8545f973722fb5051e97a420fc4a14a", + "points": [ + { + "method": "read_item", + "receiver": "self.message_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "self.message_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6343386e8270a99dc9498847276b2fee744aafa59649ce788a34d4ed62eaf938" + }, + "classification": "sdk-compatible", + "contract": "Direct cleanup point messages are checked by field binding; strict descriptors and upload envelopes are domain projections, not outer Cosmos responses.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_bootstrap.py::read_owned_conversation": { + "boundary": { + "sha256": "1059384e6b69842cd0ef431c2d9d7bb51b22af4595abe669429e0ca94c71ecd5", + "points": [ + { + "method": "read_item", + "receiver": "config.cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "daebed8d7e69b9ad237a2c47abdf523f8763a3160f551ba12964f45abcd75ad3" + }, + "classification": "normalized-strict", + "contract": "Bootstrap normalizes conversation/settings/deletion callback point wrappers before strict authorization/result contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_bootstrap.py::build_external_identity_reader.read_user_settings": { + "boundary": { + "sha256": "c3513ddf2681594794d04fa045494145d420157afb99e4ae5470d12681cb97b4", + "points": [ + { + "method": "read_item", + "receiver": "config.cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "daebed8d7e69b9ad237a2c47abdf523f8763a3160f551ba12964f45abcd75ad3" + }, + "classification": "normalized-strict", + "contract": "Bootstrap normalizes conversation/settings/deletion callback point wrappers before strict authorization/result contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_bootstrap.py::build_image_asset_reader.read": { + "boundary": { + "sha256": "47202ebe413ca6d176c35e1ef7285d3824404a5a69a125437659041232bb886c", + "points": [ + { + "method": "read_item", + "receiver": "config.cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "daebed8d7e69b9ad237a2c47abdf523f8763a3160f551ba12964f45abcd75ad3" + }, + "classification": "sdk-compatible", + "contract": "Bootstrap normalizes conversation/settings/deletion callback point wrappers before strict authorization/result contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_bootstrap.py::build_document_transform_sources.list_artifacts": { + "boundary": { + "sha256": "7350117c58451e842091874583a79713dc534f0b38780ddeecad86e1a5516f3b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "config.cosmos_messages_container", + "response": "returned" + } + ], + "batches": [], + "module_sha256": "daebed8d7e69b9ad237a2c47abdf523f8763a3160f551ba12964f45abcd75ad3" + }, + "classification": "sdk-compatible", + "contract": "Bootstrap normalizes conversation/settings/deletion callback point wrappers before strict authorization/result contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_bootstrap.py::build_orchestration_services": { + "boundary": { + "sha256": "e9681e3bd2b9a296cecca03a8d7f72ebd8a6fcbb9efd0a399209b9c3a491d6e8", + "points": [ + { + "method": "read_item", + "receiver": "config.cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "daebed8d7e69b9ad237a2c47abdf523f8763a3160f551ba12964f45abcd75ad3" + }, + "classification": "sdk-compatible", + "contract": "Bootstrap normalizes conversation/settings/deletion callback point wrappers before strict authorization/result contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_bootstrap.py::build_orchestration_cleanup_service": { + "boundary": { + "sha256": "b0cf10f3177d20beddda6406241300f279045a5cf05a93fe0f6c7f34dcaed312", + "points": [ + { + "method": "read_item", + "receiver": "config.cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "config.cosmos_orchestration_run_steps_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "daebed8d7e69b9ad237a2c47abdf523f8763a3160f551ba12964f45abcd75ad3" + }, + "classification": "normalized-strict", + "contract": "Bootstrap normalizes conversation/settings/deletion callback point wrappers before strict authorization/result contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore._read": { + "boundary": { + "sha256": "5240d1abae08904bce4c82e95d2e80647bc6cf9c51f5d680f0747cb08aedcf71", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "bddf12373d403a9f48b999de16fe3dc42f0db550603924d9cc14e17b0c07abe4" + }, + "classification": "sdk-compatible", + "contract": "Checkpoint _verify accepts dict subclasses; nested manifests/state are plain SDK JSON and publication/control values use mapping fields.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.initialize": { + "boundary": { + "sha256": "503c77d96ea92cd9866b27c5dc6dc93a8a4c8f74d5c911c136a0397feda68c7a", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "bddf12373d403a9f48b999de16fe3dc42f0db550603924d9cc14e17b0c07abe4" + }, + "classification": "response-unused", + "contract": "CheckpointStore.initialize: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.adopt_claim": { + "boundary": { + "sha256": "fc2644e1034a7a6624f9ec9702367f2a5050a906d676881f7738d4c0c45eb00f", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "bddf12373d403a9f48b999de16fe3dc42f0db550603924d9cc14e17b0c07abe4" + }, + "classification": "response-unused", + "contract": "CheckpointStore.adopt_claim: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore._write": { + "boundary": { + "sha256": "c14dda7787185d20244e86ae8d19a274dd302470c08c036ca8ee6eeec66b11e6", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "bddf12373d403a9f48b999de16fe3dc42f0db550603924d9cc14e17b0c07abe4" + }, + "classification": "response-unused", + "contract": "CheckpointStore._write: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.has_manifest": { + "boundary": { + "sha256": "6911214220b455d1fb0b152a94834bf5ca01f714f37f3c57de7eabf19c9fcd3e", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "bddf12373d403a9f48b999de16fe3dc42f0db550603924d9cc14e17b0c07abe4" + }, + "classification": "response-unused", + "contract": "CheckpointStore.has_manifest: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.fence": { + "boundary": { + "sha256": "a850b588741cdce1ef5e107b1ce5a69607a54c4ebe7fed9e3b297de094adbf76", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "self.container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "bddf12373d403a9f48b999de16fe3dc42f0db550603924d9cc14e17b0c07abe4" + }, + "classification": "sdk-compatible", + "contract": "Checkpoint _verify accepts dict subclasses; nested manifests/state are plain SDK JSON and publication/control values use mapping fields.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.delete_payloads": { + "boundary": { + "sha256": "4600e56ecdd0dd4cec8ef9a3c5132753730ba8b884032085730330a5d853a7c8", + "points": [ + { + "method": "delete_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "bddf12373d403a9f48b999de16fe3dc42f0db550603924d9cc14e17b0c07abe4" + }, + "classification": "response-unused", + "contract": "CheckpointStore.delete_payloads: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_collaboration.py::_refresh_mirrored_answer": { + "boundary": { + "sha256": "1f782fc2b6639e15dae1f04d5fde043113215127968a0c0bef0be0074a7926ca", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "e15f66045985f75aedce3af54f4f45963c6f82e147622e99143e1efe9bb22c69" + }, + "classification": "sdk-compatible", + "contract": "_refresh_mirrored_answer: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_collaboration.py::delete_orchestration_backing": { + "boundary": { + "sha256": "a8817de98bbf75b2a8995081973562fd6f9b22adf3d7c3729b898186270b6ed3", + "points": [ + { + "method": "upsert_item", + "receiver": "archived_message_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "message_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "archived_conversation_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "conversation_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "message_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "e15f66045985f75aedce3af54f4f45963c6f82e147622e99143e1efe9bb22c69" + }, + "classification": "response-unused", + "contract": "delete_orchestration_backing: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_collaboration.py::delete_orchestration_backing.read_backing": { + "boundary": { + "sha256": "f8f778555dec4c5f2269908800913371cf8e97e555ef9475a0e1719bea358477", + "points": [ + { + "method": "read_item", + "receiver": "conversation_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "e15f66045985f75aedce3af54f4f45963c6f82e147622e99143e1efe9bb22c69" + }, + "classification": "sdk-compatible", + "contract": "delete_orchestration_backing.read_backing: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_context.py::_image_reference_message_candidates": { + "boundary": { + "sha256": "66285e0cfeceb1756f580e32d76e57894386a9e31ed1558f4fd0cc2a71c7acac", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "17eded55069836e3d1317ef48bbcb232a2b4df281708d67c380aa0efffba6386" + }, + "classification": "sdk-compatible", + "contract": "_image_reference_message_candidates: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_context.py::_owned_elicitation_conversation": { + "boundary": { + "sha256": "6c47cd9daad92fe17aa4041abe7ba2f0d9eeaaeaf84c205f764a5b5ce80ea7f5", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "17eded55069836e3d1317ef48bbcb232a2b4df281708d67c380aa0efffba6386" + }, + "classification": "sdk-compatible", + "contract": "_owned_elicitation_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_context.py::_authorize_references": { + "boundary": { + "sha256": "95eac176b288373f2ddebfbcac3ec75936f7e998de84acbea8251077293fbfa7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "17eded55069836e3d1317ef48bbcb232a2b4df281708d67c380aa0efffba6386" + }, + "classification": "sdk-compatible", + "contract": "_authorize_references: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_continuation.py::_continuation_guards": { + "boundary": { + "sha256": "3baddfbdca48611b98aac80cbcb5d1e4222f4f1fc1552990b72c4266f37a3a4a", + "points": [ + { + "method": "read_item", + "receiver": "message_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c59f0ee0b7653f08c774ae1a5e59a6942a33098c4399758e0931432355c176e8" + }, + "classification": "sdk-compatible", + "contract": "Point guards use mapping fields and plain metadata-stripping projections; inherited lease reads already normalize before strict continuation state.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_continuation.py::ContinuationExecutionLease._roll_guard": { + "boundary": { + "sha256": "15a656f94d617211faaf9dda9ae1dbec9c0ce2a1b006ae451368d45a4a1dcd32", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c59f0ee0b7653f08c774ae1a5e59a6942a33098c4399758e0931432355c176e8" + }, + "classification": "sdk-compatible", + "contract": "Point guards use mapping fields and plain metadata-stripping projections; inherited lease reads already normalize before strict continuation state.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_execution.py::_conversation_context": { + "boundary": { + "sha256": "369e78d28cf686eb692ad1720a9b74612faa16ee52156dae2160de0a1259b8ae", + "points": [ + { + "method": "read_item", + "receiver": "message_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "message_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "809037c25bcd0d4c4392bc931c33fcb5d265dc252b0bea2b95ef9c9980294894" + }, + "classification": "sdk-compatible", + "contract": "Execution receives the normalized lease record; direct point message reads use fields/fingerprints, while strict settings and event checks are domain values.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_execution.py::HarnessExecution._read_delivery_metadata": { + "boundary": { + "sha256": "07583c290502c23d5927e3d6d46c037a20c7dfce5fe3a0e92b6f717ab58b9b93", + "points": [ + { + "method": "read_item", + "receiver": "self.lease.message_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "809037c25bcd0d4c4392bc931c33fcb5d265dc252b0bea2b95ef9c9980294894" + }, + "classification": "sdk-compatible", + "contract": "Execution receives the normalized lease record; direct point message reads use fields/fingerprints, while strict settings and event checks are domain values.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_execution.py::HarnessExecution._regeneration_thread": { + "boundary": { + "sha256": "ceca514e0da4bb42153c8c42d3d23cc863070e713df7518b2ac48c99b749bd61", + "points": [ + { + "method": "read_item", + "receiver": "self.lease.message_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "809037c25bcd0d4c4392bc931c33fcb5d265dc252b0bea2b95ef9c9980294894" + }, + "classification": "sdk-compatible", + "contract": "Execution receives the normalized lease record; direct point message reads use fields/fingerprints, while strict settings and event checks are domain values.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_execution.py::HarnessExecution._touch_conversation": { + "boundary": { + "sha256": "ebd2d57c650ecbf59f6533479ce7061ff203861f1ef2fdad4e385b941fff288a", + "points": [ + { + "method": "replace_item", + "receiver": "self._bootstrap.config.cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "809037c25bcd0d4c4392bc931c33fcb5d265dc252b0bea2b95ef9c9980294894" + }, + "classification": "sdk-compatible", + "contract": "Execution receives the normalized lease record; direct point message reads use fields/fingerprints, while strict settings and event checks are domain values.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_execution.py::HarnessExecution._finalize": { + "boundary": { + "sha256": "5e58999e21d9ff52aa15f3ec083c53ad13fedd2a027251d353478f6cffa9d2f6", + "points": [ + { + "method": "read_item", + "receiver": "self.lease.message_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "809037c25bcd0d4c4392bc931c33fcb5d265dc252b0bea2b95ef9c9980294894" + }, + "classification": "sdk-compatible", + "contract": "Execution receives the normalized lease record; direct point message reads use fields/fingerprints, while strict settings and event checks are domain values.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_operations.py::OperationJournal._change": { + "boundary": { + "sha256": "37e251491172caaeb3e6696bd57a010ad3205c51a78781ecf44b3984ab700f29", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "self.container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "9fa2e76dd1babf4931ecb9171737d6cdd1d631846fd67c5857bfdb20efc9f0af" + }, + "classification": "normalized-strict", + "contract": "Irreversible-effect journal normalizes stored point records before copying and canonical JSON; conditional ETags and sticky uncertain-effect failures remain mandatory.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_operation_runtime.py" + ] + }, + "application/single_app/functions_orchestration_output_store.py::enumerate_due_outputs": { + "boundary": { + "sha256": "0f6fafa26a06f152d25b0ab4e864c2781fd81717d260faa502e29bcb3a829ecf", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b4218ffe925c740a8acf31370d7210f1103a82b903481e56c5d33299edc90d1d" + }, + "classification": "sdk-compatible", + "contract": "Output point records normalize in _point before strict output validation; owner-injected conversation readers normalize before authorization.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_output_store.py::enumerate_output_cleanup_enrollments": { + "boundary": { + "sha256": "93b9fe5c5c3734839e2b3ec30778c51caa1e0c003cb607de425c9a4f6a056519", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b4218ffe925c740a8acf31370d7210f1103a82b903481e56c5d33299edc90d1d" + }, + "classification": "sdk-compatible", + "contract": "Output point records normalize in _point before strict output validation; owner-injected conversation readers normalize before authorization.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_output_store.py::OrchestrationOutputStore._point": { + "boundary": { + "sha256": "59458388fbd4013dff35a9b4e14782fc7071fb31ec7f57c9364cc4af4f5599af", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b4218ffe925c740a8acf31370d7210f1103a82b903481e56c5d33299edc90d1d" + }, + "classification": "normalized-strict", + "contract": "Output point records normalize in _point before strict output validation; owner-injected conversation readers normalize before authorization.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_output_store.py::OrchestrationOutputStore._batch": { + "boundary": { + "sha256": "0f016711517c548e3c0c8f24c877c349b1f211755b9bc44e40a07aec65af7d35", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "consumed" + } + ], + "module_sha256": "b4218ffe925c740a8acf31370d7210f1103a82b903481e56c5d33299edc90d1d" + }, + "classification": "sdk-compatible", + "contract": "Output point records normalize in _point before strict output validation; owner-injected conversation readers normalize before authorization.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_output_store.py::OrchestrationOutputStore.enroll_run_cleanup": { + "boundary": { + "sha256": "b42e471dc45df344d84494dc28ab8699c80ecd6063317fa8d055b420d2b499dd", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "b4218ffe925c740a8acf31370d7210f1103a82b903481e56c5d33299edc90d1d" + }, + "classification": "response-unused", + "contract": "OrchestrationOutputStore.enroll_run_cleanup: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_plan_revisions.py::read_revision_run": { + "boundary": { + "sha256": "1c59f77efe5e43d0223c6c484ca7b7f74cab044035e723dc94138b4fd0a4aefb", + "points": [ + { + "method": "read_item", + "receiver": "run_store.cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "46808a9e51f41bbe58a296433373dd6fe11191a577704d1b12f59b0e21e9bc3d" + }, + "classification": "normalized-strict", + "contract": "Owned revision reads and execution claims normalize the outer wrapper; ownership, lineage and ETag fencing stay in this owner.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_plan_revisions.py::_replace": { + "boundary": { + "sha256": "d48c8da9487caf2a375ea56f0355df20b8eec015084ee44088a6178585cfb247", + "points": [ + { + "method": "replace_item", + "receiver": "run_store.cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "46808a9e51f41bbe58a296433373dd6fe11191a577704d1b12f59b0e21e9bc3d" + }, + "classification": "sdk-compatible", + "contract": "Owned revision reads and execution claims normalize the outer wrapper; ownership, lineage and ETag fencing stay in this owner.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_plan_revisions.py::plan_editor_state": { + "boundary": { + "sha256": "0df7c567b3820a29a770e8adf3d4dfbc2e008e2a02db56a0613eefe831b10c28", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "run_store.cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "46808a9e51f41bbe58a296433373dd6fe11191a577704d1b12f59b0e21e9bc3d" + }, + "classification": "sdk-compatible", + "contract": "Owned revision reads and execution claims normalize the outer wrapper; ownership, lineage and ETag fencing stay in this owner.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_plan_revisions.py::complete_plan_revision": { + "boundary": { + "sha256": "ad689ebdd5c616f0f049cebbf4f9b32fff4c6dcfe944d65e9730347042b096eb", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "run_store.cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "module_sha256": "46808a9e51f41bbe58a296433373dd6fe11191a577704d1b12f59b0e21e9bc3d" + }, + "classification": "sdk-compatible", + "contract": "Owned revision reads and execution claims normalize the outer wrapper; ownership, lineage and ETag fencing stay in this owner.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_recovery.py::_replace": { + "boundary": { + "sha256": "8abbba70c518957dcafe2d97733640677b43ac08ba15f8ecb542eddad207f8fe", + "points": [ + { + "method": "replace_item", + "receiver": "run_store.cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "85fbda793f397c3ddc760221e6926e6ccb034e0f41f34c739414a868c5805fc6" + }, + "classification": "normalized-strict", + "contract": "Lease responses normalize before execution; publication guards use mapping fields and metadata-stripped fingerprints, not exact SDK document types.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_recovery.py::fence_publication": { + "boundary": { + "sha256": "380e7f08eb28d66200aafb75d020385a24066c8a086e41540034ad3be8f3a05a", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "85fbda793f397c3ddc760221e6926e6ccb034e0f41f34c739414a868c5805fc6" + }, + "classification": "sdk-compatible", + "contract": "Lease responses normalize before execution; publication guards use mapping fields and metadata-stripped fingerprints, not exact SDK document types.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_recovery.py::ExecutionLease.publish_message": { + "boundary": { + "sha256": "157ea1dadb8e9af5a42b27b9f317b6f6b72276cd5edfecd7f77de6e5650e7234", + "points": [ + { + "method": "read_item", + "receiver": "self.message_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "self.message_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "self.message_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.message_container", + "response": "unused" + } + ], + "module_sha256": "85fbda793f397c3ddc760221e6926e6ccb034e0f41f34c739414a868c5805fc6" + }, + "classification": "sdk-compatible", + "contract": "Lease responses normalize before execution; publication guards use mapping fields and metadata-stripped fingerprints, not exact SDK document types.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_recovery.py::ExecutionLease._published_message_matches": { + "boundary": { + "sha256": "8663b4f845f6ab2e7cfb286a388f08a318514e05975717c955785b9025d4653f", + "points": [ + { + "method": "read_item", + "receiver": "self.message_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "self.message_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "85fbda793f397c3ddc760221e6926e6ccb034e0f41f34c739414a868c5805fc6" + }, + "classification": "sdk-compatible", + "contract": "Lease responses normalize before execution; publication guards use mapping fields and metadata-stripped fingerprints, not exact SDK document types.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_recovery.py::ExecutionLease.ensure_publication_guard": { + "boundary": { + "sha256": "a28f3f8f2f654bd38de1c44f66e6bfdc7e86447d6406b3149cde27171b3494ca", + "points": [ + { + "method": "create_item", + "receiver": "self.message_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "self.message_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "self.message_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "85fbda793f397c3ddc760221e6926e6ccb034e0f41f34c739414a868c5805fc6" + }, + "classification": "sdk-compatible", + "contract": "Lease responses normalize before execution; publication guards use mapping fields and metadata-stripped fingerprints, not exact SDK document types.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_recovery.py::claim_waiting_continuation": { + "boundary": { + "sha256": "715768032cef5aebcaa27948a57244fd7604957d8a9daf0c81d8ea16991bd2ef", + "points": [ + { + "method": "read_item", + "receiver": "message_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "85fbda793f397c3ddc760221e6926e6ccb034e0f41f34c739414a868c5805fc6" + }, + "classification": "sdk-compatible", + "contract": "Lease responses normalize before execution; publication guards use mapping fields and metadata-stripped fingerprints, not exact SDK document types.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_recovery.py::prepare_retry": { + "boundary": { + "sha256": "2a6a54ff32934cc0607bdfa86a988f491c697df1ada7153161725326b5b68f04", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "run_store.cosmos_orchestration_runs_container", + "response": "unused" + } + ], + "module_sha256": "85fbda793f397c3ddc760221e6926e6ccb034e0f41f34c739414a868c5805fc6" + }, + "classification": "response-unused", + "contract": "prepare_retry: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_recovery.py::cleanup_conversation_checkpoints": { + "boundary": { + "sha256": "26ebc929e28b8c78a14728240c791a4a5a30d896fad3d1570051c84e69edc6b6", + "points": [ + { + "method": "read_item", + "receiver": "conversation_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "conversation_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "run_store.cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "85fbda793f397c3ddc760221e6926e6ccb034e0f41f34c739414a868c5805fc6" + }, + "classification": "sdk-compatible", + "contract": "Lease responses normalize before execution; publication guards use mapping fields and metadata-stripped fingerprints, not exact SDK document types.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "application/single_app/functions_orchestration_runs.py::get_pending_turn_context": { + "boundary": { + "sha256": "2261aa80f66b799f26236d08bba3e6f78bb7c1833eaca9dc03100017b3e8eb59", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "get_pending_turn_context: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::save_pending_turn_context": { + "boundary": { + "sha256": "e83fb3547eed7add20f742c362102f2a3d014c428d4157c22a0601802d08c871", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "response-unused", + "contract": "save_pending_turn_context: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_runs.py::clear_pending_turn_context": { + "boundary": { + "sha256": "6a5d90b1a76bfabe7ee52da73f89700f13f9bc4ac2d6924c3961f6f4ed9824e9", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "response-unused", + "contract": "clear_pending_turn_context: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_runs.py::create_orchestration_run": { + "boundary": { + "sha256": "410bed68d219f97c50a0bef1f218c1af8cb94f03f6ce2a67bcf37d6ca71d107d", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "response-unused", + "contract": "create_orchestration_run: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_orchestration_runs.py::_replanned_outcome": { + "boundary": { + "sha256": "ddb55064b1d96ea9daea5bfbdeebc53054809cf07c84f974768f4b0b6243a591", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "_replanned_outcome: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::_publish_replanned_run": { + "boundary": { + "sha256": "9e47be34d5022955208842bf0e106a6777deb6f62ec20efeb216cb373a65c06e", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "cosmos_orchestration_runs_container", + "response": "unused" + } + ], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "_publish_replanned_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::get_orchestration_run": { + "boundary": { + "sha256": "566a28d0677d6e22aa48723039c795b9d1aab1fd2e601459d512033a918e4a8f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "get_orchestration_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::get_latest_turn_run": { + "boundary": { + "sha256": "b6629b6374ab8a901a412456558e0b274b64e176128a6c9dbdcdcf818e680d22", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "get_latest_turn_run: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::update_orchestration_run": { + "boundary": { + "sha256": "9e6146a64875676f993aeadf6d179736d27fd19d1af367f23db700d735b6425b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "update_orchestration_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::_update_run_decision": { + "boundary": { + "sha256": "49bcd43ea80aa0ae067257690d5d2421467d6bdce15069573368b412fe2dbad9", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "_update_run_decision: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::list_conversation_runs": { + "boundary": { + "sha256": "d433b88b1c76d947af0b7c5f28a2ec32c458723f3f4027a0238b578c65bf2d18", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "list_conversation_runs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::next_turn_index": { + "boundary": { + "sha256": "27f66d4f9f6773a5402c4d6202b60ee9aabf6227be0516389a314896c2ca0af6", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "next_turn_index: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::get_pending_elicitation": { + "boundary": { + "sha256": "d0d0266ee7766d8af42a88159b5af471df9c3d3c53e29633291fcbb3cbeccdf3", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "get_pending_elicitation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::create_pending_elicitation": { + "boundary": { + "sha256": "05e307f66bb95f147a155f973406c663201e5a09bbec48b9813747f653e1023c", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "create_pending_elicitation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::_replace_pending": { + "boundary": { + "sha256": "ba4c39af74125736bb555a105d72f4cd07961470f09b823ac23387998bf3804f", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "_replace_pending: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::save_orchestration_step": { + "boundary": { + "sha256": "18f35b2cfd173d75c13efd05a9f815f6f67e26f16fc17be6bbe7dbfbd165bc63", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_orchestration_run_steps_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "save_orchestration_step: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::get_orchestration_step_record": { + "boundary": { + "sha256": "6b4cd0bae280ae372685c29b6ff0a86311293e2b697c1d6ad944c529b19dad76", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_run_steps_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "get_orchestration_step_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_runs.py::list_run_steps": { + "boundary": { + "sha256": "38db69fbdbe5226c6fbebe158945c3a1a2b4604b325777e71b2ad199b380bfcc", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_orchestration_run_steps_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4cfb13e9f5a7dd3ad33370e77465d8871379e4c10a791ac449143e1ffdcd83f1" + }, + "classification": "sdk-compatible", + "contract": "list_run_steps: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_scheduler.py::enumerate_due_runs": { + "boundary": { + "sha256": "107e36595fce609e46ba5a62527680cc5611240fe8fd923ae5576bf59778cef6", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d6df5be9e8e468d58f6c7532d553daa2f34414f3526ac0083ec23277d073864f" + }, + "classification": "sdk-compatible", + "contract": "enumerate_due_runs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_context.py::_read_personal_agents": { + "boundary": { + "sha256": "0906e7c2325148feb77c91723ecf29f5f88d734b1d99de2ea202c043cb822866", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_agents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "91913e2ec2c0d81027420730f9933bd32da062fcdcb7fdc1d1af301095a15e36" + }, + "classification": "sdk-compatible", + "contract": "_read_personal_agents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_context.py::_read_global_agents": { + "boundary": { + "sha256": "45b55354ec653ccd5afa52e398746d8c8f04c1fef8899a88eeec56cac1785b6c", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "91913e2ec2c0d81027420730f9933bd32da062fcdcb7fdc1d1af301095a15e36" + }, + "classification": "sdk-compatible", + "contract": "_read_global_agents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_context.py::_read_workflows": { + "boundary": { + "sha256": "b352f70af4c3ae5845d5fc6fd8ebfa464b915520b149a6ac0652ce61fdbe31a7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "91913e2ec2c0d81027420730f9933bd32da062fcdcb7fdc1d1af301095a15e36" + }, + "classification": "sdk-compatible", + "contract": "_read_workflows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_context.py::_read_wait_workflows": { + "boundary": { + "sha256": "e2340bd8034c2590807413acb493988fe8692e07f2e3fdf40b3eac3cea72120c", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "91913e2ec2c0d81027420730f9933bd32da062fcdcb7fdc1d1af301095a15e36" + }, + "classification": "sdk-compatible", + "contract": "_read_wait_workflows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_handoff_decisions.py::_read_workflow": { + "boundary": { + "sha256": "7046771aae4163c50a6a75812ed9c5b6cf93d7a994c803a5026e4b5f68faebd1", + "points": [ + { + "method": "read_item", + "receiver": "functions_personal_workflows.cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "9c33fd634a1bb72f2c5af417932b94a11e4162cdd9bdefad57b857bea91d30f1" + }, + "classification": "sdk-compatible", + "contract": "_read_workflow: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_handoff_decisions.py::_read_workflow_run": { + "boundary": { + "sha256": "2958aa37adb6b4a35103f111c710730a2642354a40689423a7df6a37119133cb", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "9c33fd634a1bb72f2c5af417932b94a11e4162cdd9bdefad57b857bea91d30f1" + }, + "classification": "sdk-compatible", + "contract": "_read_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_proposals.py::_read_workflow": { + "boundary": { + "sha256": "9fd6a30bf07ccf1d641c0c1906e91590873116ae4bcc28d7afb089a79da198e8", + "points": [ + { + "method": "read_item", + "receiver": "functions_personal_workflows.cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dd1ea4cedf89874f6826fe112f7163eb5ec98ef9a56e0811699200b8ab3fe282" + }, + "classification": "sdk-compatible", + "contract": "_read_workflow: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_results.py::_point_read": { + "boundary": { + "sha256": "6fa766ae95769ada7b35c40e690442afab1fd62bf50122d398e32315f480bb73", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a2b558c3b5f49091cc64dcc3baa0347c900c362b5e307c5ef20ba25b56580162" + }, + "classification": "sdk-compatible", + "contract": "_point_read: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_results.py::_query_runs": { + "boundary": { + "sha256": "7c46cc5f8775b087ed97063980d342a012e38f8ee4917a5f9f0539ad5bb2dd26", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "a2b558c3b5f49091cc64dcc3baa0347c900c362b5e307c5ef20ba25b56580162" + }, + "classification": "sdk-compatible", + "contract": "_query_runs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_run_links.py::_point_read": { + "boundary": { + "sha256": "a98f78276f1e644076a80c55d0fcf2409f629c8191a8a4046ddc3768c3d6ef85", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dccc59a97c88abeae9582ca8534dfdc88e02065e3428b5ab1420c9e7b36c0f78" + }, + "classification": "sdk-compatible", + "contract": "_point_read: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_runs.py::_point_read": { + "boundary": { + "sha256": "db3c40849fc4470d14db15dd7f4bf5c8275df0612db5ec1ef1df4309a820f8f6", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "506835922ecb5b830d71dc6b845a415fe6feec133932ea989d6a6878033a3eb4" + }, + "classification": "sdk-compatible", + "contract": "_point_read: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_orchestration_workflow_runs.py::_write_plan_wait": { + "boundary": { + "sha256": "2e849c7d0aec76c8ba714e0279c8d17205b25abb46bdb58172ae923e97f62f4f", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "506835922ecb5b830d71dc6b845a415fe6feec133932ea989d6a6878033a3eb4" + }, + "classification": "sdk-compatible", + "contract": "_write_plan_wait: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::_read_personal_action_record": { + "boundary": { + "sha256": "33433fddfbbff8cdb1ed4732e03d87a91800a0a88801e19df0060f9571da5b0b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_actions_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "_read_personal_action_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::_find_personal_action_record": { + "boundary": { + "sha256": "99cd4c13818d7dea5ac11b425f8bd83f5f5218636ec1147fa563b8a9789e1626", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "_find_personal_action_record: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::get_personal_actions": { + "boundary": { + "sha256": "2e73277210b65a3da0c8cd5ec553817110c5c28770711916c2637a217f91f8e2", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "get_personal_actions: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::_save_personal_action": { + "boundary": { + "sha256": "e50b7a7507eb4657ba87ee41e68c8a6734df5d713dc360fa81086a250942734f", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "_save_personal_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::delete_personal_action": { + "boundary": { + "sha256": "90848722b373be749fef5850885aff8b92a48b710acb901ae84052e688389eaa", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_personal_actions_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "response-unused", + "contract": "delete_personal_action: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_personal_actions.py::_migrate_historical_msgraph_action": { + "boundary": { + "sha256": "ec28c39932d1d73699e1632f07299537dfa8d0895aa0b94d8050898a8db9aa5e", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_actions_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_personal_actions_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + } + ], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "cosmos_personal_actions_container", + "response": "unused" + } + ], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "_migrate_historical_msgraph_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::_read_legacy_settings_document": { + "boundary": { + "sha256": "966450ea66c071dc40a40962cf5b4111958cdcb16ca375832a2561614b755e34", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "_read_legacy_settings_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::_read_legacy_settings_for_preflight": { + "boundary": { + "sha256": "a4f794ede4d12fea4c27cebd0b8570cece6125cab5461d5c6061346b341abf14", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "_read_legacy_settings_for_preflight: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::_remove_legacy_snapshot": { + "boundary": { + "sha256": "5b8605b91fdf2c2670dcb26fb5b2ed5c382524b061cf63305627d65e3b770055", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "_remove_legacy_snapshot: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::_ensure_personal_secret_name_available": { + "boundary": { + "sha256": "3df83bab95634d15119e2ea5dfbf35a1989dc025158117bc018f423835912ba5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "_ensure_personal_secret_name_available: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::get_actions_by_names": { + "boundary": { + "sha256": "006ccb8772101c4705d843106e65867d90bf3264b7898c92ee48512f5d7fa38f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "get_actions_by_names: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_actions.py::get_actions_by_type": { + "boundary": { + "sha256": "0745aacc64d9a74633de8194b14f83771b6bf0c9a561edb035eec65bae9bc46c", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620" + }, + "classification": "sdk-compatible", + "contract": "get_actions_by_type: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_agents.py::get_personal_agents": { + "boundary": { + "sha256": "87d9137a5a0113b91068f517e5adf55fc8d2465bbc6708bd241ecacee3badf62", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_agents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "268f813605323b0b8c5a8a3d20c55c5ad565446ffb598f9780b5bed39130ccef" + }, + "classification": "sdk-compatible", + "contract": "get_personal_agents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_agents.py::get_personal_agent": { + "boundary": { + "sha256": "a16c10ff47895f40cbaf4273c95077c7dc6690a860d678472e5e988fd79be025", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_agents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "268f813605323b0b8c5a8a3d20c55c5ad565446ffb598f9780b5bed39130ccef" + }, + "classification": "sdk-compatible", + "contract": "get_personal_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_agents.py::save_personal_agent": { + "boundary": { + "sha256": "16a81cf2e270c861a742292e849958a06994e393b91e328cd121aa49192acda9", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_agents_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_personal_agents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "268f813605323b0b8c5a8a3d20c55c5ad565446ffb598f9780b5bed39130ccef" + }, + "classification": "sdk-compatible", + "contract": "save_personal_agent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_agents.py::delete_personal_agent": { + "boundary": { + "sha256": "cbb121927feadb63ba7f080a826508abc07a35a7ecc723ceb4eb7e2074f3bca7", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_personal_agents_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "268f813605323b0b8c5a8a3d20c55c5ad565446ffb598f9780b5bed39130ccef" + }, + "classification": "response-unused", + "contract": "delete_personal_agent: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_personal_workflows.py::_normalize_personal_workflow_conversation_id": { + "boundary": { + "sha256": "5e40d033f27436cf47e80fb448236c229886e5934fbfb68068b9f10ccc89e6bc", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "_normalize_personal_workflow_conversation_id: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::get_personal_workflows": { + "boundary": { + "sha256": "905773d0f45b8da0ea7267122256674ef6f28e6fb5c8e5dda1b8d213d8f61fe8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "get_personal_workflows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::get_personal_workflow": { + "boundary": { + "sha256": "e4d69b9a01898a394367b60bbd789c8b35459c66315135b3b03160685e4baa1b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "get_personal_workflow: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::get_due_personal_workflows": { + "boundary": { + "sha256": "6f75b0a51958e7b20774e4f13635d9e082cefcb4e0f9aaf646c3ada307947908", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "get_due_personal_workflows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::count_personal_orchestration_workflows": { + "boundary": { + "sha256": "6936e5a68535e2feb61598b7ee5f8972ce7fe4201ee5449261fe5eca22bc16f3", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "count_personal_orchestration_workflows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::count_personal_handoff_workflows_since": { + "boundary": { + "sha256": "eaafb6ad237a0068595e305c0ea94c12cf8868581cff5edce2980c1eea0e8f9a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflows_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "count_personal_handoff_workflows_since: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::list_personal_workflow_runs": { + "boundary": { + "sha256": "6d2d86fa5267db9e57e7c731107031050c8e56d398fad237a5763c670f2a8d7a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "list_personal_workflow_runs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::get_personal_workflow_run": { + "boundary": { + "sha256": "7949285738d3746f20d3612f307f5743972d1d7cb80aed5765fb29ed29d9aaa2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "get_personal_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::get_latest_personal_workflow_run_for_conversation": { + "boundary": { + "sha256": "15bfd6ef0164f2b0cecc09f174ea59e7603c28bbfa2449b5f46419e512da1ed0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "get_latest_personal_workflow_run_for_conversation: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::save_personal_workflow_run": { + "boundary": { + "sha256": "fe26c875be74be57211c0d7af42e7533a39273af3aac438fa97a994b3a2bfb98", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "save_personal_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::_save_chat_started_workflow_run": { + "boundary": { + "sha256": "511c71bc730dc14b9ba099ffde4d9ac8b7f8a418cd6a90d7a29bb48fd81cbf13", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "returned" + }, + { + "method": "upsert_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "returned" + }, + { + "method": "replace_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "returned" + }, + { + "method": "upsert_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "returned" + }, + { + "method": "upsert_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "_save_chat_started_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::save_personal_workflow_run_item": { + "boundary": { + "sha256": "82054fc1eaa6329001278d6b54792a208f848ec5e21b51abfadc7a3b99085175", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_personal_workflow_run_items_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "save_personal_workflow_run_item: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::get_personal_workflow_run_item": { + "boundary": { + "sha256": "df27269210c84bd6330118096dad40ab0a83e668b92c8335f91959478a37e4fd", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_workflow_run_items_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "get_personal_workflow_run_item: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::list_personal_workflow_run_items": { + "boundary": { + "sha256": "0d8f662f26ab5c5170c1ce9fb7385dfd0652391181098849024c892767fbe26b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflow_run_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "sdk-compatible", + "contract": "list_personal_workflow_run_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_personal_workflows.py::delete_personal_workflow": { + "boundary": { + "sha256": "bcb28cca6eb2ab10b8ed03c4353f0bb92aa9a6725fd6b8915e00ea221ea64ef8", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_personal_workflow_run_items_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_personal_workflows_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_personal_workflow_runs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_personal_workflow_run_items_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1dc2d9ae4700769a72bd406922d82a051200ea4f73f1e2fe578bcc1284636df" + }, + "classification": "response-unused", + "contract": "delete_personal_workflow: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_prompt_variables.py::_authorize_conversation": { + "boundary": { + "sha256": "f73d52df0fcf271a72ed466c359a908179d42f1f7b235037f11f97ffd24b6ec7", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "55d8262d5dc2cd6df651b7d02e890333eecc2224071254de5a5c3ab0331570f4" + }, + "classification": "sdk-compatible", + "contract": "_authorize_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_prompts.py::_query_prompt_items": { + "boundary": { + "sha256": "50059c1a04f465ebd370975bc34207e64b2856f8a2b3ffe387c05b795637c276", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9" + }, + "classification": "sdk-compatible", + "contract": "_query_prompt_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_prompts.py::_read_prompt_from_container": { + "boundary": { + "sha256": "16caa9c766d1dea027b30a0f2c5a8ea0c92ec1b6478c02ff673f45d74f66ae18", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9" + }, + "classification": "sdk-compatible", + "contract": "_read_prompt_from_container: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_prompts.py::create_prompt_doc": { + "boundary": { + "sha256": "b464693e2669b8267778bd4d7883514c587a60151eda3b6528f501f39a72b23c", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9" + }, + "classification": "sdk-compatible", + "contract": "create_prompt_doc: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_prompts.py::update_prompt_doc": { + "boundary": { + "sha256": "7ae83bcad6788d077d497aa5eb71f70011a174faba0428fa5b0571db5d705e84", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9" + }, + "classification": "sdk-compatible", + "contract": "update_prompt_doc: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_prompts.py::delete_prompt_doc": { + "boundary": { + "sha256": "cfbbb31f8f281c65f967af29c78bbe6ed7a36b5348c44ae202ebda73a636a67c", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9" + }, + "classification": "response-unused", + "contract": "delete_prompt_doc: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_public_directory.py::list_public_directory": { + "boundary": { + "sha256": "a29a206b814ae898df118ae2f34f500380698d7aa6fc833770213c039f8a8a51", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d2eaaf72dd5b8f87b9f316929ed429a1b01ce2520482142972bed140550c88c7" + }, + "classification": "sdk-compatible", + "contract": "list_public_directory: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_document_access.py::public_document_family_records": { + "boundary": { + "sha256": "a57b3bb90045a3720be29222d474968b47bbd61ff597c0b4cd68c560b0f520c3", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "fa73a3ff6e35be847c43d5e414c9a4a5a6b876f203954122af3ae0c6a33ce07b" + }, + "classification": "sdk-compatible", + "contract": "public_document_family_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_document_access.py::read_public_document_record": { + "boundary": { + "sha256": "d7c75804089aedace1f88f63393612453420b0d4707d5c09b34ec34055cc4c86", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "fa73a3ff6e35be847c43d5e414c9a4a5a6b876f203954122af3ae0c6a33ce07b" + }, + "classification": "sdk-compatible", + "contract": "read_public_document_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_document_access.py::public_document_cleanup_allowed": { + "boundary": { + "sha256": "d54c84a3e7b03bd312355685e436db98c6fc7746437f32ec578e46da8e90813b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_content_screening_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "fa73a3ff6e35be847c43d5e414c9a4a5a6b876f203954122af3ae0c6a33ce07b" + }, + "classification": "sdk-compatible", + "contract": "public_document_cleanup_allowed: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_document_collaboration.py::_replace": { + "boundary": { + "sha256": "672682a5122e71c121ed9cc808119d7d7752783b1b66f81055b0dac310515e7e", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6afc61319c9c7443e166787d14212d7a8d6d591622c0eccd74bec3f4fdba3676" + }, + "classification": "sdk-compatible", + "contract": "_replace: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_document_management.py::_patch_tag_definitions": { + "boundary": { + "sha256": "119f15ade791e0f6d8994a24e50f287d40e8028953905c0a8a48a8351077a113", + "points": [ + { + "method": "patch_item", + "receiver": "cosmos_public_workspaces_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8b0e9942726918283c85af09bcea20d43f4244f35030639721834b0211f31782" + }, + "classification": "sdk-compatible", + "contract": "_patch_tag_definitions: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_document_management.py::_current_owned_documents": { + "boundary": { + "sha256": "1d08e7d455643773474eda546bfe06a5ee78d059c5850c4f8ebe45a9db74a3bb", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8b0e9942726918283c85af09bcea20d43f4244f35030639721834b0211f31782" + }, + "classification": "sdk-compatible", + "contract": "_current_owned_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_document_publication.py::decide_public_document_publication": { + "boundary": { + "sha256": "696887923d17f3ba3fb12f7feb1f6223108468f73b1790daa01f6cf18f285a9d", + "points": [ + { + "method": "read_item", + "receiver": "publication.cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "dd1c1aeb9dbe27b30aed1a983b7f5713c6a989008dda1cf3b2d4d61086bac117" + }, + "classification": "sdk-compatible", + "contract": "decide_public_document_publication: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_document_reads.py::_query_public_document_records": { + "boundary": { + "sha256": "dc48c3be6f68c8d8bf0af6285e2434d90d8104566b63ed3ea9b15e650be3875f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "58cf665d4895ca875ea5fd4e6596a6a401d14a79a1501271da98b0b8a318d78d" + }, + "classification": "sdk-compatible", + "contract": "_query_public_document_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_insights.py::read_public_activity": { + "boundary": { + "sha256": "eeaa9a30b6ecd8d071579a2116b2cac62c3aa28d7fb75aa50da97da2e77db37a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0acb8da162c6bb235ed058b3119f9b34d6e62b83cde230de1005d8ca9666caf6" + }, + "classification": "sdk-compatible", + "contract": "read_public_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_insights.py::read_public_stats_rows": { + "boundary": { + "sha256": "88d3d7d8de304bb9368581b68fb3f36d0e9851a5b347dc8275c6ec8d4b9ce8ba", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0acb8da162c6bb235ed058b3119f9b34d6e62b83cde230de1005d8ca9666caf6" + }, + "classification": "sdk-compatible", + "contract": "read_public_stats_rows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_membership_audit.py::log_public_member_added": { + "boundary": { + "sha256": "7d04cc19ef192e99455b1b5c5cc6a9a440384873a773fdefd3cdb2d2c1ed0e36", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661" + }, + "classification": "response-unused", + "contract": "log_public_member_added: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_public_membership_audit.py::log_public_member_role_change": { + "boundary": { + "sha256": "ff22a336fe4ca041c508e48b8e91ccb39aa00a1961be4d2a6d31d1c80c54892e", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661" + }, + "classification": "response-unused", + "contract": "log_public_member_role_change: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_public_membership_audit.py::log_public_member_removed": { + "boundary": { + "sha256": "f56bc80fc78ee5347c9c35b92f05df8bee1d79a2b20390be0b76d48191776004", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661" + }, + "classification": "response-unused", + "contract": "log_public_member_removed: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_public_membership_audit.py::log_public_membership_requested": { + "boundary": { + "sha256": "095446611779beaadb5e651ef9ebf64f8e710d33ee7b5bc49237d61648871e84", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661" + }, + "classification": "response-unused", + "contract": "log_public_membership_requested: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_public_membership_audit.py::log_public_membership_request_canceled": { + "boundary": { + "sha256": "650ad92185797a83ae1ba52dab481f395839f0f640acb7432ee16c9114afa32c", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661" + }, + "classification": "response-unused", + "contract": "log_public_membership_request_canceled: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_public_workspaces.py::update_public_workspace_document_with_etag_guard": { + "boundary": { + "sha256": "21417c1f98a2e416e48b97380319f576bd576cfdba219d80b8d7558084ead1e4", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "update_public_workspace_document_with_etag_guard: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_workspaces.py::create_public_workspace": { + "boundary": { + "sha256": "f2d8d0966ec6c33f557900a79f38ae08fa4763e65bacecabd327b600dd12206e", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_public_workspaces_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "response-unused", + "contract": "create_public_workspace: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_public_workspaces.py::find_public_workspace_by_id": { + "boundary": { + "sha256": "51391e2c9dcf31628d67639d75b067189cfba5122566e78fd57bbc6c58f1cdd4", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "find_public_workspace_by_id: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_workspaces.py::get_user_public_workspaces": { + "boundary": { + "sha256": "96c0182f3d2fb2240330cef8e9bd08d74d247a85480eed811cf121b5bd0e3814", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "get_user_public_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_workspaces.py::get_all_public_workspaces": { + "boundary": { + "sha256": "36fd96d6cc2d924619639600479ff82e5c1deaa44f47e7beefea27a254c7d411", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "get_all_public_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_workspaces.py::search_public_workspaces": { + "boundary": { + "sha256": "4fe527f7c3f0f7d4aef8b38f78675f6ff5669301a79b87399e5f7feb1d117381", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "search_public_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_workspaces.py::search_all_public_workspaces": { + "boundary": { + "sha256": "3e413a713ed954bd0a3a0ad9af7fce5be104ab37e5ee7ecd2ce67829f67eeab0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "search_all_public_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_workspaces.py::find_public_workspaces_by_ids": { + "boundary": { + "sha256": "847a67116c24f82b5a20ef8929580a2fbbe4bd802a4d1e4af896bbab54399b29", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "find_public_workspaces_by_ids: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_workspaces.py::list_public_workspaces_for_admin_directory": { + "boundary": { + "sha256": "8f24fb4f8c9ed4a07a03e3c23f1c5635de54ed6a303283a492cf2ddc8a858e25", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "list_public_workspaces_for_admin_directory: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_public_workspaces.py::delete_public_workspace": { + "boundary": { + "sha256": "d6762367be43696282fe5c08a702eaa819909893eed092a315afbc457cb174f0", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_public_workspaces_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "response-unused", + "contract": "delete_public_workspace: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_public_workspaces.py::count_public_workspace_documents": { + "boundary": { + "sha256": "6d54684e6ce3f85bc6f530b4344b5303511a5456e4c7a0e232ca98e46147b2d7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0732d97fc2379d142af6b214e4df18c1e743eec5bef5cd46e8fad34cb5cadd07" + }, + "classification": "sdk-compatible", + "contract": "count_public_workspace_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_retention_policy.py::get_all_user_settings": { + "boundary": { + "sha256": "bc530227c13ce510b35848e9f89fa4739fcf9a74495357263fbf9ec05a084fdc", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b" + }, + "classification": "sdk-compatible", + "contract": "get_all_user_settings: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_retention_policy.py::get_all_groups": { + "boundary": { + "sha256": "7984194905e1f9c7f366d96dfdcab319d3f93c86540a681b76e32994ae87ec2b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b" + }, + "classification": "sdk-compatible", + "contract": "get_all_groups: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_retention_policy.py::get_all_public_workspaces": { + "boundary": { + "sha256": "5fbf9bdfb1b05af3266c9f4133b5182f18496f004e126fad8e57e2f00fb1bf27", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b" + }, + "classification": "sdk-compatible", + "contract": "get_all_public_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_retention_policy.py::_get_existing_public_workspace_ids": { + "boundary": { + "sha256": "a010abf781e7ca52560e3e6d87f5492ef48cf891cda2dc1665fac20a0c6d1687", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b" + }, + "classification": "sdk-compatible", + "contract": "_get_existing_public_workspace_ids: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_retention_policy.py::_delete_standard_conversation_for_retention": { + "boundary": { + "sha256": "6ec4882d48aa8b3748c928459c2e7eeb07a134b539287310e75b2a1ebf30fd21", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_archived_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_archived_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b" + }, + "classification": "sdk-compatible", + "contract": "_delete_standard_conversation_for_retention: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_retention_policy.py::delete_aged_conversations": { + "boundary": { + "sha256": "b827d1a88c7e6de360b85d8e1485347f5c16032bceec34b61220d78a1186c8be", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "source['container']", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b" + }, + "classification": "sdk-compatible", + "contract": "delete_aged_conversations: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_retention_policy.py::delete_aged_documents": { + "boundary": { + "sha256": "2fa9b05c204b4c4d702e47933257a10c25611ae382d598ba548dee84a82b41e8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b" + }, + "classification": "sdk-compatible", + "contract": "delete_aged_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_review_assist_runtime.py::_read_record": { + "boundary": { + "sha256": "4041d61e4cbd67b0b1e3c33d3e2f650fb21e797aa5726cf559af630e2a44a4aa", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "1ad30bd2fd0176512faec80cb0ac6bec898c6c53f6431c8d7f7a168b650ed5ff" + }, + "classification": "sdk-compatible", + "contract": "_read_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_review_assist_runtime.py::count_prior_violations": { + "boundary": { + "sha256": "a363db28ec0e32ced89ac88a15fe06a37be54662672091d247cb94235521f43d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "1ad30bd2fd0176512faec80cb0ac6bec898c6c53f6431c8d7f7a168b650ed5ff" + }, + "classification": "sdk-compatible", + "contract": "count_prior_violations: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_review_center.py::replace_review_record": { + "boundary": { + "sha256": "c3055cfdd1fb60dedf4f259f7ec6605cc4da83aaff88ea60fce06650802a7d23", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5f0806ecc99697c866ce1112a97c8defc684b68c9bcb4c6661c3ba56d0058f35" + }, + "classification": "sdk-compatible", + "contract": "replace_review_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_review_center.py::resolve_review_users": { + "boundary": { + "sha256": "aa9509db53619973f70937d6bb5b6e3e8cd9529e5d79306f6a08892ca74a0999", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "5f0806ecc99697c866ce1112a97c8defc684b68c9bcb4c6661c3ba56d0058f35" + }, + "classification": "sdk-compatible", + "contract": "resolve_review_users: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_review_center.py::_read_review_record": { + "boundary": { + "sha256": "08cdb9ab8e06fa307b2299ee7dc957d754c99b9ec73b5fa7f65181a359ea0d74", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "5f0806ecc99697c866ce1112a97c8defc684b68c9bcb4c6661c3ba56d0058f35" + }, + "classification": "sdk-compatible", + "contract": "_read_review_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_safety_remediation.py::get_safety_log_item": { + "boundary": { + "sha256": "4bb6ceb875d0da3ea0f215132a08764868740a24030401231d718c8eaa107c83", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9" + }, + "classification": "sdk-compatible", + "contract": "get_safety_log_item: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_safety_remediation.py::write_safety_log_updates": { + "boundary": { + "sha256": "138b3e448a8ccbb2c407e1b6644d403ba21d2496ff1fa0938b6dd222311a6737", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9" + }, + "classification": "sdk-compatible", + "contract": "write_safety_log_updates: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_safety_remediation.py::_lookup_remediation_requests": { + "boundary": { + "sha256": "59ab629791a167e5533e7d992e6b51606c33c40f7621f962a0673ccfa76cefde", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_approvals_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9" + }, + "classification": "sdk-compatible", + "contract": "_lookup_remediation_requests: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_safety_remediation.py::_replace_safety_log_if_unchanged": { + "boundary": { + "sha256": "395eea46a51192e55e326c7f50ca31a83a89fb0335f212688a754ae8bb53ae0a", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9" + }, + "classification": "sdk-compatible", + "contract": "_replace_safety_log_if_unchanged: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_safety_remediation.py::record_safety_warning_send": { + "boundary": { + "sha256": "34f43fecd386f220a3147a02d46a7cae5e1606094191e52d42e7ab9060652d9b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9" + }, + "classification": "sdk-compatible", + "contract": "record_safety_warning_send: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_safety_remediation.py::count_pending_safety_warnings": { + "boundary": { + "sha256": "8b28156825a8df2bdb68774229871250238e2c89a09e3ae1d4c96a1c6bcce3ae", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9" + }, + "classification": "sdk-compatible", + "contract": "count_pending_safety_warnings: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_safety_remediation.py::list_pending_safety_warnings": { + "boundary": { + "sha256": "64ecc9bcefda3996d4029b5cbc42f621f0e310053687c1e09175f48131cfd69e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9" + }, + "classification": "sdk-compatible", + "contract": "list_pending_safety_warnings: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_safety_remediation.py::acknowledge_safety_warning": { + "boundary": { + "sha256": "bebbcf46be575953b76a32aa0d8bd0e822ede442de94c6c12476645eab972a5f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9" + }, + "classification": "sdk-compatible", + "contract": "acknowledge_safety_warning: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_saved_analysis.py::_authorize_conversation": { + "boundary": { + "sha256": "d1b19e615b58caeb8af0ecf974dcd298d8c3221523ce899690f4a8a1d5079595", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "55d3821f09b34fd6ce9c05a0ad76fe0c6234ba16a9d18b1ac53265b0cda90388" + }, + "classification": "sdk-compatible", + "contract": "_authorize_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_saved_analysis.py::update_analysis_conversation": { + "boundary": { + "sha256": "daa5dd01599c40363697e8d59579f0ccfc5c2f95064ac57a84f87f5eed62433d", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "55d3821f09b34fd6ce9c05a0ad76fe0c6234ba16a9d18b1ac53265b0cda90388" + }, + "classification": "sdk-compatible", + "contract": "update_analysis_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_saved_analysis.py::bind_chat_analysis_attempt": { + "boundary": { + "sha256": "2bc004b90e5e208b915c2f5d644bc08b868c784b4a347bd295521554b8cb4d4e", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "55d3821f09b34fd6ce9c05a0ad76fe0c6234ba16a9d18b1ac53265b0cda90388" + }, + "classification": "sdk-compatible", + "contract": "bind_chat_analysis_attempt: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_saved_analysis.py::_load_authorized_message": { + "boundary": { + "sha256": "333a176776ca22bbb19306afdde16dea7711ce3ad1314f9320da16b0359b19da", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "55d3821f09b34fd6ce9c05a0ad76fe0c6234ba16a9d18b1ac53265b0cda90388" + }, + "classification": "sdk-compatible", + "contract": "_load_authorized_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_saved_analysis.py::_read_personal_conversation": { + "boundary": { + "sha256": "5ae8ec8e1432b308ed386ee16a337be099a4a0888068ae01eb96bf817e072d1c", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "55d3821f09b34fd6ce9c05a0ad76fe0c6234ba16a9d18b1ac53265b0cda90388" + }, + "classification": "sdk-compatible", + "contract": "_read_personal_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_saved_analysis.py::_analysis_artifact_parents": { + "boundary": { + "sha256": "120f9ce8e7ffd69bbf1db054bef665a354136e157cbbc7f8c981df8716097657", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "55d3821f09b34fd6ce9c05a0ad76fe0c6234ba16a9d18b1ac53265b0cda90388" + }, + "classification": "sdk-compatible", + "contract": "_analysis_artifact_parents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_saved_analysis.py::bind_native_analysis_artifacts": { + "boundary": { + "sha256": "a17bc97196452aa15ca361acf8d595861e24f68903bdfea4dcfe62596735618d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "patch_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "55d3821f09b34fd6ce9c05a0ad76fe0c6234ba16a9d18b1ac53265b0cda90388" + }, + "classification": "sdk-compatible", + "contract": "bind_native_analysis_artifacts: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_saved_analysis.py::_bind_analysis_projection_contexts": { + "boundary": { + "sha256": "baa8499ae9304680634fcdeecd576a7627b2a845c385808e74daea677904a45d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "patch_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "55d3821f09b34fd6ce9c05a0ad76fe0c6234ba16a9d18b1ac53265b0cda90388" + }, + "classification": "sdk-compatible", + "contract": "_bind_analysis_projection_contexts: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_search_service.py::_authorize_chat_upload_conversation": { + "boundary": { + "sha256": "3c3492a4d44ec21724c0682922e0f6fbd3dc68894ec4bdacf20d82294159d42e", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "103fbf517240fe01f444d3acab7e740df4923003a62aba34ff1fcb388632899b" + }, + "classification": "sdk-compatible", + "contract": "_authorize_chat_upload_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_search_service.py::_resolve_chat_upload_context": { + "boundary": { + "sha256": "e795483e3a90794e3268e2833ba72694964ea9173814a9cd6a1f7e4b045e23ee", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "103fbf517240fe01f444d3acab7e740df4923003a62aba34ff1fcb388632899b" + }, + "classification": "sdk-compatible", + "contract": "_resolve_chat_upload_context: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_settings.py::_get_app_settings_store": { + "boundary": { + "sha256": "bc6d3efd58cae9b3e1b692f5b541b9c385fbe1ee6ce71a0ad64fff5df44f7748", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a393c3f309753a4fa67ed29866b92d691d592e1e3b956040056cf801ff428bcb" + }, + "classification": "sdk-compatible", + "contract": "_get_app_settings_store: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_settings.py::get_user_settings": { + "boundary": { + "sha256": "e63e62388d227292584451585cef9d22de7f5e5bb633569d9b85fcdf0aa75f1a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_user_settings_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_user_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a393c3f309753a4fa67ed29866b92d691d592e1e3b956040056cf801ff428bcb" + }, + "classification": "sdk-compatible", + "contract": "get_user_settings: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_settings.py::read_user_settings_snapshot": { + "boundary": { + "sha256": "c45411751c857573b8d0ec86a6a340a8e060204799d9d92915cd9e2866e3eda8", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a393c3f309753a4fa67ed29866b92d691d592e1e3b956040056cf801ff428bcb" + }, + "classification": "sdk-compatible", + "contract": "read_user_settings_snapshot: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_settings.py::update_user_settings": { + "boundary": { + "sha256": "ac64ffe361080b3b61215154961ab6c7d6200c3acfae9b837a6a063a0c118859", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_user_settings_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_user_settings_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_user_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a393c3f309753a4fa67ed29866b92d691d592e1e3b956040056cf801ff428bcb" + }, + "classification": "sdk-compatible", + "contract": "update_user_settings: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_settings.py::get_user_search_history": { + "boundary": { + "sha256": "6037312077f10d0f3a4fee3eab19d7f4be707853317ee1d4a7765d4e0e956471", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a393c3f309753a4fa67ed29866b92d691d592e1e3b956040056cf801ff428bcb" + }, + "classification": "sdk-compatible", + "contract": "get_user_search_history: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_settings.py::add_search_to_history": { + "boundary": { + "sha256": "4b3c61716e5517b6dfc5f67cbb532a034281458e33c20375ddddb3dd2cfad6a8", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_user_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a393c3f309753a4fa67ed29866b92d691d592e1e3b956040056cf801ff428bcb" + }, + "classification": "sdk-compatible", + "contract": "add_search_to_history: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_settings.py::clear_user_search_history": { + "boundary": { + "sha256": "2ec265bcf42c91c40cce1b307cdd449f453755c1c7c5b9219fc4e1212f1cc867", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_user_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "a393c3f309753a4fa67ed29866b92d691d592e1e3b956040056cf801ff428bcb" + }, + "classification": "sdk-compatible", + "contract": "clear_user_search_history: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_shared_cache.py::set_shared_cache_entry": { + "boundary": { + "sha256": "e893e542a4a578f66fd78a17ca0ce90b2e3731945fd104f5844cd1726b55e722", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0" + }, + "classification": "response-unused", + "contract": "set_shared_cache_entry: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_shared_cache.py::get_shared_cache_entry": { + "boundary": { + "sha256": "c69d5b5e16e8d88540f80d76acbf06b05f028d570fca59d1a1930f2a44374f93", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0" + }, + "classification": "sdk-compatible", + "contract": "get_shared_cache_entry: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_shared_cache.py::delete_shared_cache_entry": { + "boundary": { + "sha256": "37529eeee47374229895daff545719757ccfcfe7d25bbeb00fcee10da5ea0ad4", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0" + }, + "classification": "response-unused", + "contract": "delete_shared_cache_entry: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_shared_cache.py::get_shared_cache_version": { + "boundary": { + "sha256": "014b42bfb0d1c442035e0def7076faff80e0595fd6d8e58029a83abf902b20c1", + "points": [ + { + "method": "read_item", + "receiver": "cache_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0" + }, + "classification": "sdk-compatible", + "contract": "get_shared_cache_version: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_shared_cache.py::ensure_shared_cache_version_doc": { + "boundary": { + "sha256": "4d714875e63aadd9e70e1e2c9a1940322decb19a409f8a98500b5fa4a23ab533", + "points": [ + { + "method": "read_item", + "receiver": "cache_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cache_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cache_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0" + }, + "classification": "sdk-compatible", + "contract": "ensure_shared_cache_version_doc: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_shared_cache.py::bump_shared_cache_version": { + "boundary": { + "sha256": "803868a1b5ea3baec17e3208b594b04fd7aef1d90e49597192211bbb127013b7", + "points": [ + { + "method": "read_item", + "receiver": "cache_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cache_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0" + }, + "classification": "sdk-compatible", + "contract": "bump_shared_cache_version: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::_cleanup_failed_fork": { + "boundary": { + "sha256": "bfecba7b3f17e38bbbe1a63f7c9787d6a01caf968cbf28b39b6fce8ca91ad8e0", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "response-unused", + "contract": "_cleanup_failed_fork: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_simplechat_operations.py::fork_personal_conversation_for_user": { + "boundary": { + "sha256": "9ea61c64c44d4d0fd561face73a793bb6acf5c19368c7366f513bc766d6afa24", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "fork_personal_conversation_for_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::create_personal_conversation_for_current_user": { + "boundary": { + "sha256": "4fcfb55ad703b839e52759c958b2f87b6fceeba9c03cceb0f0ede0b14f262d51", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "response-unused", + "contract": "create_personal_conversation_for_current_user: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_simplechat_operations.py::add_conversation_message_for_current_user": { + "boundary": { + "sha256": "693cc6280702a2a25f1bbf49014844ba9184edd086efd6656558a017612e0849", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "add_conversation_message_for_current_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::delete_generated_chat_artifact_for_user": { + "boundary": { + "sha256": "7caeb1655962bad3e4dd1349722c5d14bd83aa620b897006a8f6fd2f4a0ff100", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "delete_generated_chat_artifact_for_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::delete_staged_orchestration_chat_artifact_for_user": { + "boundary": { + "sha256": "1f85fdd29870262b79bf0d2ba82028bce78d4c8627297810c5201558d57ad827", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "delete_staged_orchestration_chat_artifact_for_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::delete_blob_backed_chat_message_files": { + "boundary": { + "sha256": "68675d5404a8406b9907975fcbd20efb1e55680cb6b6ba20276170e76b357e8b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "delete_blob_backed_chat_message_files: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::_persist_personal_conversation_message": { + "boundary": { + "sha256": "5290e5a1e696c001282790000ea11a896524b84c53d46c7ab76076bb7c2e8a56", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "response-unused", + "contract": "_persist_personal_conversation_message: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_simplechat_operations.py::_get_latest_personal_thread_id": { + "boundary": { + "sha256": "a67efd9fc9a5f5f315bb3d611d8c4586bf80f38c6f1e095242fe26e3761fd05f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "_get_latest_personal_thread_id: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::list_pending_generated_file_approvals_for_user": { + "boundary": { + "sha256": "567a1350247b61ef5a33b7ff484590aa6a9d0c75e7d99841a0d0d8fe37ee043e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "list_pending_generated_file_approvals_for_user: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::resolve_generated_file_approval_for_user": { + "boundary": { + "sha256": "4907d47d45012968698cf7e0bc4e48650b2366f3f7d5ad2463d366eb6044bb18", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "resolve_generated_file_approval_for_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::attach_generated_file_approval_state": { + "boundary": { + "sha256": "097f0b2426f9f7b8947ef01da77c60a7d36946c709bbcda3b028306745ea4666", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "attach_generated_file_approval_state: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::auto_deny_expired_generated_file_approvals": { + "boundary": { + "sha256": "42a08d53f01608922dc4098d9f8ad95e73704ce4a5c2e9b6361b3300e75278ff", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "response-unused", + "contract": "auto_deny_expired_generated_file_approvals: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_simplechat_operations.py::_upload_generated_chat_artifact_for_current_user": { + "boundary": { + "sha256": "02c90ea6a3b7cb15e418a47736c269f77fb5292a6bb67da6339368d1358f3736", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "_upload_generated_chat_artifact_for_current_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::_upload_generated_chat_artifact_for_current_user.reauthorize_write": { + "boundary": { + "sha256": "4a10b59df2b5b52844e8d67817619d64d04ad814240e7d50fbf620ac74a089f8", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "_upload_generated_chat_artifact_for_current_user.reauthorize_write: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::assert_generated_chat_artifact_is_published_for_user": { + "boundary": { + "sha256": "6f5107b7ed0f82fa97e0398fcdf920749f28c39d5120d15ac3a1fa68263da2de", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_tabular_export_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "assert_generated_chat_artifact_is_published_for_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::commit_generated_chat_artifact_publication_for_user": { + "boundary": { + "sha256": "58eb69bf4d85b1ca10a68c739861e319c3293d5f08135578798ee6c2bc17c5a8", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "sdk-compatible", + "contract": "commit_generated_chat_artifact_publication_for_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_simplechat_operations.py::_log_group_member_addition": { + "boundary": { + "sha256": "94f1a69594b714c9890021aed786cb192074f1966237c4df082d8191e4a46f1e", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "00c664946ca1bbea65b5726521defd10024c6a424ca1972f5a5c366493d8d553" + }, + "classification": "response-unused", + "contract": "_log_group_member_addition: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_tabular_generated_exports.py::_authorize_tabular_export_run_conversation": { + "boundary": { + "sha256": "2db7ce9752384889b7e3c88a920b73086d376abad2b561cc916be2fcb67be600", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7b22e886bd1fd300ac8ff9bb18bb5a9abe1f0f29118f8789f23d43229e2ccae7" + }, + "classification": "sdk-compatible", + "contract": "_authorize_tabular_export_run_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_tabular_generated_exports.py::_authorize_tabular_export_run_execution": { + "boundary": { + "sha256": "46bcb71e46489ffc9447c96e6de8ddd5e215935c7efd696857aa0efe597a2f07", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_orchestration_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7b22e886bd1fd300ac8ff9bb18bb5a9abe1f0f29118f8789f23d43229e2ccae7" + }, + "classification": "sdk-compatible", + "contract": "_authorize_tabular_export_run_execution: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_tabular_generated_exports.py::_query_scheduler_candidates_by_status": { + "boundary": { + "sha256": "95dd3db2bdbcca82dcbad9eb846bcc46410a5043892925275d0b97976ef1241e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_tabular_export_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "7b22e886bd1fd300ac8ff9bb18bb5a9abe1f0f29118f8789f23d43229e2ccae7" + }, + "classification": "sdk-compatible", + "contract": "_query_scheduler_candidates_by_status: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_tabular_generated_exports.py::get_tabular_generated_output_run_status": { + "boundary": { + "sha256": "37033d74b534cb3d85ef135810b7eb61d429c05cf514899562a5e1ea9dc5a548", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_tabular_export_runs_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7b22e886bd1fd300ac8ff9bb18bb5a9abe1f0f29118f8789f23d43229e2ccae7" + }, + "classification": "sdk-compatible", + "contract": "get_tabular_generated_output_run_status: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_tabular_generated_exports.py::_read_run": { + "boundary": { + "sha256": "64e6ce341659ab2caf67081615f6fdcb6f5cf08a6a00adbb2c79bae62ebbbf00", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_tabular_export_runs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7b22e886bd1fd300ac8ff9bb18bb5a9abe1f0f29118f8789f23d43229e2ccae7" + }, + "classification": "sdk-compatible", + "contract": "_read_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_tabular_generated_exports.py::_replace_run": { + "boundary": { + "sha256": "c5bbea5e76c5ff60dfbb2bc32fc91949ec38988b5630578ea0cc1dafbc9c973a", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_tabular_export_runs_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7b22e886bd1fd300ac8ff9bb18bb5a9abe1f0f29118f8789f23d43229e2ccae7" + }, + "classification": "sdk-compatible", + "contract": "_replace_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_tabular_generated_exports.py::queue_tabular_generated_output_run": { + "boundary": { + "sha256": "eb5b3df6fef7c091dcea83e7295773d6f7d483cf18bff0fbba16fcaf42b10dd8", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_tabular_export_runs_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_tabular_export_runs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "7b22e886bd1fd300ac8ff9bb18bb5a9abe1f0f29118f8789f23d43229e2ccae7" + }, + "classification": "response-unused", + "contract": "queue_tabular_generated_output_run: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_thoughts.py::ThoughtTracker.add_thought": { + "boundary": { + "sha256": "f2f09a0fa64a3ad68b44d18171b6ccb50588c88ab2211139430bf03382434f7c", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_thoughts_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "response-unused", + "contract": "ThoughtTracker.add_thought: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_thoughts.py::ThoughtTracker.complete_thought": { + "boundary": { + "sha256": "94fe05a760579b371a7de682c470bd413d6f2b55cc7b7397f85c7d95b00c3eb3", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_thoughts_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_thoughts_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "sdk-compatible", + "contract": "ThoughtTracker.complete_thought: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_thoughts.py::_visible_chat_thoughts": { + "boundary": { + "sha256": "1fc21c1a497b944936d3667dc4f6fe81b7e38ed1aabc8c21cf0ac67cd0c015fc", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "sdk-compatible", + "contract": "_visible_chat_thoughts: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_thoughts.py::get_thoughts_for_message": { + "boundary": { + "sha256": "b779b47553c15b1f6b96a8c11669d6e16eb505de16434bdf6cda17b050eeb8db", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_thoughts_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "sdk-compatible", + "contract": "get_thoughts_for_message: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_thoughts.py::delete_scoped_thoughts_for_message": { + "boundary": { + "sha256": "72b1e8a6ce5b4a287a7d7e70b80eb283736e3b44b8a467db6036fd62eab26c0b", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_thoughts_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_thoughts_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "response-unused", + "contract": "delete_scoped_thoughts_for_message: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_thoughts.py::get_pending_thoughts": { + "boundary": { + "sha256": "7680ee4ea6ed71d4e8d3baa58410132dc5b1a5268e7f0d845662d349fc3ced56", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_thoughts_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "sdk-compatible", + "contract": "get_pending_thoughts: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_thoughts.py::get_thoughts_for_conversation": { + "boundary": { + "sha256": "89242cc68d8108032b11dccd291a2bc860ac296a21a17fc4cefbdc7fa4ea920d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_thoughts_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "sdk-compatible", + "contract": "get_thoughts_for_conversation: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_thoughts.py::archive_thoughts_for_conversation": { + "boundary": { + "sha256": "91915c00823924719e3a1162e3816e3fd6493c8d21da0de206bbd1734b9bae7e", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_archived_thoughts_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_thoughts_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "response-unused", + "contract": "archive_thoughts_for_conversation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_thoughts.py::delete_thoughts_for_conversation": { + "boundary": { + "sha256": "d2d004c344acfb0043a929fb2760868ddc066494bbbc351f05d444eba7a4dea7", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_thoughts_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "response-unused", + "contract": "delete_thoughts_for_conversation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_thoughts.py::delete_thoughts_for_message": { + "boundary": { + "sha256": "3ca279147884bfcc851445b3e8372db1c9d49b7540cb12dba44959c399e48628", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_thoughts_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_thoughts_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b" + }, + "classification": "response-unused", + "contract": "delete_thoughts_for_message: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_assist_limits.py::CosmosAssistLimitStore.read": { + "boundary": { + "sha256": "a18f5fb1e5f4a5145bf71fbbfe4670f4ac0cafa692dfd9ed7e9fbc1fb3d131f7", + "points": [ + { + "method": "read_item", + "receiver": "self._container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0fd04eb6bc92eac13793adde066dffade5cbebab3ab28d28bfa20dfe193944a8" + }, + "classification": "sdk-compatible", + "contract": "CosmosAssistLimitStore.read: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_assist_limits.py::CosmosAssistLimitStore.create": { + "boundary": { + "sha256": "32fcb10e98824abe508b3906381710ebf0c486dbc5477315c308b53b6454d039", + "points": [ + { + "method": "create_item", + "receiver": "self._container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0fd04eb6bc92eac13793adde066dffade5cbebab3ab28d28bfa20dfe193944a8" + }, + "classification": "response-unused", + "contract": "CosmosAssistLimitStore.create: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_assist_limits.py::CosmosAssistLimitStore.replace": { + "boundary": { + "sha256": "d9b7a4e99e0410d49b0a5217174d90f3a889aaaa01828a52475c840665f3fa3d", + "points": [ + { + "method": "replace_item", + "receiver": "self._container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0fd04eb6bc92eac13793adde066dffade5cbebab3ab28d28bfa20dfe193944a8" + }, + "classification": "response-unused", + "contract": "CosmosAssistLimitStore.replace: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_assist_runtime.py::read_workflow_base": { + "boundary": { + "sha256": "fa36276a6106a2ac5d3919ef22e7c80bd6d463373838c74660b05e9d7b92a014", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "e4db2e747cbc4026e96e90af13cf117ab83c5f6d3a8fe3ed2c193364752188cb" + }, + "classification": "sdk-compatible", + "contract": "read_workflow_base: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_chat_delivery_status.py::_RequestReads._read_workflow": { + "boundary": { + "sha256": "4918c28aa34588dccf309addf9de423c8abeac5d4ed5da45ab7342e99a2159f8", + "points": [ + { + "method": "read_item", + "receiver": "self.services.workflows", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4d3920a486b7ba6ab66675757c160220c96750ae2b6441d244d05b465abb0679" + }, + "classification": "sdk-compatible", + "contract": "Status reads accept mapping records and expose a redacted field projection; no raw SDK response reaches an exact-dictionary sink.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_status_route.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_status.py::workflow_run_status_payload": { + "boundary": { + "sha256": "2a14578dee997a853ff322b8bbe15fd09a6cd9bc528d2787e2e447b0ab68a565", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "services.runs", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4d3920a486b7ba6ab66675757c160220c96750ae2b6441d244d05b465abb0679" + }, + "classification": "sdk-compatible", + "contract": "Status reads accept mapping records and expose a redacted field projection; no raw SDK response reaches an exact-dictionary sink.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_status_route.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_read_run": { + "boundary": { + "sha256": "277cd44165557a6c5955d0feb62259b5643cdba91665d2b57e2bc417860b88b2", + "points": [ + { + "method": "read_item", + "receiver": "services.runs", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_replace_run": { + "boundary": { + "sha256": "be465d660014c8d7a07961be323f2fabfa8456ffcb526344a509f716a363160e", + "points": [ + { + "method": "replace_item", + "receiver": "services.runs", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_read_workflow": { + "boundary": { + "sha256": "ee70bfbf1b42c9e0d56cdb53a8822ed5932ba2ac86b14b89fe637c18828cd46d", + "points": [ + { + "method": "read_item", + "receiver": "services.workflows", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_read_conversation": { + "boundary": { + "sha256": "43ec4802bb6f1612419aeb4913a332fb5d6bb6a98bec0b668563dd9511971a3f", + "points": [ + { + "method": "read_item", + "receiver": "services.conversations", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_newest_message": { + "boundary": { + "sha256": "736b126674b344581792cefad6c5e53388599df215208500d5664fae1ff8b237", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "services.messages", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_message_exists": { + "boundary": { + "sha256": "35e728b00cfd4b7e16fceb0323561242ec7dcf5b01d563b84ad082dbb361e438", + "points": [ + { + "method": "read_item", + "receiver": "services.messages", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_create_message": { + "boundary": { + "sha256": "40c36845dc8e90c10cfb21dc2d6d7778e457f47d3a18951e58e271bfcb53b146", + "points": [ + { + "method": "create_item", + "receiver": "services.messages", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "response-unused", + "contract": "_create_message: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_question": { + "boundary": { + "sha256": "9e185629660669cdbbeeab49179f84b373bfa9514620320892a105b8306f4629", + "points": [ + { + "method": "read_item", + "receiver": "services.messages", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::_conversation_title": { + "boundary": { + "sha256": "7f2330c18f46d92a7d677e0a03af430f46e0216ca39fcc6710d45f03b969d22e", + "points": [ + { + "method": "read_item", + "receiver": "delivery.services.conversations", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_chat_delivery_worker.py::run_workflow_chat_delivery_sweep": { + "boundary": { + "sha256": "1009b5ce991b7601591920b3891b29ac5136fa08a97c760d877a0e2dc8a20994", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "services.runs", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769" + }, + "classification": "sdk-compatible", + "contract": "Chat post-back storage records use mapping fields and plain owner-built publication payloads; domain runtime/readers are separate injected contracts.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "application/single_app/functions_workflow_definition_store.py::refuse_save_of_deleted_workflow": { + "boundary": { + "sha256": "57767c3c4d23c4a0c0731aca3f5a4546954cef151f1f5c544b906d78a518c7cd", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b363895390b6a4f1f5a513b797356bd4da3924313d69c1475856815589d7b048" + }, + "classification": "response-unused", + "contract": "refuse_save_of_deleted_workflow: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_definition_store.py::save_workflow_definition_record": { + "boundary": { + "sha256": "4bfab13ee42d1966d699fd75c99c66edc9232a09c18cb6d95dfa85ad2b1e6202", + "points": [ + { + "method": "create_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b363895390b6a4f1f5a513b797356bd4da3924313d69c1475856815589d7b048" + }, + "classification": "sdk-compatible", + "contract": "save_workflow_definition_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_definition_store.py::create_workflow_definition_record_if_absent": { + "boundary": { + "sha256": "739152491251985ee67686ca9cbaac07190d2a241e8fa352303febf514ecc784", + "points": [ + { + "method": "create_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b363895390b6a4f1f5a513b797356bd4da3924313d69c1475856815589d7b048" + }, + "classification": "sdk-compatible", + "contract": "create_workflow_definition_record_if_absent: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_definition_store.py::update_workflow_runtime_record": { + "boundary": { + "sha256": "69ecef53ba0e035589abcf90e505f685c7f0eb7593fe827da38cc0a876543a51", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b363895390b6a4f1f5a513b797356bd4da3924313d69c1475856815589d7b048" + }, + "classification": "sdk-compatible", + "contract": "update_workflow_runtime_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_read": { + "boundary": { + "sha256": "0e7fb77a51acff91267a563ac4ec3a2633a945fc7dc34ec85b687e24eaba7c75", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6" + }, + "classification": "sdk-compatible", + "contract": "Journal outer point records use identity fields; payload JSON is nested plain data and public journal entries are explicit dictionary projections.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_runtime_store.py" + ] + }, + "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_commit": { + "boundary": { + "sha256": "7802606a24180625608cb9fb299d8ccebd29841891a247f6ef7f12ed0f83831f", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6" + }, + "classification": "response-unused", + "contract": "WorkflowJournalMixin.journal_commit: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_commit_many": { + "boundary": { + "sha256": "76be0e82056e88bf278012769b6dd38b8dc40670135c74d086aebf851986a55e", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6" + }, + "classification": "response-unused", + "contract": "WorkflowJournalMixin.journal_commit_many: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_page": { + "boundary": { + "sha256": "690c8da2b5607a0b9391160d9ef61687ef6e4298996c31b379d6fe835caff5a7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6" + }, + "classification": "sdk-compatible", + "contract": "Journal outer point records use identity fields; payload JSON is nested plain data and public journal entries are explicit dictionary projections.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_runtime_store.py" + ] + }, + "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_decide": { + "boundary": { + "sha256": "78c5787bd238a93595f12e364c355d04af9f19d16048237206ec7c77bf748a5f", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6" + }, + "classification": "response-unused", + "contract": "WorkflowJournalMixin.journal_decide: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_request": { + "boundary": { + "sha256": "ebd1ff632967d8104191240ee511f3af5fb59d800013670c367bf9b2bcbbf5c6", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6" + }, + "classification": "response-unused", + "contract": "WorkflowJournalMixin.journal_request: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_plan_replay.py::_read_conversation": { + "boundary": { + "sha256": "7b4e209d54227517fe831b536b97d745427b0c514074468db4ca5a819faef5d6", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b2d8cd612ddbf83ac1f627b5611dbee93badced5c9e71a0ac5484fbb7231ad24" + }, + "classification": "sdk-compatible", + "contract": "_read_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_plan_replay.py::_read_message": { + "boundary": { + "sha256": "31fd9586f6e3dcf1b4ebf281c629f61a494891b1b0fbe0514af41b8e83babdd6", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "b2d8cd612ddbf83ac1f627b5611dbee93badced5c9e71a0ac5484fbb7231ad24" + }, + "classification": "sdk-compatible", + "contract": "_read_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_result_followup.py::_latest_thread_id": { + "boundary": { + "sha256": "e1cad6036054f7a15527580880d4be3170fed502554db9484488a6a018281363", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "messages", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "98859b10b350cebda30047969d35c29e29eb6a6cd40e92d4e1405163cf4c8999" + }, + "classification": "sdk-compatible", + "contract": "_latest_thread_id: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_result_followup.py::run_workflow_result_follow_up": { + "boundary": { + "sha256": "f9f18ac76172b80a987628c2a2f2497e7b75ec7168487443a02800da6245f7bc", + "points": [ + { + "method": "upsert_item", + "receiver": "services.messages", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "services.messages", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "98859b10b350cebda30047969d35c29e29eb6a6cd40e92d4e1405163cf4c8999" + }, + "classification": "response-unused", + "contract": "run_workflow_result_follow_up: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_result_followup.py::_discard_answer": { + "boundary": { + "sha256": "2234671490f2ecb9e51172a52ffd04612e10c300efd3122b070918f9ace1060c", + "points": [ + { + "method": "delete_item", + "receiver": "services.messages", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "98859b10b350cebda30047969d35c29e29eb6a6cd40e92d4e1405163cf4c8999" + }, + "classification": "response-unused", + "contract": "_discard_answer: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_result_reader.py::_point_read": { + "boundary": { + "sha256": "a8c328dd8d85e7c973c4ba8a529be184407de37243504ab6919368cbf882fd46", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0f32f66cbe8a09ef70282e28b587fe4d76cab601b348e6166b6c278cbe7a4252" + }, + "classification": "sdk-compatible", + "contract": "_point_read: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_result_reader.py::_task_rows": { + "boundary": { + "sha256": "2fdd50432261ec86dce3d4cdd39ae916db63484927734a4614f9f68b5af19a19", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "0f32f66cbe8a09ef70282e28b587fe4d76cab601b348e6166b6c278cbe7a4252" + }, + "classification": "sdk-compatible", + "contract": "_task_rows: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._create_immutable_record": { + "boundary": { + "sha256": "3e2145b1d8bf7e6ec417fece48f7abdb9a706dd639425742903aff760eedb1b9", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore.rollover_orchestration_result_guard": { + "boundary": { + "sha256": "8fdec4ad9449440ec6c32497f6c1e4e2277de52c0b2b54aea5286cadfb1b4b7d", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "response-unused", + "contract": "WorkflowResultStore.rollover_orchestration_result_guard: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._read_manifest": { + "boundary": { + "sha256": "1d4312f5c6bc3f188e38cdde26f5380b400c0cd6047dad58ccc46d1334cba0dc", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._analysis_guard": { + "boundary": { + "sha256": "bf0be658cc9f8519b139fc7368a7ad115cdaeaf7f8c4af4f4b2cb1a89eebb7bb", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._analysis_control": { + "boundary": { + "sha256": "a106ee76ee7d0f75b53306e7304ecfb3214619cb1718340ee7a522c393eb90c6", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._write_analysis_record": { + "boundary": { + "sha256": "c6eefb7957109f068c667737aa4722198ac1740077018e084cbee8075e9ba189", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._write_analysis_lifecycle": { + "boundary": { + "sha256": "8a37397701955b25c178262a038316e8234c91eb102d76a12881bf6c6f517e48", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "self.container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "returned" + } + ], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._link_analysis_parent": { + "boundary": { + "sha256": "741cea63ef3a225783a012aab31be5c4c6a3f6faf7caed7cb5881929bbf01f1d", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore.fence_analysis_attempt": { + "boundary": { + "sha256": "9f5515ccd7092bf4d8f2bc39fecbdc1e1d55ba8829cdfd4c829b04f540101446", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "response-unused", + "contract": "WorkflowResultStore.fence_analysis_attempt: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore.cancel_analysis_attempt": { + "boundary": { + "sha256": "f7a503c0fb52c40ed4b259dee9b29a89f183432534de75bdd9c157d33026b382", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "response-unused", + "contract": "WorkflowResultStore.cancel_analysis_attempt: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._analysis_scope_rows": { + "boundary": { + "sha256": "fe5c54f69e50b44f69eb2e181ec442757ec3030b6844191af6c2a79bc4b1eedc", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "returned" + } + ], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._delete_analysis_controls": { + "boundary": { + "sha256": "0b220005d832a0c205ffef9dd66b618d7a8ee098047ba994b8f244f47a08d57d", + "points": [ + { + "method": "delete_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "response-unused", + "contract": "WorkflowResultStore._delete_analysis_controls: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._read_chunk": { + "boundary": { + "sha256": "91f7fee588a6c8264aa57f543bdd0f0c2600b9ab8c1bfee5fba9cbd6af0dd4b0", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore.delete_run_results": { + "boundary": { + "sha256": "acdb106e2cef98335485d90b31dc3d29367801e5dd823a876892f8fc40eba9d8", + "points": [ + { + "method": "delete_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "response-unused", + "contract": "WorkflowResultStore.delete_run_results: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._delete_conversation_results": { + "boundary": { + "sha256": "e7cf762bbd6ffde7d430c82b6f9ff6de95b1d0c8b99de09b1e50de7ebaa9f004", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._delete_records": { + "boundary": { + "sha256": "d28b179322cb5b860ca4092e1301c96c12e9644a5d36e974004cb8fd81b98620", + "points": [ + { + "method": "delete_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "response-unused", + "contract": "WorkflowResultStore._delete_records: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_result_store.py::_configured_result_store": { + "boundary": { + "sha256": "d6f8a6df63335a2d6399b0f7246b1361d5c163bd1d580013de11ff875d9d3c35", + "points": [ + { + "method": "read_item", + "receiver": "config.cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c8ff245201b16d2b2f1710c095f7af4528fd94b16abc56a00b45dfad41104a49" + }, + "classification": "sdk-compatible", + "contract": "Manifest/lifecycle/chunk point reads accept Mapping via _require_fields; strict execution callbacks use normalized orchestration lease reads and payloads are parsed JSON.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_result_store.py" + ] + }, + "application/single_app/functions_workflow_results.py::authorize_workflow_run_read": { + "boundary": { + "sha256": "f5424b8206570dfa24e8e03e8e7f2c9b27689d28804d3e8238d6640897195eb0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "cf5fd249fe67de1a851cd7cfa2ce90ddbf0574594c5d67bd320f2295da73518a" + }, + "classification": "sdk-compatible", + "contract": "authorize_workflow_run_read: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_persist_agent_citation_artifacts": { + "boundary": { + "sha256": "8802115ebaf241fb68a75c1d942ee19d2fb6f039f45bb25edc78ce97b2e9cb45", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "response-unused", + "contract": "_persist_agent_citation_artifacts: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_runner.py::_hide_run_posts_superseded_by_reply": { + "boundary": { + "sha256": "d0bffe29664b0dc9ea83fc1b01f8b54c258f0b7ea42c166a9f150a6966c895f0", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_hide_run_posts_superseded_by_reply: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_hide_workflow_conversation_after_delivery": { + "boundary": { + "sha256": "a83260ac1a25c600544ae9ed8a397f0546d51c0615c52f1dd8a043142440b9a1", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_hide_workflow_conversation_after_delivery: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_mirror_assistant_message_to_personal_conversation": { + "boundary": { + "sha256": "db7e5a52f4079e891456f8eadc8bdea2cf8116119d58492d112550bfadd07bbf", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_mirror_assistant_message_to_personal_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_ensure_workflow_conversation": { + "boundary": { + "sha256": "dd591c009fee4188c4b535de05b033f94daf5ca3b08bc5569dc26bd8cf7d5fd1", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_ensure_workflow_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_get_latest_thread_id": { + "boundary": { + "sha256": "589f93f025d29d0a48ad56e9e89e23d4db2811a5322dec506d12659be4dc3f26", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_get_latest_thread_id: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_create_user_message": { + "boundary": { + "sha256": "11227ebeea95959cbbbaba0dc0c757022ac6ec33859ebeb497114b51d5737036", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_create_user_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_create_assistant_message": { + "boundary": { + "sha256": "e406158d98ce2022b08753d3ad1da265e7ed3f3528aff0723b6e1b00916e5ff6", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "response-unused", + "contract": "_create_assistant_message: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_runner.py::_query_recent_documents": { + "boundary": { + "sha256": "7107052712a007be1dcfa040eab13e8728d5150b95fd27330c2327e0a2e0584e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_query_recent_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_query_merge_candidate_documents": { + "boundary": { + "sha256": "64302912ed78d926766464c74de15ffc49456009c63955dcbfbeb69afc04404e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_query_merge_candidate_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runner.py::_run_authorized_workflow_impl": { + "boundary": { + "sha256": "fcbe4f937e1c3013af9aeb7537925d18f7937f0e0e39c1bd17ef6158ed64836a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d49f6afd849dcad105c2da3a370fa7a1340e7ae1365259f189d5c1c578e1dfc0" + }, + "classification": "sdk-compatible", + "contract": "_run_authorized_workflow_impl: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runtime.py::_bind_active_run": { + "boundary": { + "sha256": "5c9bd78acc45bf2f4d61a4a00aa26824d76b63fbfdc8dbc367147d31bb81c0c8", + "points": [ + { + "method": "read_item", + "receiver": "services['definitions']", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "services['definitions']", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c00f385c8c260df3d4d508325877a3b893a3338bcb868c29f0ef61c95c73ed87" + }, + "classification": "sdk-compatible", + "contract": "_bind_active_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runtime.py::queue_durable_workflow_run": { + "boundary": { + "sha256": "e98462a2dfb1d5f81ca51301bd9a781ff56bb46e1029ebff9f45241ca004813b", + "points": [ + { + "method": "read_item", + "receiver": "services['runs']", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "services['runs']", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "services['runs']", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "services['runs']", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "services['runs']", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c00f385c8c260df3d4d508325877a3b893a3338bcb868c29f0ef61c95c73ed87" + }, + "classification": "sdk-compatible", + "contract": "queue_durable_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runtime.py::_project_runtime_run": { + "boundary": { + "sha256": "d517e62c328922e43abdbac71fa7c1a1958275302ae538dd1aca819ddabe00ee", + "points": [ + { + "method": "read_item", + "receiver": "services['runs']", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "services['runs']", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "services['definitions']", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "services['definitions']", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c00f385c8c260df3d4d508325877a3b893a3338bcb868c29f0ef61c95c73ed87" + }, + "classification": "sdk-compatible", + "contract": "_project_runtime_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runtime.py::workflow_runtime_status": { + "boundary": { + "sha256": "addedc285d5a49c04bf60e6a218873cb175faaeb5dd994da3f2aae8495dec5b0", + "points": [ + { + "method": "read_item", + "receiver": "services['runs']", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c00f385c8c260df3d4d508325877a3b893a3338bcb868c29f0ef61c95c73ed87" + }, + "classification": "sdk-compatible", + "contract": "workflow_runtime_status: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runtime.py::continue_durable_workflow_run": { + "boundary": { + "sha256": "85ca4c534f0fb39b9602e90510a072dc167c532a12efbbb8ae3dbc88661e5ad9", + "points": [ + { + "method": "read_item", + "receiver": "services['runs']", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c00f385c8c260df3d4d508325877a3b893a3338bcb868c29f0ef61c95c73ed87" + }, + "classification": "sdk-compatible", + "contract": "continue_durable_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runtime.py::resume_m365_durable_workflow_run": { + "boundary": { + "sha256": "575bcc46920e0c8cb578a6ac8db9e309b8ca167a739a16781a821043ce8bc97d", + "points": [ + { + "method": "read_item", + "receiver": "services['runs']", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c00f385c8c260df3d4d508325877a3b893a3338bcb868c29f0ef61c95c73ed87" + }, + "classification": "sdk-compatible", + "contract": "resume_m365_durable_workflow_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runtime.py::check_durable_workflows_once": { + "boundary": { + "sha256": "3c9e4df80a33d44da65f94711ee44ba8caff8d1f61bfb2401a58d5dd06a2f286", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c00f385c8c260df3d4d508325877a3b893a3338bcb868c29f0ef61c95c73ed87" + }, + "classification": "sdk-compatible", + "contract": "check_durable_workflows_once: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore._read_control": { + "boundary": { + "sha256": "f524b533206fcb5a9afc3f51b0e0a9e3743f40683224a9988d10cb77d6ba846e", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" + }, + "classification": "sdk-compatible", + "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_runtime_store.py" + ] + }, + "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore._replace": { + "boundary": { + "sha256": "49b1ecfa58161e4aa57e04ef2f663b68d0f61045062656581ccd545906325dfc", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" + }, + "classification": "sdk-compatible", + "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_runtime_store.py" + ] + }, + "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore._verify_existing_record": { + "boundary": { + "sha256": "ab7406e8ef1ed75a2c52a5e928bfde344f07393b80f2642dcd227dca88f72bc7", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" + }, + "classification": "sdk-compatible", + "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_runtime_store.py" + ] + }, + "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore.write_record": { + "boundary": { + "sha256": "2ff6f956594bbd4e85705c20540b5ca97d6ab7d9be82e1e3cffe9b27e2a82d44", + "points": [], + "queries": [], + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" + }, + "classification": "response-unused", + "contract": "WorkflowRuntimeStore.write_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore.initialize": { + "boundary": { + "sha256": "144df60afd6a838f1f3aaca394c9bd60ea406d66724a5e8cd1664e034b7aa969", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" + }, + "classification": "sdk-compatible", + "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_runtime_store.py" + ] + }, + "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore.tombstone": { + "boundary": { + "sha256": "02550cd8959ceb2512c9f9e7aa1d07a0c14385c07f656a8d89d18d48977da010", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" + }, + "classification": "sdk-compatible", + "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", + "evidence_scope": "owner-runtime", + "tests": [ + "functional_tests/test_workflow_runtime_store.py" + ] + }, + "application/single_app/functions_workspace_authoring.py::read_editor_record": { + "boundary": { + "sha256": "868eeca7039453ea5d0a0d3d9e4187a711193dbeb0be1c06bb0bdbd147032825", + "points": [ + { + "method": "read_item", + "receiver": "_container(kind, scope)", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "read_editor_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::list_editor_records": { + "boundary": { + "sha256": "0644df05d0bc95a6f4cc684c1207541ee087a21452e22fbfeb3fcb8e245967a8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(kind)", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "_container(kind, 'global')", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "list_editor_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::_cleanup_replaced_secrets": { + "boundary": { + "sha256": "efd7842f0cf096879938f5923abe43d5b79819e52a11b36831dd7a8c4e54fbd0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(kind, 'global')", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "_container(kind, 'group')", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "_container(kind)", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "_cleanup_replaced_secrets: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::_sync_editor_reminders": { + "boundary": { + "sha256": "571e8a38e2c8ec4d1d9ca4fae9c6f3a4040fc38831513773fef547537faa175f", + "points": [ + { + "method": "patch_item", + "receiver": "_container(kind, scope)", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "_sync_editor_reminders: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::save_editor_record": { + "boundary": { + "sha256": "202c098f09f1b06c5dc9fda008f6ddcecbbdb1dcff377a5f1631ef524b0d75c0", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "save_editor_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::delete_editor_record": { + "boundary": { + "sha256": "7854c93a88a5c04eac52df00e4799c1591a7ad6954e30a6d1e1b36e38ae789ba", + "points": [ + { + "method": "delete_item", + "receiver": "_container(kind)", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "response-unused", + "contract": "delete_editor_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workspace_authoring.py::read_group_editor_record": { + "boundary": { + "sha256": "4220960e84458f2216fb800b9eb2ebbfecb883524c67b2ee8a6cb3253cff8153", + "points": [ + { + "method": "read_item", + "receiver": "_container(kind, 'group')", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "read_group_editor_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::read_group_merged_global_record": { + "boundary": { + "sha256": "a6ad28bd2f2be9c6cee3a22eb83bc952a416ba13a7bf89cf0bc7fd083f984845", + "points": [ + { + "method": "read_item", + "receiver": "_container(kind, 'global')", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "read_group_merged_global_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::list_group_editor_records": { + "boundary": { + "sha256": "5d1816ce8939e3c138d48ebcfdba677dcc1791f5e07423553e05a3f53b689090", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(kind, 'group')", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "_container(kind, 'global')", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "list_group_editor_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::_assert_group_available_name": { + "boundary": { + "sha256": "a97098cc7c98141169eb7308cb83097690d8bca0fe81c79d2c17b0ed68389704", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(kind, 'group')", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "_container(kind, 'global')", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "_assert_group_available_name: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::save_group_editor_record": { + "boundary": { + "sha256": "3f70651e24b0922e6ae10eda75072faeecba3f5e93354f1feb7d4584cd6dbf8d", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "save_group_editor_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::delete_group_editor_record": { + "boundary": { + "sha256": "091afdd15aef6701a865fff142a27b20af41b5843e74dc7b191c5662c3aa318e", + "points": [ + { + "method": "delete_item", + "receiver": "_container(kind, 'group')", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "response-unused", + "contract": "delete_group_editor_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workspace_authoring.py::read_global_editor_record": { + "boundary": { + "sha256": "c2a89be2257ca1359da93dafde2011ab378347e45772e8dbb154ae67cc72d357", + "points": [ + { + "method": "read_item", + "receiver": "_container(kind, 'global')", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "read_global_editor_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::list_global_editor_records": { + "boundary": { + "sha256": "5f804d08106d54afe5041bd1fb6e69feb007791e53172024f499a1c191256d10", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(kind, 'global')", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "list_global_editor_records: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::_assert_global_available_name": { + "boundary": { + "sha256": "160414da04c6afe7ca4e98e10bfde2ed7d57dd325f478213c50cc62a4f50d703", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(kind, 'global')", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "_assert_global_available_name: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::save_global_editor_record": { + "boundary": { + "sha256": "554fe0352d6b3b8e2a9834a61ef5db2aa1374876e9237569cefb091125dc5fd6", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "save_global_editor_record: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_authoring.py::delete_global_editor_record": { + "boundary": { + "sha256": "534275467cebcfbd124bbb145d4982df9fed050dd946fd82c307fa800b42bb9e", + "points": [ + { + "method": "delete_item", + "receiver": "_container(kind, 'global')", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "response-unused", + "contract": "delete_global_editor_record: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workspace_authoring.py::_assert_available_name": { + "boundary": { + "sha256": "2845badc3c227845c90d381e04e0c86387de63a22345bac0b221ea1f84a61fec", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_container(kind)", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "_container(kind, 'global')", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f326fa3383a60499d0f7a472e37ebd4699ab704062d6f663893f4343cde4a688" + }, + "classification": "sdk-compatible", + "contract": "_assert_available_name: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_identities.py::list_workspace_identities": { + "boundary": { + "sha256": "173ac629756efbafa1c0cafa0e8006d9896ae95742e8b165cc9e43d4c0d4b76f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "_get_identities_container(scope_type)", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ebb0c3de664aa68372c2259cea73549507be27ae3f84decd179a2f71164ba1a1" + }, + "classification": "sdk-compatible", + "contract": "list_workspace_identities: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_identities.py::get_workspace_identity": { + "boundary": { + "sha256": "ee9ca96edf1583d5f49675f444b2be2f5df7ee5b89e36223c4b259603e95c8dd", + "points": [ + { + "method": "read_item", + "receiver": "_get_identities_container(scope_type)", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ebb0c3de664aa68372c2259cea73549507be27ae3f84decd179a2f71164ba1a1" + }, + "classification": "sdk-compatible", + "contract": "get_workspace_identity: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_identities.py::create_workspace_identity": { + "boundary": { + "sha256": "4fab2bd15981a31010a3de4ad587231e96a88291d515d7f17bc199409b5127b6", + "points": [ + { + "method": "create_item", + "receiver": "_get_identities_container(scope_type)", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ebb0c3de664aa68372c2259cea73549507be27ae3f84decd179a2f71164ba1a1" + }, + "classification": "response-unused", + "contract": "create_workspace_identity: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workspace_identities.py::update_workspace_identity": { + "boundary": { + "sha256": "bd7e6858f1315f39121afc58e3ffcd068aecf0a869de6440bea8c10823675962", + "points": [ + { + "method": "upsert_item", + "receiver": "_get_identities_container(scope_type)", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ebb0c3de664aa68372c2259cea73549507be27ae3f84decd179a2f71164ba1a1" + }, + "classification": "response-unused", + "contract": "update_workspace_identity: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workspace_identities.py::delete_workspace_identity": { + "boundary": { + "sha256": "41ad9424b165d9f38062f9f943e64872ef6b37c76cc2db569b2ecd1041f24a55", + "points": [ + { + "method": "delete_item", + "receiver": "_get_identities_container(scope_type)", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ebb0c3de664aa68372c2259cea73549507be27ae3f84decd179a2f71164ba1a1" + }, + "classification": "response-unused", + "contract": "delete_workspace_identity: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/functions_workspace_identities.py::update_workspace_identity_conditional": { + "boundary": { + "sha256": "609a40e20a4d0889beda4dd0eacc6b0c792b3ebbbd323e7ad367a48ca55e0896", + "points": [ + { + "method": "replace_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ebb0c3de664aa68372c2259cea73549507be27ae3f84decd179a2f71164ba1a1" + }, + "classification": "sdk-compatible", + "contract": "update_workspace_identity_conditional: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/functions_workspace_identities.py::delete_workspace_identity_conditional": { + "boundary": { + "sha256": "44ade66ac6236cae59672f164c59dee64ad7911ea1baf4f78d9723529296a82b", + "points": [ + { + "method": "delete_item", + "receiver": "container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "ebb0c3de664aa68372c2259cea73549507be27ae3f84decd179a2f71164ba1a1" + }, + "classification": "response-unused", + "contract": "delete_workspace_identity_conditional: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_agents.py::_load_all_agent_records_for_default_migration": { + "boundary": { + "sha256": "e3aaf58e361440ee9e83ef8d6d0da7bfacedf44bebbc14dec7383abe3023ac2a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_global_agents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_agents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_personal_agents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "07b14ca7fecec049311521c23fd6ddae5b10ae399cb5642df1eeeace47730cc8" + }, + "classification": "sdk-compatible", + "contract": "_load_all_agent_records_for_default_migration: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::_rollback_agent_citation_artifacts": { + "boundary": { + "sha256": "f4b52dfb5a5a24a71a8b31c0839f7901ad49bc60e59be4104c6fbad5895e3ed8", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "response-unused", + "contract": "_rollback_agent_citation_artifacts: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_chats.py::_get_user_message_image_context": { + "boundary": { + "sha256": "9e47c6d3efd9690037f39ffbb8a98eb7bfa2457a76d9f4810161a8bb8d2b83b4", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "_get_user_message_image_context: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::_read_recent_assistant_messages": { + "boundary": { + "sha256": "046e824243430a02a5b186cd6e9d37d7e4b3b1c0388ad3620877f5594c0b75df", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "_read_recent_assistant_messages: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::_read_agent_citation_artifact_payloads": { + "boundary": { + "sha256": "6405a74b2bc9f5b3fec1e8dd855b4cf7286ce55f64019fa0ca3ee0e2b471f26e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "_read_agent_citation_artifact_payloads: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::_persist_screened_assistant": { + "boundary": { + "sha256": "3dc11565c768ba2dba4022d2d2e79c54f0f949cdcdcd0d270ceab567a7adc7d1", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "response-unused", + "contract": "_persist_screened_assistant: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_chats.py::_resolve_chat_selected_document_metadata": { + "boundary": { + "sha256": "b74514b35b7026cc4e9b74ca6e636b73bdc2aeb5b43b9b831a1b889933ba86bc", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "resolution_query['cosmos_container']", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "_resolve_chat_selected_document_metadata: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::_create_personal_conversation": { + "boundary": { + "sha256": "fe575c723ec7aa2ecdc1e1fbe7eb10d77fe71508f0d629aa8836b974abdd9618", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "response-unused", + "contract": "_create_personal_conversation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_chats.py::_resolve_authorized_conversation_context": { + "boundary": { + "sha256": "fab1e43b2782cf73dbcb57a0054fce275c34a46f670d5cb3a1dbc341a40a69a3", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "_resolve_authorized_conversation_context: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::persist_agent_citation_artifacts": { + "boundary": { + "sha256": "2ddf8a15d4535a230894dce969eec6547280a76d58c36b1517babbfa9cd59858", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "response-unused", + "contract": "persist_agent_citation_artifacts: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_chats.py::_load_user_message_response_context": { + "boundary": { + "sha256": "0c5fba39f955b382d6e3aaae020f036a56bdfc83993b061349c5a1790f1e482f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "_load_user_message_response_context: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::_reject_chat_submission": { + "boundary": { + "sha256": "288e129d9b351e7154851236aa8dc9e729c3717bdd3f70eabb8b8ae115486315", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "response-unused", + "contract": "_reject_chat_submission: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_chats.py::_build_tabular_related_document_catalog": { + "boundary": { + "sha256": "82662957f069353aefbf2a550a0c79d4812d7390c33162431d2ca95d6607cba8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "scope_query['cosmos_container']", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "_build_tabular_related_document_catalog: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::_save_chat_user_metadata": { + "boundary": { + "sha256": "3418d5f4ed60e5d72a0effeb33b213f1a69a24451547c70ab8468a1bfdba5a32", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "_save_chat_user_metadata: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats._resolve_document_action_selected_documents": { + "boundary": { + "sha256": "25a6045d75aaf20cb18064c0862a5f129752ef8170f85a29e3bf068189cd9204", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats._resolve_document_action_selected_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats._get_latest_chat_thread_id": { + "boundary": { + "sha256": "a038c79bedcf74e8e6845e86eb121bb297b509576060664c4f4665b4a194da0c", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats._get_latest_chat_thread_id: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats._load_or_create_analyze_conversation": { + "boundary": { + "sha256": "bdca4fcc9d084df866c382d171029a7b50682ed4277ae576a76eb6242b6eba50", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats._load_or_create_analyze_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.execute_saved_analysis_chat_request": { + "boundary": { + "sha256": "d05f7e80e44a9a9bebac52069256e6b2fe5a14d0b135ad25d8df2b925d464565", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.execute_saved_analysis_chat_request: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.execute_document_action_chat_request": { + "boundary": { + "sha256": "1de639eea525bd90a584727772f51764b3d4093e221b5b433dd2cbe2cf64034b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.execute_document_action_chat_request: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.generate_image_from_proposal": { + "boundary": { + "sha256": "69be4b24e818f4e852ff30fa1031f467c574c9693590231d7f5c858a19dfaa36", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.generate_image_from_proposal: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.generate_image_from_proposal.read_conversation_image": { + "boundary": { + "sha256": "7d6b5464e658524d26adfb6f6f7ff1e53a30f1bca4ef34bfc5db702897cc5377", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.generate_image_from_proposal.read_conversation_image: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.image_proposal_status": { + "boundary": { + "sha256": "bf6e633a6029e92fb26ac8044b8e88a6b593fa8103188190d93797a3aabc91d2", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.image_proposal_status: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.chat_api": { + "boundary": { + "sha256": "847f5b558af23dd4abbc4417e73664862f2e9d2f5fddca4749a0dfc2b2b65f46", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.chat_api: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.chat_stream_api.generate": { + "boundary": { + "sha256": "4191c8cba2e6a543d8304fbbcc916260406e07f370c2b51346ca8487a5b12cba", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.chat_stream_api.generate: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.chat_stream_api.generate.finalize_cancelled_stream_response": { + "boundary": { + "sha256": "2d72bd7ae1222544cf6c854947690d663816b01fcf1ba7000e7312416aeb731a", + "points": [ + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "response-unused", + "contract": "register_route_backend_chats.chat_stream_api.generate.finalize_cancelled_stream_response: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.mask_message_api": { + "boundary": { + "sha256": "4f023bbdec15c4ce11a324c31963c4689df6b465abdaf0d74b959c59aa099053", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.mask_message_api: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.set_message_visual_style_api": { + "boundary": { + "sha256": "ef785c631c95a57e1290f86dbf05a4c37972705387f146a543f7968ae5b7c7bf", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.set_message_visual_style_api: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats._load_block_revision_message": { + "boundary": { + "sha256": "c123ca933146d12ce4abf1d4fe6908b5b85669bec2683a9596570165bfc55305", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats._load_block_revision_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats._find_originating_user_request": { + "boundary": { + "sha256": "87cabd89ec423b1d136ca31f57302e7968915917aed47f813fde7509038cd88d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats._find_originating_user_request: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats._answer_raced_block_submission": { + "boundary": { + "sha256": "665b15455527190885836ef2693e580d7bb12f1095f5f852b3025e49300bf11f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats._answer_raced_block_submission: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_chats.py::register_route_backend_chats.add_message_image_revision_api": { + "boundary": { + "sha256": "738633127c1ba804260536f901a7797409fd8d518e35920ec3ee14efd10786d5", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "865c35d29eb1b428035d0c5c3028d8696de1ecd0e0ffcc4a7dc5c5d520a82b9d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_chats.add_message_image_revision_api: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_collaboration.py::_read_source_message_doc": { + "boundary": { + "sha256": "4e197f96774901388a1020c7f7782209922f741d17537f0d6ef327d3efbf838b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "returned" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "sdk-compatible", + "contract": "_read_source_message_doc: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_collaboration.py::_sync_collaboration_mask_metadata_to_source": { + "boundary": { + "sha256": "62a96e92fdcab0fb96a26e681afadabffcb66e5c23c0b1d9c2113e3bb76d16a0", + "points": [ + { + "method": "read_item", + "receiver": "source_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "source_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "sdk-compatible", + "contract": "_sync_collaboration_mask_metadata_to_source: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_collaboration.py::_sync_collaboration_block_revisions_to_source": { + "boundary": { + "sha256": "6379d69b1d3010498caa86ba7cae744002d02d46da7c012dd178e991b99b4f3e", + "points": [ + { + "method": "read_item", + "receiver": "source_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "source_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "sdk-compatible", + "contract": "_sync_collaboration_block_revisions_to_source: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_collaboration.py::_save_collaboration_image_revisions": { + "boundary": { + "sha256": "c0339b04a55a8a44fec6f496e6d3da8556b04ef196581787b0dd6fd4477f685f", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "response-unused", + "contract": "_save_collaboration_image_revisions: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_collaboration.py::_save_collaboration_block_revisions": { + "boundary": { + "sha256": "c1ca1faf4fc3d73cfde67dd6f45439322bc550d23302d3c000bf011d2f8c5a8b", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "response-unused", + "contract": "_save_collaboration_block_revisions: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_collaboration.py::_find_collaboration_originating_request": { + "boundary": { + "sha256": "ed7144214acf3cab30b8e4361586861007bd3127d59d2fd904bf2a07a8386c0f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "sdk-compatible", + "contract": "_find_collaboration_originating_request: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.mask_collaboration_message_api": { + "boundary": { + "sha256": "1fc52aaaa55005467cd20bcac1ba986376ac46a4c827ee6bdb2ceb2ef1a74e99", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "response-unused", + "contract": "register_route_backend_collaboration.mask_collaboration_message_api: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.add_collaboration_image_revision_api": { + "boundary": { + "sha256": "4bb38f2c190d9406561a1d98a4e82237ef836afe05249aa5e796aab2e4730818", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_collaboration.add_collaboration_image_revision_api: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.set_collaboration_message_visual_style_api": { + "boundary": { + "sha256": "f525b0236ed0bb7c4a3022b0e04811502f4c56a88b1e28cee1585c1a08acfc20", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "response-unused", + "contract": "register_route_backend_collaboration.set_collaboration_message_visual_style_api: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.stream_collaboration_message_api": { + "boundary": { + "sha256": "7c440d8651f4cbfdb65c259ebe698fe7f9de2c643186e64e1c7ef0e24de48f48", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "response-unused", + "contract": "register_route_backend_collaboration.stream_collaboration_message_api: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.stream_collaboration_message_api.generate_stream.transform_event_block": { + "boundary": { + "sha256": "365afb6eef02a0d5fdbb11f91a9e1d10d24eef0e4196ada527860748edba55d5", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_messages_container", + "response": "unused" + }, + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "019de1e7a6fd41fd216eee70d0fa248807bf6731a2faa90f62b10e26cd3acda9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_collaboration.stream_collaboration_message_api.generate_stream.transform_event_block: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_content_screening.py::register_route_backend_content_screening.content_screening_update_configuration": { + "boundary": { + "sha256": "96f02b15c06020c1da35a3347ca858516ec06b10b07889b8b630c798cf6890f5", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4fd917927cadbfb141d5268b9116f3350687681e46bf5a2c6d49a6c0b02d2e7d" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_content_screening.content_screening_update_configuration: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::get_group_token_totals": { + "boundary": { + "sha256": "cd22ac59f1ae93391e86fdaf5e592d1554dca69237b3ee7d5a1069962e35a3c4", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "get_group_token_totals: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::get_group_name_map": { + "boundary": { + "sha256": "a11221be98915e6d6562cbb7ce21dfe081431bc73a950f085d56ca2425cb8672", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "get_group_name_map: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::get_public_workspace_name_map": { + "boundary": { + "sha256": "c7acfabe176f420db2da191e9bd616eb6d5496b2675abe861d0ca44bc4edc4a1", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "get_public_workspace_name_map: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::get_distinct_token_filter_values": { + "boundary": { + "sha256": "88cb89bb060277c932b41a0c695a107f32d7c55adcedd867fb41dd62a2e3f8c7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "get_distinct_token_filter_values: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::get_activity_log_user_details": { + "boundary": { + "sha256": "db6ac09d6cf74929d1f3ba5cfc090fdf53620d66f3b2faa48a02445fd7398487", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "get_activity_log_user_details: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::enhance_user_with_activity": { + "boundary": { + "sha256": "15165977cf094e191e4765d9487052825ed9b83053532bf362d0bc6d5f185d8a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "enhance_user_with_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::_control_center_count_users": { + "boundary": { + "sha256": "01a9ad635c819fde99b0b296f472c6440616cc79b7e8aff29bf05a2d92fd7693", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "_control_center_count_users: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::_control_center_query_user_page": { + "boundary": { + "sha256": "aac7db66f198602913f484100799d691e35f77cf431197c599502ae10ad0cfc9", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "_control_center_query_user_page: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::_control_center_iter_users": { + "boundary": { + "sha256": "5ba64d8b61db844264f1273a6bb055cb6315f3bac5568b37350bd7f31c055cc9", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "_control_center_iter_users: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::enhance_public_workspace_with_activity": { + "boundary": { + "sha256": "41e4438482b804498e698784b4dc6f27149e9c9c84026572f7512fd122832632", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "enhance_public_workspace_with_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::enhance_group_with_activity": { + "boundary": { + "sha256": "7f60d6f37106da1433c8148fd7153b33a98c75f706dabb51dfbca559e775f5b0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "enhance_group_with_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::get_activity_trends_data": { + "boundary": { + "sha256": "6cae217b028b8ca9d05d4d82e9440f922a87665ebbabed773209b6f386bf2e38", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "get_activity_trends_data: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::get_raw_activity_trends_data": { + "boundary": { + "sha256": "bc580439f145a7efc361bbdc0f3d9e923090497976501b4f0b5c14f486585a06", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "get_raw_activity_trends_data: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::get_raw_activity_trends_data.get_user_info": { + "boundary": { + "sha256": "1ac34bf41434e9967d08dbc7804dc180c19f04a01678d00ef67a476e28ee1cf9", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "get_raw_activity_trends_data.get_user_info: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_all_users": { + "boundary": { + "sha256": "7b089da10b9f50d8ce718a8b8a9246ec9d201182982532c25489ecb2fbf21531", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_all_users: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_user_documents_admin": { + "boundary": { + "sha256": "f3e138cded81bc0eb56dbeae783cfcea5e6240f9c66acf31bebd427ce965f30f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_delete_user_documents_admin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_user_detail": { + "boundary": { + "sha256": "11dff4696a7335b87709786771eaa6333d22b0d7ecd498dd3415a9763108e41a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_v2_control_center_user_detail: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_users_bulk_action": { + "boundary": { + "sha256": "091325d90b12a464000e5a7586637a9c725e41932513c7d7a966da3d5d502e65", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_v2_control_center_users_bulk_action: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_group_detail": { + "boundary": { + "sha256": "83e235ea1e198629c89936db011966c2a83ab8ecd75c2f64142d3d95a1682bec", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_v2_control_center_group_detail: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_all_groups": { + "boundary": { + "sha256": "db5a1800b1878ef7ffe96d60466bcae089e733dea0fa6bf71c0ce676e28150c4", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_all_groups: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._update_group_status": { + "boundary": { + "sha256": "cb8948e7e20ef4aa9dba1a57e93feff9141802a76bbc247a8b4eb799afa96d56", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center._update_group_status: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_group_details_admin": { + "boundary": { + "sha256": "ace5a3e3953423f49745711e9848d926969f431f59c420d1beaf5e6cd2f72d9d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_group_details_admin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_group_admin": { + "boundary": { + "sha256": "74129a46aadfd2a3b989c2917b6d997af2c2b60a44eb40fb2e8cdf4009f1fc15", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_delete_group_admin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_group_documents_admin": { + "boundary": { + "sha256": "9eb798e2b3f1c1b9f03626c3987508b0c431d6e3a4a339209c6673fdfaba6766", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_delete_group_documents_admin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_group_members_admin": { + "boundary": { + "sha256": "2178cb5d3ca522efc8b51dd2a1041c848a57352392dbabf7c9afd9c8d2311666", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_group_members_admin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_take_group_ownership": { + "boundary": { + "sha256": "bdad34ce89e68b0c0f3107071a0bd279251bf89dd37d1ecb635da9d2aa108fbf", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_admin_take_group_ownership: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_transfer_group_ownership": { + "boundary": { + "sha256": "02ed6815ae2edd7ae926837e21ee902c01712553c830f5cd6ae50c91fcc3186e", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_admin_transfer_group_ownership: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_group_member": { + "boundary": { + "sha256": "4d41d2c6f7181843fee34e6ab84bbe70f079a743174252ff29aa25a75e81b7b1", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_admin_add_group_member: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_get_group_activity": { + "boundary": { + "sha256": "846db4bbce46379580c8c2127ffa9612bdb8a7971f1b6845f1bb20b4b35847bf", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_admin_get_group_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_public_workspace_detail": { + "boundary": { + "sha256": "23bce2a2e6b0b5e978288e25ecb684b7e2a4f019780a955052da381795c84263", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_v2_control_center_public_workspace_detail: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_control_center_public_workspaces": { + "boundary": { + "sha256": "ec82b7ba7e8bd23ff1fa9c8c472ad61c8643ff06af0c82566f08032a027ffe8e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_control_center_public_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_update_public_workspace_status": { + "boundary": { + "sha256": "773660a9082f9caf125d8985ddcca2166410cfcd4ba5032fe4f0a96b2758e0ad", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_update_public_workspace_status: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_bulk_public_workspace_action": { + "boundary": { + "sha256": "23727e4f33f97332f0aa6c496041bd4f98272f187e5a3241a456bdc7d67e7be6", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_bulk_public_workspace_action: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_details": { + "boundary": { + "sha256": "3ad7c153a87d1bb31ee0b7ee7ad9ef97d8a8c42e467401435faa473ee6afe5ec", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_public_workspace_details: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_members": { + "boundary": { + "sha256": "95321b44b8ac34e47bc18acfe1dc9d6ed03ba7ded4e280d7f43b682a397efe23", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_public_workspace_members: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_workspace_member": { + "boundary": { + "sha256": "190a9e0fd62cdf0fbc5a6cc7ffa214590c3494ab4b55776b3bb31e789be2138f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_admin_add_workspace_member: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_workspace_member_single": { + "boundary": { + "sha256": "102f1a5c5260d2a9d49d32adf40a953d0dc291ce2503a66382858dd173e6bde7", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_admin_add_workspace_member_single: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_activity": { + "boundary": { + "sha256": "d22f652c8f1aeadc7fb1cd2e4f6e25fb05edfc48d2af83c98ce695d6ec22333b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_public_workspace_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_take_workspace_ownership": { + "boundary": { + "sha256": "5c45a4268ed203cc1191f0b24c8708f609f6845792ddb1fa85e0f9f1ed1c1658", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_admin_take_workspace_ownership: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_update_public_workspace_ownership": { + "boundary": { + "sha256": "2b714ae8d17eb3f9414f3d6b0e416945015d7e63492077fe4165a17f3aec993a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_update_public_workspace_ownership: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_public_workspace_documents_admin": { + "boundary": { + "sha256": "0c7c5be24c7ef3f726e0f8cd75667b124bed98ba8570690901f7baae22303d90", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_delete_public_workspace_documents_admin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_public_workspace_admin": { + "boundary": { + "sha256": "d0e757dd05f82a15acdf847446730b24b8ecc5ffbf0b28f551baf5e6d074699b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_delete_public_workspace_admin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_dashboard_chat_readiness": { + "boundary": { + "sha256": "5bb8f8e780644f95c0aa35b6f0bbf777b392fc839477589669bc8e360c266e68", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_v2_control_center_dashboard_chat_readiness: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_token_filter_options": { + "boundary": { + "sha256": "4931b85731507d256754196b317189aaa18c299f3ccf7714f0b96ccc08a3c606", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_groups_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_token_filter_options: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_refresh_control_center_data": { + "boundary": { + "sha256": "7710a07eb7492e1d26caaeaffda928d3b72b5a9850c63605aac3a0eaf7c1cf73", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_refresh_control_center_data: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_activity_logs": { + "boundary": { + "sha256": "5d97c8a9db00355916061c4e7a2b02f6d190813878abaaa4e54564d5548ce3f5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_get_activity_logs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_export_activity_logs": { + "boundary": { + "sha256": "0c01054b08e472d162f861977bab1291dac624c04e99a4a595004531d97c295a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center.api_export_activity_logs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_take_ownership": { + "boundary": { + "sha256": "4d96dcd137ce7240af654015cddff03a7d9f3ce6d1310c92ad8fa1a04b0d0e10", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "response-unused", + "contract": "register_route_backend_control_center._execute_take_ownership: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_take_workspace_ownership": { + "boundary": { + "sha256": "f6cbc529a9062c458ed8b214ca3c84c8047e4e8b5330e76e8cd015ea62ba4ea0", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center._execute_take_workspace_ownership: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_take_workspace_ownership._resolve_user": { + "boundary": { + "sha256": "ef274097ab22ac87c72a3b048c7e5c29552a0fd3019ea61d09e7bd0d37bced4f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center._execute_take_workspace_ownership._resolve_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_transfer_ownership": { + "boundary": { + "sha256": "055e76f4c52ccb11c56a596291122ad68e78b56e995a48fc5cfb53ddd093775c", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "response-unused", + "contract": "register_route_backend_control_center._execute_transfer_ownership: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_transfer_workspace_ownership": { + "boundary": { + "sha256": "4417b1f5555b88b196d8548e4faf4e1b1a60cf02f96bd434a5114beb3b4221ee", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center._execute_transfer_workspace_ownership: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_transfer_workspace_ownership._resolve_user": { + "boundary": { + "sha256": "ef274097ab22ac87c72a3b048c7e5c29552a0fd3019ea61d09e7bd0d37bced4f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_control_center._execute_transfer_workspace_ownership._resolve_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_documents": { + "boundary": { + "sha256": "a1dab49c07ba1a019f7a7c966979e2b8e322e4cc4717eaae3ec9ebccf8728828", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "response-unused", + "contract": "register_route_backend_control_center._execute_delete_documents: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_public_workspace_documents": { + "boundary": { + "sha256": "4f95d0624ad9e1e16e0530c684f83045f043ed9cf8d7b91d09702ce13c23c366", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "response-unused", + "contract": "register_route_backend_control_center._execute_delete_public_workspace_documents: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_public_workspace": { + "boundary": { + "sha256": "dc56aa9ebe34d4a74e87b0f1a444ce3288d8face35882d9e959d2629b0535c1b", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_public_workspaces_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "response-unused", + "contract": "register_route_backend_control_center._execute_delete_public_workspace: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_group": { + "boundary": { + "sha256": "d8f46e31573c657e2d4fb8e5d373a5277edb1f6515c6ffd14d398d797d0fcc5f", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_group_conversations_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_group_messages_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_conversations_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "response-unused", + "contract": "register_route_backend_control_center._execute_delete_group: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_user_documents": { + "boundary": { + "sha256": "37081d79f77c390b0bc0eeee8769b496d3a45075684316cf78ada29492dfca38", + "points": [ + { + "method": "create_item", + "receiver": "cosmos_activity_logs_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9" + }, + "classification": "response-unused", + "contract": "register_route_backend_control_center._execute_delete_user_documents: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_conversation_export.py::_load_exportable_conversation_for_user": { + "boundary": { + "sha256": "e08c883a197ed4fc6c2f48cff05b535ae6f0e0532550aefafa881dc087551ea2", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c469f37c172440268486d8d833b646d766fd8e3b49b1c91aca0753853a17fb8b" + }, + "classification": "sdk-compatible", + "contract": "_load_exportable_conversation_for_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversation_export.py::_load_export_message_for_user": { + "boundary": { + "sha256": "46162520da41c8343e3f6198b672bd3617819e785bdcbe0cb5585780d7a8e780", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c469f37c172440268486d8d833b646d766fd8e3b49b1c91aca0753853a17fb8b" + }, + "classification": "sdk-compatible", + "contract": "_load_export_message_for_user: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversation_export.py::_load_generated_image_proposal_assets": { + "boundary": { + "sha256": "c8f9210188ad8d8d0399324a91ab66c3fdf3aa15b6c3838527ef711a34e3e2f6", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c469f37c172440268486d8d833b646d766fd8e3b49b1c91aca0753853a17fb8b" + }, + "classification": "sdk-compatible", + "contract": "_load_generated_image_proposal_assets: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_query_matching_messages": { + "boundary": { + "sha256": "d2f13ccdef1ed6b767cbda69558863f036b8619a867b0ed85b10b29d127cce10", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_query_matching_messages: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_query_legacy_conversations_for_feed": { + "boundary": { + "sha256": "fb26199a7007bb488fcd96a621dbb73d2cc37594401fda2f8524faa8ac1ac59d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_query_legacy_conversations_for_feed: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_count_hidden_legacy_conversations": { + "boundary": { + "sha256": "0b5aa104dbbe0cc2b29d3f8fca3ad15cae7018370a639811ccfc81be5c7e3564", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_count_hidden_legacy_conversations: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_load_unread_collaboration_notification_map": { + "boundary": { + "sha256": "e288840b85558b963b02fe8a08dd65cc6f57268680697f7ffbd924490d876761", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_notifications_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_load_unread_collaboration_notification_map: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_collect_child_message_documents": { + "boundary": { + "sha256": "f4046a3cf88c5c3362c3433d079685adb66b1c646d13947558ae38a38331bdba", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_collect_child_message_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_promote_remaining_thread_attempt": { + "boundary": { + "sha256": "70567c02b3fe0d663bbd02e982c95a5f4a8bbf887dbbbad7a1679b603024bcb8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_promote_remaining_thread_attempt: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_authorize_personal_conversation_read": { + "boundary": { + "sha256": "be12ad59bc41af0561996539729e975d73e0dd420cdf3b601b1b3e6feb30d179", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_authorize_personal_conversation_read: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_list_personal_conversation_generated_documents": { + "boundary": { + "sha256": "53bb11f366c937afb5e7c1e00e49fdc07656a8a04f6c78e35beb3fe61a68f53e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_list_personal_conversation_generated_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_rebuild_authorized_personal_conversation_used_documents": { + "boundary": { + "sha256": "3f8096462f25be00b36db760102f1f43cf6d84f6ea971f5f5ad4b8950d6ded6e", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "response-unused", + "contract": "_rebuild_authorized_personal_conversation_used_documents: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_conversations.py::_load_scope_lock_conversation": { + "boundary": { + "sha256": "1d77f8c14df18b5ef095f53d420e3f946390965f5f99b4cf3733b0542dfe3da6", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "_load_scope_lock_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::_persist_scope_lock_update": { + "boundary": { + "sha256": "b6876aa15e2e5423b60e936b4d822543703c04107f5bc7c6346be78eaab8663c", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_collaboration_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "response-unused", + "contract": "_persist_scope_lock_update: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.api_get_messages": { + "boundary": { + "sha256": "1f1b9bc53d9c4dfd2cfab4b059192911c97df1c923c45fe2416c44a68d8384cb", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.api_get_messages: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversations": { + "boundary": { + "sha256": "aca58e63857de1251541bf6bcb0ab76f1a8bc805f237dd16e8c007bbda6f66f5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.get_conversations: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.update_conversation_title": { + "boundary": { + "sha256": "b239c7ec5a4b20f20181461a3f8b1eedd97b38de518e40b93ce9cfa2df1cb77f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.update_conversation_title: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.delete_conversation": { + "boundary": { + "sha256": "cbdca96268fe6f7693a4ad6c477c22962d218d02dac1bdd05aa53b0746daadd2", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_archived_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_archived_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "response-unused", + "contract": "register_route_backend_conversations.delete_conversation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.delete_multiple_conversations": { + "boundary": { + "sha256": "9773c7d7de39b4ae9ad0c9879d46f75a51300375c117cc50c20384a568ede0b7", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_archived_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_archived_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "response-unused", + "contract": "register_route_backend_conversations.delete_multiple_conversations: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.toggle_conversation_pin": { + "boundary": { + "sha256": "9db586c9549d97f2f4ab431fc670f8a4498b883ce0b895bbf9aa287df40d7972", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.toggle_conversation_pin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.toggle_conversation_hide": { + "boundary": { + "sha256": "2fe5e3f4df4ba0f2ffb8eb2341c6dab33a9ea61b9248faaab32424753cc2f726", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.toggle_conversation_hide: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.bulk_pin_conversations": { + "boundary": { + "sha256": "f735878ca5ddc678867028375a8c7b03544cd8717c5ce26c8bc14f142a336902", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.bulk_pin_conversations: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.bulk_hide_conversations": { + "boundary": { + "sha256": "81f840e8f67daff73a3edd418243bb3936aeef3867a5ff9a7afdf68b786a66c7", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.bulk_hide_conversations: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversation_metadata_api": { + "boundary": { + "sha256": "132dd76467c6b53e568b146e4cbbaded407c7ec011ac5bf5c2fc4d8632b2f904", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.get_conversation_metadata_api: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversation_kind_api": { + "boundary": { + "sha256": "247712a562dcc002276aab8ee155f16f30ee65346336de39ca1b1579bc3d776d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.get_conversation_kind_api: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.mark_conversation_read_api": { + "boundary": { + "sha256": "82808426ee5a477f72469abb7117c64380995ac78625e0ead9c19108a9b550de", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.mark_conversation_read_api: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.generate_conversation_summary_api": { + "boundary": { + "sha256": "b43e1b99cd6bde701a4896e8eae5acbf0c41a22ab061f8386a559a75cbcefea3", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.generate_conversation_summary_api: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_user_classifications": { + "boundary": { + "sha256": "578cc1a0435445dcd95b0222773a48876a86d435b96486302bcc5166ae332166", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.get_user_classifications: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.search_conversations": { + "boundary": { + "sha256": "28a3a042791e03da653a93a96f2f4fa1da0eeec7c8bd1a53d484fefd7f50ad8f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.search_conversations: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.delete_message": { + "boundary": { + "sha256": "368109d39acb0f8ed18b0977ffce318ab6c6fdea17ef7ec3775feb7d3d281e2a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_archived_messages_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.delete_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_conversations.py::register_route_backend_conversations.switch_attempt": { + "boundary": { + "sha256": "e406e2cb9067349d8fd706e3fa29f192c93bd524c2b7cecf1115b557cffa21fe", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f98b82253ee3906e01a7ec5c478df8467121e90fb4588e8dff81d50988c992e" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_conversations.switch_attempt: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::_load_accessible_personal_documents": { + "boundary": { + "sha256": "1b8ab218df53ceddbf4cc594a485b2ed0675048a1d9b3914570bf356047c3cf7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "_load_accessible_personal_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.get_file_content": { + "boundary": { + "sha256": "6a6043aca95406472412e9e235804f780b26b17ae5ad56aca3d5ec4b97f5cb8a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.get_file_content: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_get_user_documents": { + "boundary": { + "sha256": "4b966b59d4193a62acec8dd61dff181e7b2ccea0233b47e321e3e981a23916ca", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.api_get_user_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_bulk_tag_documents": { + "boundary": { + "sha256": "16ac2858c8f376d8e939223871f78d852508ae17beaf216a18cb8f589a163b9e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.api_bulk_tag_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_update_tag": { + "boundary": { + "sha256": "7fde633c80ef35ececc9506b9136df550f535dc8262573740f3fc99eefeb32c1", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.api_update_tag: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_delete_tag": { + "boundary": { + "sha256": "21513f78dbbbe148e1488c3e2f519fabeb6ee99ff9e1b017fa4b4add0185c444", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.api_delete_tag: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_share_document": { + "boundary": { + "sha256": "7067173ad0f9cfbdf20eeb75b369420142ffaa8efef75ff508b4659ee2bbb8d9", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.api_share_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_unshare_document": { + "boundary": { + "sha256": "2000ce0507df7351d7ec847bbeb9709f700913a71e9b4f31cd0f71f18643c842", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.api_unshare_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_remove_self_from_document": { + "boundary": { + "sha256": "59885803bfcf17f747b6dee4854db92741fb70ac5ee017511f35b255f46a33ac", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.api_remove_self_from_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_documents.py::register_route_backend_documents.api_approve_shared_document": { + "boundary": { + "sha256": "4bb2f1afd8d86892e023fab521ca49c004cbffc09d62649b2f87e5e1e1427bdf", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8098cb1414887d448127f154f49df7fa6f9eae65fc66274a81f43ef9c0c0a094" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_documents.api_approve_shared_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_feedback.py::_authorize_feedback_conversation": { + "boundary": { + "sha256": "9dbd8ed7032992c75b9b4d3842a2f649f458bcb711c37c4a17fc247ed2523086", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2243e16fd3f4d004e4d9266bc304975d8be52ea68160528c85be170d0ee6ca97" + }, + "classification": "sdk-compatible", + "contract": "_authorize_feedback_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_feedback.py::_query_feedback_items": { + "boundary": { + "sha256": "64dfcec41f3fae8a5b0a16db1b971b64c702612ec5f39274abbfbce2c3b607bd", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_feedback_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2243e16fd3f4d004e4d9266bc304975d8be52ea68160528c85be170d0ee6ca97" + }, + "classification": "sdk-compatible", + "contract": "_query_feedback_items: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_feedback.py::_apply_feedback_review_update": { + "boundary": { + "sha256": "e156509d5f230fbe1b15b31b0b6038785da681f5ee053fec28cc88c1d7c8d55c", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_feedback_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2243e16fd3f4d004e4d9266bc304975d8be52ea68160528c85be170d0ee6ca97" + }, + "classification": "sdk-compatible", + "contract": "_apply_feedback_review_update: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_feedback.py::_archive_feedback": { + "boundary": { + "sha256": "4313ec95732eed92b206391a7ce3832c99d0db2da7df081b25b5fb1f0c853b85", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_feedback_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2243e16fd3f4d004e4d9266bc304975d8be52ea68160528c85be170d0ee6ca97" + }, + "classification": "sdk-compatible", + "contract": "_archive_feedback: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_feedback.py::_delete_feedback": { + "boundary": { + "sha256": "e0986f883c87644d0e16c0c12d81dee19fb0c8533b1f48393ceaf5d2492502cb", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_feedback_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_feedback_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_feedback_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2243e16fd3f4d004e4d9266bc304975d8be52ea68160528c85be170d0ee6ca97" + }, + "classification": "sdk-compatible", + "contract": "_delete_feedback: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_feedback.py::register_route_backend_feedback.feedback_submit": { + "boundary": { + "sha256": "8fa906645aec09a8d1511a86169cb1fdc0549307a3d5e7a0f57bf6107e02eb81", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_feedback_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2243e16fd3f4d004e4d9266bc304975d8be52ea68160528c85be170d0ee6ca97" + }, + "classification": "response-unused", + "contract": "register_route_backend_feedback.feedback_submit: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_feedback.py::register_route_backend_feedback.feedback_review_get_single": { + "boundary": { + "sha256": "35eee73bbe46eca5d57026ce28e3c92225494846e73fa566a2dac6ba305ffeab", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_feedback_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2243e16fd3f4d004e4d9266bc304975d8be52ea68160528c85be170d0ee6ca97" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_feedback.feedback_review_get_single: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_get_group_documents": { + "boundary": { + "sha256": "e99f47ec943a2e57f5a51981b3e826552fcae5e3a2bed8f1cd031ad0e263e19c", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_group_documents.api_get_group_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_delete_group_document": { + "boundary": { + "sha256": "0e7e3872316d496e2426c93072252bd077d9e17fc617ab5eef43e6cafc4159d4", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_group_documents.api_delete_group_document: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_bulk_tag_group_documents": { + "boundary": { + "sha256": "3e0a08f18cbb2e9b08536a05cbdf9af2a80e650080e9209c52d4ff392d341b06", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_group_documents.api_bulk_tag_group_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_update_group_tag": { + "boundary": { + "sha256": "0533cae1310aa8c2c5d9cea0ebb1de02b46045c69e492a06bad230a3fc670ee1", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_group_documents.api_update_group_tag: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_delete_group_tag": { + "boundary": { + "sha256": "1248b4c9a4fe15c566d86f9d66e02b71720812baa13e46a21241a33758c09a1d", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_group_documents.api_delete_group_tag: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_groups.py::register_route_backend_groups.api_group_activity": { + "boundary": { + "sha256": "17a8e6e356351c481d623b5901ec4130206c7382acb3a1b75ab598ae2855a9e7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "61aec306156aa512829ee0809a429a7464ebecc3ba292ec567cd9a00a8b8d7e1" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_groups.api_group_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_groups.py::register_route_backend_groups.api_group_stats": { + "boundary": { + "sha256": "588d93b9aa39400ff4bf53efc405ce70c31808339678e98f5dd04f1e2e6e2ccf", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "61aec306156aa512829ee0809a429a7464ebecc3ba292ec567cd9a00a8b8d7e1" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_groups.api_group_stats: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_m365.py::register_route_backend_m365.list_m365_waiting_requests": { + "boundary": { + "sha256": "f6dba896e621b730b8610e92a02ba74103c98dccf549744fd8b7cb96d90c104a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_m365_execution_runs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "ca3b45abe33f3ef83e6190af256368949379bbdca738b21d7cc3906ab0644215" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_m365.list_m365_waiting_requests: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_load_ledger": { + "boundary": { + "sha256": "b5dc08f80aa6ad83c0e2d1d7c1f4e3338cb90b939facde5ffa8b9fc40ebb969f", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_load_ledger: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_authorize_context_conversation": { + "boundary": { + "sha256": "89efc6e7eca2ba3ef0112983c5d9e2788fad3304f0ef503796998be744495e58", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_authorize_context_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_load_regeneration_snapshot": { + "boundary": { + "sha256": "5637554bb021fcd62df90f70c98e9e6e33cc15489898e46f2df2ed1203a80c45", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_load_regeneration_snapshot: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_link_regeneration_thread": { + "boundary": { + "sha256": "d679a3d90d078defe9de7faaae37dde08f24433e8b7311987a0a07be7802deb8", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_link_regeneration_thread: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_load_conversation_snapshot": { + "boundary": { + "sha256": "1b4d30f5e09b77e861bd836b0be885ac7e122285dfd6aa68d34417b971863a5c", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_load_conversation_snapshot: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_validate_saved_conversation_context": { + "boundary": { + "sha256": "e8f65e5deb3c03fecce21ed459e478418a0f26879783281dcccab44984a680e3", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_validate_saved_conversation_context: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_conversation_context_for_run": { + "boundary": { + "sha256": "e67be42f4ee19df1dc6c91805dbb858a6f0a01b1690f0995d016a83dea55a4d4", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_conversation_context_for_run: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_ensure_conversation": { + "boundary": { + "sha256": "16e2e62456a9d1d728e0985459f8625413e0d4c5a8a08d19b36f506ce01ef06f", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "create_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_ensure_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_save_message": { + "boundary": { + "sha256": "a8e211f24561985c44a87b387ee773a243a5e36e48bd1d58bfcad00a24c861a6", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "response-unused", + "contract": "_save_message: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_orchestration.py::_mirror_planned_turn": { + "boundary": { + "sha256": "8615966a67ce45b07978a6c1bef586a4929ecaada317f7d63b94829c1fc302b4", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_mirror_planned_turn: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_persist_planned_turn": { + "boundary": { + "sha256": "0ee1e0c7657944a1819faffbbb32aeff018ed19408c9a4e443e6aea195af0138", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_persist_planned_turn: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_save_turn_message": { + "boundary": { + "sha256": "60e2d02d068178246d072f878c7063fa4f18fa5003fa9de3c2498470ed95e693", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_save_turn_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_touch_conversation": { + "boundary": { + "sha256": "99d4c36c67f84cce3003b1743cd74df2a0c457539fd6f0e4d185db2bd3ce140c", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "replace_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_touch_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_run_response_removed": { + "boundary": { + "sha256": "7abf6197e4f767ff81c376db34ae031cb104e4d275e5ac078621113362fcbaba", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_run_response_removed: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_validate_checkpoint_artifacts": { + "boundary": { + "sha256": "d93f00edfdb22533b2e2b578313d4cee8da2ace69d7ffca425ed4332425b2366", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_validate_checkpoint_artifacts: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::_checkpoint_artifact_versions": { + "boundary": { + "sha256": "1c83df7e9294278003effafc350fa505ef60e47463b758e2ac25477e19f8e44a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "_checkpoint_artifact_versions: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_orchestration.py::register_route_backend_orchestration.orchestration_plan": { + "boundary": { + "sha256": "278c6030a064e1be2396c35f3dde06a488815d95f42d4ab019fe5360bcf30e5b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c66febd0dbbe84ef8f69cef250b3aa145d96efa5e9fb05e81155d81ad053971f" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_orchestration.orchestration_plan: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_plugins.py::set_user_plugins": { + "boundary": { + "sha256": "2a84bcceb1cea62cb4c5e3c20803005f63a499e4def57c408eef93e1e8e04aa9", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_personal_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c0b926e2dd2d7fed9999a9136c944270753cba204c11539937ef49ebe9cad9ed" + }, + "classification": "sdk-compatible", + "contract": "set_user_plugins: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_plugins.py::edit_plugin": { + "boundary": { + "sha256": "33d4fff6f75f78a7b47db4aab6feac61be6aa97534c858376aee87a74509195c", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_global_actions_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c0b926e2dd2d7fed9999a9136c944270753cba204c11539937ef49ebe9cad9ed" + }, + "classification": "sdk-compatible", + "contract": "edit_plugin: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_plugins.py::test_cosmos_connection": { + "boundary": { + "sha256": "b0a291494272cabf99d1c4e6c442e397453712b28ad1434291b0192fe717120e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container_client", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c0b926e2dd2d7fed9999a9136c944270753cba204c11539937ef49ebe9cad9ed" + }, + "classification": "sdk-compatible", + "contract": "test_cosmos_connection: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_list_public_documents": { + "boundary": { + "sha256": "fbf09f53a8f547cd40b065005d298f4353317a2e92fba76a71ee89b3d51d9856", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "00271fcce489a87d02f15ea5e37eba46cf28a82b24c0076554d1d6d8a0be2faa" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_public_documents.api_list_public_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_bulk_tag_public_documents": { + "boundary": { + "sha256": "f249322bafabb8d42f9ccbeb547e88706a05abc995d4e1a432ddd605d3f3389e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "00271fcce489a87d02f15ea5e37eba46cf28a82b24c0076554d1d6d8a0be2faa" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_public_documents.api_bulk_tag_public_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_update_public_workspace_tag": { + "boundary": { + "sha256": "61b6e308b6c2ab845e073e1586db3111ad1e4f33118f620377df4567aa02bb7a", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "00271fcce489a87d02f15ea5e37eba46cf28a82b24c0076554d1d6d8a0be2faa" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_public_documents.api_update_public_workspace_tag: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_delete_public_workspace_tag": { + "boundary": { + "sha256": "2bff3efcff5f56ca7b67d487b9a9d18e8056e1dd5b2236972454679813649a2b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "00271fcce489a87d02f15ea5e37eba46cf28a82b24c0076554d1d6d8a0be2faa" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_public_documents.api_delete_public_workspace_tag: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.discover_public_workspaces": { + "boundary": { + "sha256": "2abceccfe7a0f037b270aa76701310dabe02f29eed95df7db7bf37393feb6943", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "404eee415b651fe67730b93f997bd06631f3fb77fb66ef591c03aa90ddb52f93" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_public_workspaces.discover_public_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_file_count": { + "boundary": { + "sha256": "4fa3852d575f78037fa5a5225f6bd05e8b0aea2d75b60e19102c1627647bfbda", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "404eee415b651fe67730b93f997bd06631f3fb77fb66ef591c03aa90ddb52f93" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_public_workspaces.api_public_file_count: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_workspace_stats": { + "boundary": { + "sha256": "3239a9fd163d67457eb170e75defabad0cf3cc83ee67fce93f345a1f9d8ec047", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "404eee415b651fe67730b93f997bd06631f3fb77fb66ef591c03aa90ddb52f93" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_public_workspaces.api_public_workspace_stats: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_workspace_activity": { + "boundary": { + "sha256": "c3330120ec3b557e8ceee5586164f4782ef4dbdeeeeaba6bcc7c3e2758d3edbb", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "404eee415b651fe67730b93f997bd06631f3fb77fb66ef591c03aa90ddb52f93" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_public_workspaces.api_public_workspace_activity: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_retention_policy.py::register_route_backend_retention_policy.force_push_retention_defaults": { + "boundary": { + "sha256": "f3544c3dcd4e073acae0b0ff24171b087eed9386cb1eeec1f1b5af5a01033a23", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_user_settings_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "84c1e0e08f5f1444aa7732a6fa7881d4f10ea5d395fe1ff8037934afe3186bb2" + }, + "classification": "response-unused", + "contract": "register_route_backend_retention_policy.force_push_retention_defaults: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_backend_safety.py::_query_safety_logs": { + "boundary": { + "sha256": "4e39be4a23bcd7572381ee2bcb518bbfd2ee23ac59a9bf594598667d2be95c39", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "79d431364818117b84ac8810d30f0cfc8f79934901c0ab89d736b047f90b2745" + }, + "classification": "sdk-compatible", + "contract": "_query_safety_logs: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_safety.py::_count_other_user_violations": { + "boundary": { + "sha256": "4088baedc2b9295f883447368c52deff91311d68fee52ee633005a7bd32e7734", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "79d431364818117b84ac8810d30f0cfc8f79934901c0ab89d736b047f90b2745" + }, + "classification": "sdk-compatible", + "contract": "_count_other_user_violations: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_safety.py::_archive_safety_log": { + "boundary": { + "sha256": "67110af6279c981b2b6527f37c9b2286828cf08544dfb76e6cc4bba2562c5cef", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79d431364818117b84ac8810d30f0cfc8f79934901c0ab89d736b047f90b2745" + }, + "classification": "sdk-compatible", + "contract": "_archive_safety_log: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_safety.py::_delete_safety_log": { + "boundary": { + "sha256": "6358cae95552fa159f8f1fa17cb9db22d2404533e67f12ff62a0440d9899267a", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_safety_container", + "response": "unused" + }, + { + "method": "delete_item", + "receiver": "cosmos_safety_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79d431364818117b84ac8810d30f0cfc8f79934901c0ab89d736b047f90b2745" + }, + "classification": "sdk-compatible", + "contract": "_delete_safety_log: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_safety.py::register_route_backend_safety.get_safety_log": { + "boundary": { + "sha256": "a1a8c7ca1d2853c42692e197c5dc54b9e973460c7248b21481165833e7615f80", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79d431364818117b84ac8810d30f0cfc8f79934901c0ab89d736b047f90b2745" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_safety.get_safety_log: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_safety.py::register_route_backend_safety.apply_safety_review_update": { + "boundary": { + "sha256": "98c3a4551b5f56ee37dc6b9f6ada179e0fff459094b883df4e797b2beece9e6b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79d431364818117b84ac8810d30f0cfc8f79934901c0ab89d736b047f90b2745" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_safety.apply_safety_review_update: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_safety.py::register_route_backend_safety.update_my_safety_log": { + "boundary": { + "sha256": "9ddee90c4aeca29b679b39363ff339bf57a3c594b0c02491a6b3a6f9b1a3327d", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_safety_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "79d431364818117b84ac8810d30f0cfc8f79934901c0ab89d736b047f90b2745" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_safety.update_my_safety_log: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_users.py::_has_shared_document_profile_relationship": { + "boundary": { + "sha256": "2ce3fc862935814ebf6d1d0028cdeec20fb1ad7ff90a4f47550e4160de492e26", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3" + }, + "classification": "sdk-compatible", + "contract": "_has_shared_document_profile_relationship: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_users.py::_has_collaboration_profile_relationship": { + "boundary": { + "sha256": "7eb60bbca933fed959e0f812a220727b924946eaf355b9da9147aa8dac19479e", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_collaboration_user_state_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_collaboration_user_state_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3" + }, + "classification": "sdk-compatible", + "contract": "_has_collaboration_profile_relationship: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_users.py::_read_authorized_user_profile_document": { + "boundary": { + "sha256": "201caf9181199545783634b7f638fc3efeacdd9e8f07d408c902b8595f86bb38", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3" + }, + "classification": "sdk-compatible", + "contract": "_read_authorized_user_profile_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_users.py::register_route_backend_users.api_get_user_info": { + "boundary": { + "sha256": "b6027682ae3b7b3b8c0ffdda269ea18f19e2ed46c8b0dad51ea5f89d52a1c8e0", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_users.api_get_user_info: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_users.py::register_route_backend_users.api_collaboration_suggestions": { + "boundary": { + "sha256": "73abc50267e15ec0134f0862538bafa5ee4ca7ea8f04769443700f81da89d2d8", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3" + }, + "classification": "sdk-compatible", + "contract": "register_route_backend_users.api_collaboration_suggestions: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_workflows.py::_load_workflow_conversation": { + "boundary": { + "sha256": "6fb2ae3c4ba3ab91130c34c22411394e28ce70753efca09f3946334181d4bcfb", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f8ac00b74be6e30518a3941a09a76d2e0336fd38ece6d056ac0e124b6eca8e38" + }, + "classification": "sdk-compatible", + "contract": "_load_workflow_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_backend_workflows.py::_load_group_workflow_conversation": { + "boundary": { + "sha256": "49dd50eb7edc99ff086cd515db6c7d79d97fcf7a959286a93ee33098e1c4d8dd", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f8ac00b74be6e30518a3941a09a76d2e0336fd38ece6d056ac0e124b6eca8e38" + }, + "classification": "sdk-compatible", + "contract": "_load_group_workflow_conversation: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_enhanced_citations.py::_get_authorized_chat_artifact_message": { + "boundary": { + "sha256": "a2c6beb6142f515b82306165e8d8001995a4fad0f7a776d9f1d43c70c84c7614", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "read_item", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "e7c2b601ff10d30163c943231ff1f33043f237e89159ac46f68dcfbcbd139197" + }, + "classification": "sdk-compatible", + "contract": "_get_authorized_chat_artifact_message: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_enhanced_citations.py::register_enhanced_citations_routes.get_enhanced_citation_tabular": { + "boundary": { + "sha256": "5cf97a0cec09c4811369dd7c311d5aaf3f358e0dc96e8c7e82803ebc89bbc365", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "e7c2b601ff10d30163c943231ff1f33043f237e89159ac46f68dcfbcbd139197" + }, + "classification": "sdk-compatible", + "contract": "register_enhanced_citations_routes.get_enhanced_citation_tabular: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_external_public_documents.py::register_route_external_public_documents.external_get_public_documents": { + "boundary": { + "sha256": "fdba7f2d675b7e814bb2d2493aac2c09f7b219a9b12f767a212def8a8f21a7f0", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "231c4794f1288f2a86c0e7cf6a20ddd35f2ea0f728b59279646bb78dddc99ce0" + }, + "classification": "sdk-compatible", + "contract": "register_route_external_public_documents.external_get_public_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_chats.py::_build_new_chat_conversation": { + "boundary": { + "sha256": "3f1dc9d4206c9b17c73ddad4708bf92b1ec94a40d8b646201f05c34179fdd1a4", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8ebafa6d3ad84d52c1f94fefab84dd67ce8c270142c20114a1ed49b11369676f" + }, + "classification": "response-unused", + "contract": "_build_new_chat_conversation: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_frontend_chats.py::_resolve_chat_upload_context": { + "boundary": { + "sha256": "2438af0d0c512dd0c24b52828098eb62d04115bac98d9c083c375eeede97a372", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "8ebafa6d3ad84d52c1f94fefab84dd67ce8c270142c20114a1ed49b11369676f" + }, + "classification": "sdk-compatible", + "contract": "_resolve_chat_upload_context: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_chats.py::register_route_frontend_chats.upload_file": { + "boundary": { + "sha256": "a79f077ca278be1fb5772cfc856ccd668c53b162673f45d27bfb9684a2e0723e", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_messages_container", + "response": "unused" + }, + { + "method": "upsert_item", + "receiver": "cosmos_conversations_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "8ebafa6d3ad84d52c1f94fefab84dd67ce8c270142c20114a1ed49b11369676f" + }, + "classification": "response-unused", + "contract": "register_route_frontend_chats.upload_file: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/route_frontend_control_center.py::get_control_center_statistics": { + "boundary": { + "sha256": "d0f2fe9b8db61ebf4ea8f4487d3d6fd99e4d9135bf0f6d60f271ab216c059652", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_groups_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_public_workspaces_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_user_settings_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "864a0ff0422bfeb363581dbcc416f66a569fe93b587062d59f58f03fc75ba814" + }, + "classification": "sdk-compatible", + "contract": "get_control_center_statistics: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_conversations.py::_authorize_frontend_personal_conversation_access": { + "boundary": { + "sha256": "d9c4ad68ff896cb16581ad73fd5a718ce68cd399a3e9b7013ce76da1aa76deee", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b" + }, + "classification": "sdk-compatible", + "contract": "_authorize_frontend_personal_conversation_access: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.conversations": { + "boundary": { + "sha256": "26806b7d6a411cd80252ba95f8682ddb44b4ffa1f965e50f3263309d25d42612", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b" + }, + "classification": "sdk-compatible", + "contract": "register_route_frontend_conversations.conversations: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.view_conversation": { + "boundary": { + "sha256": "d86c4dd32514a5ed089b4bb14cc361a6b5272f3732c045c3028304fd78db1da6", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b" + }, + "classification": "sdk-compatible", + "contract": "register_route_frontend_conversations.view_conversation: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_conversation_messages": { + "boundary": { + "sha256": "6b1cfcc1271fdcd83c47a2485dd848ec2514b85510c79189e15440158af4da1e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b" + }, + "classification": "sdk-compatible", + "contract": "register_route_frontend_conversations.get_conversation_messages: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_agent_citation_artifact": { + "boundary": { + "sha256": "fd8501eec03eaa48a3decb39bfe0249ba8012efb668a4a2d40e9bbe13d4d517b", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b" + }, + "classification": "sdk-compatible", + "contract": "register_route_frontend_conversations.get_agent_citation_artifact: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_message_metadata": { + "boundary": { + "sha256": "bc31ff8688128bcc8cbd9b17865c94c68471da69bed27ee9f60a6bb685162c21", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_messages_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b" + }, + "classification": "sdk-compatible", + "contract": "register_route_frontend_conversations.get_message_metadata: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_group_workspaces.py::register_route_frontend_group_workspaces.group_workspaces": { + "boundary": { + "sha256": "df494ec94b71d6290e3e55d9523b70c1614d3753aa16128c9c345601286dbaeb", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f7369403bb7f46bac2309d90cdca5f4b125c4ab5670bdbb22d69781328efe190" + }, + "classification": "sdk-compatible", + "contract": "register_route_frontend_group_workspaces.group_workspaces: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_profile.py::register_route_frontend_profile.get_user_activity_trends": { + "boundary": { + "sha256": "a17ce8a02c0093e8e4661101d61925940228be61197fb8a68d05adbe01c4bcac", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_activity_logs_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "161a5f6125e8df58457902de3693d4715a4cd75c5848b0bd04703a20c3611fc5" + }, + "classification": "sdk-compatible", + "contract": "register_route_frontend_profile.get_user_activity_trends: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/route_frontend_workspace.py::register_route_frontend_workspace.workspace": { + "boundary": { + "sha256": "252b880849f4eca48d35d608cdf8949d4f2912dae6886081d869ffebb59a07e1", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "59c173e6664096002e14ab63cb014657beff1b4ad645a59c2731ed4d005b2a3e" + }, + "classification": "sdk-compatible", + "contract": "register_route_frontend_workspace.workspace: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore._persist": { + "boundary": { + "sha256": "a3524c7630031b3943be9a396b941644bb88b8ec4a6f876ad88da89c24ab04d5", + "points": [ + { + "method": "upsert_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f61903cd0a5097c6d55bf00f74d282d4ccb50c4f669e0ff0e91b434044d2e83" + }, + "classification": "sdk-compatible", + "contract": "FactMemoryStore._persist: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore.get_fact_item": { + "boundary": { + "sha256": "6de40ea727242a1edf76614ae2c486471999e1ffa911625a713fe9892b26c2fd", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f61903cd0a5097c6d55bf00f74d282d4ccb50c4f669e0ff0e91b434044d2e83" + }, + "classification": "sdk-compatible", + "contract": "FactMemoryStore.get_fact_item: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore.get_facts": { + "boundary": { + "sha256": "7d59076553f20ffec29f304389266b9dd78e2598371a924e723921037498d63b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "2f61903cd0a5097c6d55bf00f74d282d4ccb50c4f669e0ff0e91b434044d2e83" + }, + "classification": "sdk-compatible", + "contract": "FactMemoryStore.get_facts: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore.delete_fact": { + "boundary": { + "sha256": "9bc27d2a241e5ae26219ccd994401d6d97024b2fe329ca337af5f8d1ec339054", + "points": [ + { + "method": "delete_item", + "receiver": "self.container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "2f61903cd0a5097c6d55bf00f74d282d4ccb50c4f669e0ff0e91b434044d2e83" + }, + "classification": "response-unused", + "contract": "FactMemoryStore.delete_fact: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/utils_cache.py::get_personal_document_fingerprint": { + "boundary": { + "sha256": "5647c9d5d5d1efae638101c8ca5c19afd679d45142fa956439e1c93d499c487e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_user_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "sdk-compatible", + "contract": "get_personal_document_fingerprint: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/utils_cache.py::get_group_document_fingerprint": { + "boundary": { + "sha256": "536dfddf8eb50f846e78470bdc4a173b8dd4f778aba1aee2558275362210874b", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_group_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "sdk-compatible", + "contract": "get_group_document_fingerprint: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/utils_cache.py::get_public_workspace_document_fingerprint": { + "boundary": { + "sha256": "aaba8c78008218a435aff3ec2ff23cabdbf0f612b1e770667da014f308ffddff", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_public_documents_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "sdk-compatible", + "contract": "get_public_workspace_document_fingerprint: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/utils_cache.py::get_cached_search_results": { + "boundary": { + "sha256": "80b63ef3af4223d6139bb8fff311cffc91bb7261975805d932df532de7995fb1", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_search_cache_container", + "response": "consumed" + }, + { + "method": "delete_item", + "receiver": "cosmos_search_cache_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "sdk-compatible", + "contract": "get_cached_search_results: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/utils_cache.py::cache_search_results": { + "boundary": { + "sha256": "e0bea415bb25d9e413933836bad689855f300afbfb3b737573a6a83a9a755ed9", + "points": [ + { + "method": "upsert_item", + "receiver": "cosmos_search_cache_container", + "response": "unused" + } + ], + "queries": [], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "response-unused", + "contract": "cache_search_results: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/utils_cache.py::invalidate_personal_search_cache": { + "boundary": { + "sha256": "640fb227f4ada1ce231054ac051821f19644750d1732c487b6b1f72fc747b534", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_search_cache_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_search_cache_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "response-unused", + "contract": "invalidate_personal_search_cache: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/utils_cache.py::invalidate_group_search_cache": { + "boundary": { + "sha256": "924249f36ec69838c619236863eaa58be0ec8d85bfbb33cddf04277474c08120", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_search_cache_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_search_cache_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "response-unused", + "contract": "invalidate_group_search_cache: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/utils_cache.py::invalidate_public_workspace_search_cache": { + "boundary": { + "sha256": "910d82c2509bc6225fb3aa79e7f1569a8120c2a493dc042e907ca77e6f405ca9", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_search_cache_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_search_cache_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "response-unused", + "contract": "invalidate_public_workspace_search_cache: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/utils_cache.py::clear_all_cache": { + "boundary": { + "sha256": "2d480cd473567de1c6722897f222bf834e3bd6ff643a801ba87b1a57c97a5b52", + "points": [ + { + "method": "delete_item", + "receiver": "cosmos_search_cache_container", + "response": "unused" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_search_cache_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "response-unused", + "contract": "clear_all_cache: point response values are discarded; query rows, if present, are separate plain SDK JSON. Existing write errors remain visible.", + "evidence_scope": "source-review", + "tests": [] + }, + "application/single_app/utils_cache.py::get_cache_stats": { + "boundary": { + "sha256": "8495173e96b69b24ca0e34fcdeaf530646dab6d27a463bf3ce546aafb2490d0e", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "cosmos_search_cache_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "cosmos_search_cache_container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "82a9a57c7069bebddfb58bd6ee31ae40b45d43d36b95c147216d61ef93320878" + }, + "classification": "sdk-compatible", + "contract": "get_cache_stats: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/access.py::_read_authorized_document": { + "boundary": { + "sha256": "0b545f2bf156b4f4860ddd8b77a7a60554c17026d588b4af92b5c87aefec36c8", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1c874e4ce78f1d94776fc440d9d6674a335c05b3c1a4d083bd0943b0847ef27" + }, + "classification": "sdk-compatible", + "contract": "_read_authorized_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/access.py::_require_release_proof": { + "boundary": { + "sha256": "1cbd0ff38c1cdcd6353301290fd2a250bfed8bf47a0e2010d807e026ea2175ac", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "f1c874e4ce78f1d94776fc440d9d6674a335c05b3c1a4d083bd0943b0847ef27" + }, + "classification": "sdk-compatible", + "contract": "_require_release_proof: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/access.py::_resolve_native_evidence": { + "boundary": { + "sha256": "9a46a09b083878472b91bf88c5dedad1a4e20565ce8d66c8e7e4d5bf348adfe7", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "getattr(config, container_name)", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1c874e4ce78f1d94776fc440d9d6674a335c05b3c1a4d083bd0943b0847ef27" + }, + "classification": "sdk-compatible", + "contract": "_resolve_native_evidence: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/access.py::_resolve_blob_document": { + "boundary": { + "sha256": "3026211e6cfee0a15cc79790ad5a6d931b000dbaf6741e339a08d69f7a18cc3c", + "points": [ + { + "method": "read_item", + "receiver": "config.cosmos_conversations_container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "config.cosmos_messages_container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "f1c874e4ce78f1d94776fc440d9d6674a335c05b3c1a4d083bd0943b0847ef27" + }, + "classification": "sdk-compatible", + "contract": "_resolve_blob_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/model.py::_resolve_settings": { + "boundary": { + "sha256": "ee0774d0a9d6b22f2f39503b1f9a905ce5cadae3ca01159ebe344ec3821f8af1", + "points": [ + { + "method": "read_item", + "receiver": "cosmos_settings_container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0753ee6a859407c3479383b007b2f59f50ebad5902d4f8c9c8349795f44764cd" + }, + "classification": "sdk-compatible", + "contract": "_resolve_settings: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/repository.py::_read_page": { + "boundary": { + "sha256": "8eb3ea6d318a228d144499e0ae860048b29b575b77b9311c732baa878fa05cc5", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278" + }, + "classification": "sdk-compatible", + "contract": "_read_page: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/repository.py::ScreeningRepository.get": { + "boundary": { + "sha256": "ad6769e0f5acae4ddca09f65adee24bc38445b5ad25c26a343054c74d47e5ee2", + "points": [ + { + "method": "read_item", + "receiver": "self.container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278" + }, + "classification": "sdk-compatible", + "contract": "ScreeningRepository.get: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/repository.py::ScreeningRepository.create": { + "boundary": { + "sha256": "3d89633464263004b1e4731d6f25e3344eeaaf5f6aff9a0915ab2cf4419fdacf", + "points": [ + { + "method": "create_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278" + }, + "classification": "sdk-compatible", + "contract": "ScreeningRepository.create: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/repository.py::ScreeningRepository.replace": { + "boundary": { + "sha256": "8c6747d482d4d5fa4c3cc15b489cea95f1014b1f21f4f68b9f79260374e9b0d3", + "points": [ + { + "method": "replace_item", + "receiver": "self.container", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278" + }, + "classification": "sdk-compatible", + "contract": "ScreeningRepository.replace: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/repository.py::ScreeningRepository.count": { + "boundary": { + "sha256": "d0530e1cdbccdc9ee1e8e616e5ddce014222d33c6f59e8bc1dc161fbccb18c54", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "self.container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278" + }, + "classification": "sdk-compatible", + "contract": "ScreeningRepository.count: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/repository.py::ScreeningRepository.read_document": { + "boundary": { + "sha256": "23fe4d666c1b7dab21443083c78b504edf24390c168632ce1aac634f8fc8dae3", + "points": [ + { + "method": "read_item", + "receiver": "self.document_container(subject.scope_type)", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278" + }, + "classification": "sdk-compatible", + "contract": "ScreeningRepository.read_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/content_screening/repository.py::ScreeningRepository.update_document": { + "boundary": { + "sha256": "4ce03bb70596c2f36b9dceb56d3549ca172da87c21185c90f6330e478657f97a", + "points": [ + { + "method": "replace_item", + "receiver": "self.document_container(subject.scope_type)", + "response": "returned" + } + ], + "queries": [], + "batches": [], + "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278" + }, + "classification": "sdk-compatible", + "contract": "ScreeningRepository.update_document: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "application/single_app/semantic_kernel_plugins/cosmos_query_plugin.py::CosmosQueryPlugin.execute_query": { + "boundary": { + "sha256": "14c58ba4a36ef80c1f8db6ee380dc4090a3166b8e8955e49bca991d045720e29", + "points": [], + "queries": [ + { + "method": "query_items", + "receiver": "container_client", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "d6687c31fc3a3c06b0e3b702c0019a3e5347a24d58eec7942aa065d1d6fb10fa" + }, + "classification": "sdk-compatible", + "contract": "CosmosQueryPlugin.execute_query: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "scripts/resolve_multiendpoint_gpt.py::fetch_settings_from_cosmos": { + "boundary": { + "sha256": "1316e67af6b71fd1e58b331d10db9d2089d7b2074062647cd91b129f9b23e2a3", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [ + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + }, + { + "method": "query_items", + "receiver": "container", + "response": "consumed" + } + ], + "batches": [], + "module_sha256": "37e530aacf76fe8238effe061af6a7af13ea166a671682358f1f087128d68564" + }, + "classification": "sdk-compatible", + "contract": "fetch_settings_from_cosmos: point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + }, + "deployers/bicep/postconfig.py::": { + "boundary": { + "sha256": "0bb24e992842febe1d3f6728ae9fb93afaaa94a541df12e40f6b19d8de429d28", + "points": [ + { + "method": "read_item", + "receiver": "container", + "response": "consumed" + } + ], + "queries": [], + "batches": [], + "module_sha256": "0bb24e992842febe1d3f6728ae9fb93afaaa94a541df12e40f6b19d8de429d28" + }, + "classification": "sdk-compatible", + "contract": ": point documents use Mapping field reads/JSON encoding/metadata projections; batch status/body lists are separate, never top-level-normalized as documents. Strict domain sinks remain with their storage owners.", + "evidence_scope": "sdk-api-and-source-review", + "tests": [ + "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + ] + } + }, + "doubles": { + "functional_tests/test_agent_delegation_entrypoints.py::test_actual_stream_stop_finalizer_persists_completed_child_sources_and_usage::point-seam-1": { + "boundary": { + "sha256": "e3e0a36ba35b8093999d1f708d2e909bedde133b0bac6a07c38e7c2c4fa50720", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "c6f70b20f6fb3a9392ffc15cd28a1d6a924a780c90c896dac7a227a01dd4b24f" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_agent_delegation_entrypoints.py" + ] + }, + "functional_tests/test_agent_delegation_entrypoints.py::test_actual_stream_stop_finalizer_persists_completed_child_sources_and_usage::point-seam-2": { + "boundary": { + "sha256": "7b7726438b5811ff6c165186fb27536df6266288d4db3348459d6652abfe3f79", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "c6f70b20f6fb3a9392ffc15cd28a1d6a924a780c90c896dac7a227a01dd4b24f" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_agent_delegation_entrypoints.py" + ] + }, + "functional_tests/test_ai_connection_embedding_migration.py::MigrationRuntime.__init__::point-seam-1": { + "boundary": { + "sha256": "05bb4a21b55f2274ded0e0e073034747efd7404fdf5316cc5d171643e4221876", + "methods": [ + "read_item", + "replace_item" + ], + "kind": "seam", + "imports_sha256": "aa19387acd0e45a2c110fe7fac9ed8ed63184e05288090808ae073dd23e7aeeb" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_ai_connection_embedding_migration.py" + ] + }, + "functional_tests/test_ai_connection_embedding_migration.py::MigrationRuntime.installed::point-seam-1": { + "boundary": { + "sha256": "05bb4a21b55f2274ded0e0e073034747efd7404fdf5316cc5d171643e4221876", + "methods": [ + "read_item", + "replace_item" + ], + "kind": "seam", + "imports_sha256": "aa19387acd0e45a2c110fe7fac9ed8ed63184e05288090808ae073dd23e7aeeb" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_ai_connection_embedding_migration.py" + ] + }, + "functional_tests/test_analysis_answer_and_export_data.py::test_workflow_explanation_exports_keep_the_original_source_restrictions::point-seam-1": { + "boundary": { + "sha256": "fb589a1ce6c51f6351d310e5344812ce2a174e11b9fbb085b5223c9b27109ff2", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "961625a668fb2c09e0a8c08ff17fd44bfaa8ae8dfa7e42a980bfc226342fbbe3" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analysis_answer_and_export_data.py" + ] + }, + "functional_tests/test_analysis_answer_and_export_data.py::test_workflow_explanation_exports_keep_the_original_source_restrictions::point-seam-2": { + "boundary": { + "sha256": "fb589a1ce6c51f6351d310e5344812ce2a174e11b9fbb085b5223c9b27109ff2", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "961625a668fb2c09e0a8c08ff17fd44bfaa8ae8dfa7e42a980bfc226342fbbe3" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analysis_answer_and_export_data.py" + ] + }, + "functional_tests/test_analysis_artifact_publication.py::MemoryContainer": { + "boundary": { + "sha256": "02b8d14bba4e33ed27d612295bcd840172c7c5761c9ee38000d74bf1c84d6ecc", + "methods": [ + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b2bee56464274703f7e48cf3866a2fd222524e3d376715d5800caf01a1f82eed" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_analysis_artifact_publication.py" + ] + }, + "functional_tests/test_analysis_artifact_publication.py::test_upload_digest_binds_idempotent_streams_to_actual_bytes_and_producer.Messages": { + "boundary": { + "sha256": "8c0f0ae85223251b4253b0473ee463ac9a20f1872eba81c2ea27ab3f293d26ef", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b2bee56464274703f7e48cf3866a2fd222524e3d376715d5800caf01a1f82eed" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_analysis_artifact_publication.py" + ] + }, + "functional_tests/test_analysis_artifact_publication.py::test_upload_digest_binds_idempotent_streams_to_actual_bytes_and_producer::point-seam-1": { + "boundary": { + "sha256": "b0ad08ddd0b13d8f63f6e75084f0aec1c5d2f0e20a1304805d0a792f40ba964a", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "b2bee56464274703f7e48cf3866a2fd222524e3d376715d5800caf01a1f82eed" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analysis_artifact_publication.py" + ] + }, + "functional_tests/test_analysis_result_store.py::ChatAnalysisResultStoreTests.test_cleanup_tolerates_objects_disappearing_during_conditional_deletion::point-seam-1": { + "boundary": { + "sha256": "20ba34b2909f5d28ffe593c274e267fe1efd1e681ebcc5c6b49c32fb0f5acc90", + "methods": [ + "delete_item" + ], + "kind": "seam", + "imports_sha256": "58f8293350c3be2e466e6ade0d130c017f38eacfbb21b50cc32953ad786a61cc" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analysis_result_store.py" + ] + }, + "functional_tests/test_analysis_unavailable_message_families.py::test_former_bare_raises_name_the_container_that_failed::point-seam-1": { + "boundary": { + "sha256": "9755b148463f42ec88f59ddadd36f81f8faeb8e2c69b7de5edf1fae754c0c462", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "921977db01f354bbc5bec922a32d8efe61255413cbf1610bd60eb943ccf03aac" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analysis_unavailable_message_families.py" + ] + }, + "functional_tests/test_analysis_unavailable_message_families.py::test_former_bare_raises_name_the_container_that_failed::point-seam-2": { + "boundary": { + "sha256": "1c3e9e0860d18c848c15b12fe91f66830b8b1c2759b73a16942647040682b1cc", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "921977db01f354bbc5bec922a32d8efe61255413cbf1610bd60eb943ccf03aac" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analysis_unavailable_message_families.py" + ] + }, + "functional_tests/test_analyze_backend_saved_integration.py::MessageStore": { + "boundary": { + "sha256": "ba224936d2f9c87d6cd6aabe228e8d0c141491602c09fff2cc100cabc9465743", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2cc597c86bbe58da4c04c65c66484b1ef45ac65e6f21d26b7ba00f7dfc74e3a8" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_analyze_backend_saved_integration.py" + ] + }, + "functional_tests/test_analyze_backend_saved_integration.py::chat::point-seam-1": { + "boundary": { + "sha256": "4a48d15a44e25c7338da8de520ed4cecd3858059bbad30a07dd893a592df2db1", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "2cc597c86bbe58da4c04c65c66484b1ef45ac65e6f21d26b7ba00f7dfc74e3a8" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analyze_backend_saved_integration.py" + ] + }, + "functional_tests/test_analyze_backend_saved_integration.py::test_direct_analyze_persists_one_assistant_inside_the_merged_guards::point-seam-1": { + "boundary": { + "sha256": "8d8e38b93d2a588e2274db108e90d7e276301403fff2dfc40831696ce4ce44a7", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "2cc597c86bbe58da4c04c65c66484b1ef45ac65e6f21d26b7ba00f7dfc74e3a8" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analyze_backend_saved_integration.py" + ] + }, + "functional_tests/test_analyze_live_write_fences.py::test_stop_between_guard_read_and_payload_batch_is_conditional::point-seam-1": { + "boundary": { + "sha256": "c6da310aeae94a86a8eaaf0c59fa9c56d1fac638c076bfb47aba5be94caf7718", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analyze_live_write_fences.py" + ] + }, + "functional_tests/test_analyze_live_write_fences.py::test_user_turn_retry_association_is_conditional_and_actor_bound::point-seam-1": { + "boundary": { + "sha256": "0b12bf18a89efed4322432076349135a3044ab90a6a8bee1084bb33c83911519", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analyze_live_write_fences.py" + ] + }, + "functional_tests/test_analyze_live_write_fences.py::test_cached_conversation_update_cannot_erase_a_racing_deletion_marker::point-seam-1": { + "boundary": { + "sha256": "06b1ca512cd2613e10dcabb8fe392462c4a1d6954f59398f6495ab7623eb4cc0", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analyze_live_write_fences.py" + ] + }, + "functional_tests/test_analyze_live_write_fences.py::test_deleted_followup_turn_cannot_publish_a_late_explanation::point-seam-1": { + "boundary": { + "sha256": "720b3db2b9a0b587f737283fe835846b8ac13d6742bdb8516984038c74995206", + "methods": [ + "delete_item" + ], + "kind": "seam", + "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analyze_live_write_fences.py" + ] + }, + "functional_tests/test_analyze_live_write_fences.py::test_deleted_followup_turn_cannot_publish_a_late_explanation::point-seam-2": { + "boundary": { + "sha256": "e8e410ae2dcf0a383212c66070d73c01aaad5f7267fbd60a494fa3ab7ccb1e86", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_analyze_live_write_fences.py" + ] + }, + "functional_tests/test_app_settings_embedding_write_guard.py::test_guard_covers_cas_and_shared_publication::point-seam-1": { + "boundary": { + "sha256": "4122ca217ffb775c67d9830829e934175b32f8f1e1c2a188c2c5721e0e2e6ccb", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "3552d865b4ba560436058e86bcc1046123d6e88227bfda938ca643739710be2e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_app_settings_embedding_write_guard.py" + ] + }, + "functional_tests/test_app_settings_import_boundaries.py::embedded-BOOTSTRAP_PROBE::Container": { + "boundary": { + "sha256": "ebbde58700931bdeb95e344bdf8030e4f996665a5c89880c7fb9d8a4cf9643a3", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "5d7607d00227de444f1b96c124f2e08824c04641e25c293b045f57fa0a9b8741", + "embedded_source_sha256": "18937bdc7fb9a63dd52b3e6ceba1048289c8c41b2d5ebdf74f6320e0939776d0" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_app_settings_import_boundaries.py" + ] + }, + "functional_tests/test_app_settings_store_consistency.py::FakeCosmos": { + "boundary": { + "sha256": "4f5de21abf8aabbf5deec4e2439a8a4e396be30306eaaeb074c2d008d8e8d4de", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "bb763bdfe08cb3d88be9ce9693bcf0fa1a678501a70c304ccf1af8c8a8e34fe9" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_app_settings_store_consistency.py" + ] + }, + "functional_tests/test_approval_notification_routing_fix.py::FakeNotificationContainer": { + "boundary": { + "sha256": "80ea1aa9cbbda01072f8233283de92d3795b66e604647b635966cff34ae238ad", + "methods": [ + "create_item", + "delete_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b84eacfda6d9cef33ff56945a3bcd2aabc764a8b7841c7dc5b6ae0469f6dcf7f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_approval_notification_routing_fix.py" + ] + }, + "functional_tests/test_approval_notification_routing_fix.py::FakeApprovalsContainer": { + "boundary": { + "sha256": "57f85161ce13bc8217d7dafd26c6f1fa2cedc749bbb6298deb6fdbcae6a00054", + "methods": [ + "create_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b84eacfda6d9cef33ff56945a3bcd2aabc764a8b7841c7dc5b6ae0469f6dcf7f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_approval_notification_routing_fix.py" + ] + }, + "functional_tests/test_approval_notification_routing_fix.py::FakeTemplateContainer": { + "boundary": { + "sha256": "5be2324ac9a6fb293441736b080efd98107df7cf819acb0761b7836f2e434f82", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b84eacfda6d9cef33ff56945a3bcd2aabc764a8b7841c7dc5b6ae0469f6dcf7f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_approval_notification_routing_fix.py" + ] + }, + "functional_tests/test_approval_notification_routing_fix.py::FakeActivityLogsContainer": { + "boundary": { + "sha256": "06d297c76039334bd2adf624ac90b8fcc7d0b8d9fdb91e40e44c0907f668159b", + "methods": [ + "create_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b84eacfda6d9cef33ff56945a3bcd2aabc764a8b7841c7dc5b6ae0469f6dcf7f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_approval_notification_routing_fix.py" + ] + }, + "functional_tests/test_authenticated_request_login_activity.py::FakeContainer": { + "boundary": { + "sha256": "84bc5b272353ee11d453c834f8b72b462807ae8786461f9f1fa099b18b50868e", + "methods": [ + "create_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3ed7624a4d63e0906e428793cad7fc762b2a01d14c1ef210ae8c19447262ff1f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_authenticated_request_login_activity.py" + ] + }, + "functional_tests/test_broken_access_control_findings_fix.py::FakeConversationContainer": { + "boundary": { + "sha256": "12a4cfd9fbeaf69cf210806637d5950a885570d6edc0d986e3c85689f9400f30", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f97ceaaa05b0f633db9bb614191f973bb8faf8322e9ab2cd639bc227848f79cb" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_broken_access_control_findings_fix.py" + ] + }, + "functional_tests/test_chat_activity_logging_consistency.py::FakeCreateItemContainer": { + "boundary": { + "sha256": "af6fe12d5c2c650b8bddf8f780e810f45eba847d3589f645704c8a6c16777533", + "methods": [ + "create_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "fec79c76b8b8d19ff06c115f0cdffa0e78f730c7a0fdedabdf35bd1d9a802651" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_activity_logging_consistency.py" + ] + }, + "functional_tests/test_chat_activity_logging_consistency.py::FakeUpsertContainer": { + "boundary": { + "sha256": "3d07d4b5fa2bfacff8394ce503e73406bafe6b9c381ff7f9c6e74e636a422868", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "fec79c76b8b8d19ff06c115f0cdffa0e78f730c7a0fdedabdf35bd1d9a802651" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_activity_logging_consistency.py" + ] + }, + "functional_tests/test_chat_artifact_download_bytes.py::SnapshotContainer": { + "boundary": { + "sha256": "b88da2c7be88197616f1c1c6c33140a27a64dbf6100d97c1ea37692b2bb9b67a", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "081bd1a8c570e7a3704106db0b3cf9fdcad9ac6e33c84f42662e4a34a232133e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_artifact_download_bytes.py" + ] + }, + "functional_tests/test_chat_completion_notifications.py::FakeConversationContainer": { + "boundary": { + "sha256": "068a24534d52e96bd7acb95c6627827537ba2af11df26665ad5b56a0bee55646", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f2ffd1bb87a6a55b45b8a4a51a35da2d49d9e68c5b1ecccbe869a331a984ddfb" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_completion_notifications.py" + ] + }, + "functional_tests/test_chat_completion_notifications.py::FakeNotificationContainer": { + "boundary": { + "sha256": "8180c7e62c96d63f340781917d8e92974d170485a4def27397920f3dea1fa3ea", + "methods": [ + "create_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f2ffd1bb87a6a55b45b8a4a51a35da2d49d9e68c5b1ecccbe869a331a984ddfb" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_completion_notifications.py" + ] + }, + "functional_tests/test_chat_content_review.py::MemoryContainer": { + "boundary": { + "sha256": "9f3c1f4cf9d89382cb81b72607e98dfc14e8aeb087acce36aa2f892694671760", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "fe92ff542fcfef00aeb73007c07492571ce7d532d3ff1203f4945e4a7ce61742" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_content_review.py" + ] + }, + "functional_tests/test_chat_retry_attempt_lifecycle.py::AttemptContainer": { + "boundary": { + "sha256": "b6dc5887981e863f45cc7d2c14575fa6cf817eb4ef0becd49a79e06075a94e14", + "methods": [ + "create_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "d79f3089ee119b3090c118dcd4a147cbf937a221a0169f47a2d9db2b7db6feae" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_retry_attempt_lifecycle.py" + ] + }, + "functional_tests/test_chat_retry_import_boundaries.py::embedded-EARLY_PROBE::Store": { + "boundary": { + "sha256": "a43ae348daab1439d8ba944ceb7f43234cb14995c0601124f3a6343d83020da8", + "methods": [ + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2aad9254c24a9d1a43390bef7aad3a73dc02e5ad9d004d01db54fe6e6d2ea3ce", + "embedded_source_sha256": "9d508b48960fb173104836cc6eabcea7ce919fdffe73187d03a52afcf0d674a0" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_retry_import_boundaries.py" + ] + }, + "functional_tests/test_chat_soft_deleted_message_visibility_fix.py::FakeContainer": { + "boundary": { + "sha256": "ed4179ce1741552c67053fde5a85a7884294c04cc1fcf6e6774d517c8436dc6b", + "methods": [ + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "e1feacfe578c5d6865f7db5a95d5d690b3d8e0e0a1dee57a0c489d6a112cd535" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chat_soft_deleted_message_visibility_fix.py" + ] + }, + "functional_tests/test_chats_user_settings_hardening_fix.py::FakeContainer": { + "boundary": { + "sha256": "8bac7795ceca120f440f8ad50adcaddbfd7b66bf432986c2468f3802fad6a807", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "0ea9b5e92c69e14a31f1d7d2ac12522a19585e6469c06352edddce0b09822670" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_chats_user_settings_hardening_fix.py" + ] + }, + "functional_tests/test_collaboration_conversation_summary_export_fix.py::FailingLegacyConversationContainer": { + "boundary": { + "sha256": "bf54b68678d7c9c3a9643a8f4dc2119cb6e4a40277326bd8f22921d8bad3012a", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c833900e2f24aad948933f18f6b938a0c5f806dafeada4f4e1174585c724d3f9" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_conversation_summary_export_fix.py" + ] + }, + "functional_tests/test_collaboration_conversation_summary_export_fix.py::FakeCollaborationConversationContainer": { + "boundary": { + "sha256": "a8a8acf7dfa56b647b960ae317b6711433d335913cde8b3eee081b966ade78da", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c833900e2f24aad948933f18f6b938a0c5f806dafeada4f4e1174585c724d3f9" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_conversation_summary_export_fix.py" + ] + }, + "functional_tests/test_collaboration_group_agent_stream_fix.py::FakeItemContainer": { + "boundary": { + "sha256": "e01c9508802ce3a8f0ce50244898c7a15aa7b27529acfdbdc610742203ff2782", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3a237bd7086828db841a6d42369120b12e07eed263965f09ac5bb3c46b97cb1e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_group_agent_stream_fix.py" + ] + }, + "functional_tests/test_collaboration_group_agent_stream_fix.py::FakeConversationContainer": { + "boundary": { + "sha256": "70685f738d190cbba9104c9a9b5809d00b4bd1c5b54658af26262d5a0d82ac1a", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3a237bd7086828db841a6d42369120b12e07eed263965f09ac5bb3c46b97cb1e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_group_agent_stream_fix.py" + ] + }, + "functional_tests/test_collaboration_message_delete_fix.py::FakeCollaborationMessageContainer": { + "boundary": { + "sha256": "a6b39b3acbe8fcaa3cf81b1f0d136301c7dfa4cab007e306d099dd2d23f01292", + "methods": [ + "delete_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "688c03c398ff84c5c57263cc3ea4eed9ed2c7b97aa8124a619b93fe18bff95ee" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_message_delete_fix.py" + ] + }, + "functional_tests/test_collaboration_message_delete_fix.py::FakeConversationContainer": { + "boundary": { + "sha256": "e1dabc2fb3875f43ba2d00f6d88957a577acc41132fbb6f6dc6030ab4b4c54dc", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "688c03c398ff84c5c57263cc3ea4eed9ed2c7b97aa8124a619b93fe18bff95ee" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_message_delete_fix.py" + ] + }, + "functional_tests/test_collaboration_message_notifications.py::FakeNotificationContainer": { + "boundary": { + "sha256": "9ecc3f7d7efacf11c4a45a20482e0fa818e11964289ff354af8b123e7aff4071", + "methods": [ + "create_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "fb887b17ebf65dc427c928b051c1d42b2ae12d5f826b2a811e601c02fb66e229" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_message_notifications.py" + ] + }, + "functional_tests/test_collaboration_message_notifications.py::FakeConversationContainer": { + "boundary": { + "sha256": "3104cd803a5b90841b73932d1e2baacfe0bf755c8ca526a1d0640d6c198175ce", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "fb887b17ebf65dc427c928b051c1d42b2ae12d5f826b2a811e601c02fb66e229" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_message_notifications.py" + ] + }, + "functional_tests/test_collaboration_stream_image_completion_fix.py::FakeItemContainer": { + "boundary": { + "sha256": "e01c9508802ce3a8f0ce50244898c7a15aa7b27529acfdbdc610742203ff2782", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3a237bd7086828db841a6d42369120b12e07eed263965f09ac5bb3c46b97cb1e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_stream_image_completion_fix.py" + ] + }, + "functional_tests/test_collaboration_stream_image_completion_fix.py::FakeConversationContainer": { + "boundary": { + "sha256": "70685f738d190cbba9104c9a9b5809d00b4bd1c5b54658af26262d5a0d82ac1a", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3a237bd7086828db841a6d42369120b12e07eed263965f09ac5bb3c46b97cb1e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_collaboration_stream_image_completion_fix.py" + ] + }, + "functional_tests/test_content_screening_access.py::FakeContainer": { + "boundary": { + "sha256": "5ba63f06185fb56fa377eb078a3478fc31c0289a5a12ab5b7b41f63e031c8384", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "30d6c8687ccfa555b47e656a8c240f0e5518b1c222389a109ef93f379361097e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_content_screening_access.py" + ] + }, + "functional_tests/test_content_screening_activity.py::ActivityContainer": { + "boundary": { + "sha256": "65c9acb818b67d365d41d2a396813abea4c8a05066e5073e1ee00e3f98c96b48", + "methods": [ + "create_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "591beb432249aedadfb914c9d37a6d76e57c4dbebbe6dfce69787af020bd61c1" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_content_screening_activity.py" + ] + }, + "functional_tests/test_content_screening_model.py::ModelScreeningTests.setUp::point-seam-1": { + "boundary": { + "sha256": "9b6aa36423851ac524cf7db0c9b0023d27a2031de4c7ce4e9365f7b94af6a685", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "a9f2d8670bcf84373644251a2d0a6db96e31fc495c2eb82ac60ca5f10423696b" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_content_screening_model.py" + ] + }, + "functional_tests/test_content_screening_persistence.py::FakeCosmos": { + "boundary": { + "sha256": "1a5528339036dba9e842e25188bd085759fdc802a975529c7562c3c85cd0a653", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "52228234e84d23a77c019f61b6263d59b7b367fc06a20163d206bf6c4ad6ab68" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_content_screening_persistence.py" + ] + }, + "functional_tests/test_content_screening_persistence_lifecycle.py::TransferCosmos": { + "boundary": { + "sha256": "5b416912a717acdd28ee3f0c4ceafde6a5e14a77ebd7130b23b5e3d063883b62", + "methods": [ + "create_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "a3954f2a795d5d814a3a00c772435ceabcd7063134754049b37d90a7afe33348" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_content_screening_persistence_lifecycle.py" + ] + }, + "functional_tests/test_content_screening_settings_api.py::ScreeningApiTests.setUp::point-seam-1": { + "boundary": { + "sha256": "ebf33e52af67942a3151386be88cf0be0a4c926af81fdf91a31441095e129f23", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "b86279d8962a19604def30220a0c600e8c8b634f3eed6f09cec757441b231e22" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_content_screening_settings_api.py" + ] + }, + "functional_tests/test_content_screening_upload_only_intake.py::ScanStore": { + "boundary": { + "sha256": "d03d7ea9aa47de5248998d4492c518f34d911f993b2fdda366cfe5d2e734e5c9", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8f0947601931ac3e8a20dd7b62d5fbcb029a86ed24240f98e06a15757f1820a5" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_content_screening_upload_only_intake.py" + ] + }, + "functional_tests/test_control_center_group_writers.py::after_first_read::point-seam-1": { + "boundary": { + "sha256": "a0d566c18636c32ec440ab615ec4cae01fd6a216842cd7e0c98d6884a5b10d7d", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "9342c945afcecc5f164655f5d751b5bc850ea337f16ac2dc2a6c98c355a2723c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_control_center_group_writers.py" + ] + }, + "functional_tests/test_conversation_fork.py::FakeConversationContainer": { + "boundary": { + "sha256": "d123c8a1d6cb318097112417f47f520bffb9a2232c385f7e4d05ea92e41b9bfa", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "18d547c52eda08a030067f28b4c08b3b29ce022605077d8c195a115808589f27" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_conversation_fork.py" + ] + }, + "functional_tests/test_conversation_fork.py::FakeMessageContainer": { + "boundary": { + "sha256": "0ceebd0d633dbb71d9c206ec2da6bbf93611e259361ab33e07b24717935833d4", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "18d547c52eda08a030067f28b4c08b3b29ce022605077d8c195a115808589f27" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_conversation_fork.py" + ] + }, + "functional_tests/test_conversations_read_ownership_authorization.py::FakeConversationContainer": { + "boundary": { + "sha256": "6b9ca012301696532cbe99ce06c1b4e05047201635573d252f2e90ffd44a01f2", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "592ddce8ee0dd79b708ab83477dbb2480d843dd27332812527dc275d15ed9e9c" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_conversations_read_ownership_authorization.py" + ] + }, + "functional_tests/test_conversations_read_ownership_authorization.py::FakeMessageContainer": { + "boundary": { + "sha256": "c55ef6419ec7b5dc7a2ecbb5830ecb1664022e0d538203c2dff2d4ad861b4a3c", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "592ddce8ee0dd79b708ab83477dbb2480d843dd27332812527dc275d15ed9e9c" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_conversations_read_ownership_authorization.py" + ] + }, + "functional_tests/test_cosmos_document_boundaries.py::embedded-source::embedded-PROBE::OfflineContainer": { + "boundary": { + "sha256": "500eeaa57834d5d36c2c33c0568279ec592b31e76e4652a0e24edb476f36ebe2", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3521e91219551ecc285401f634cdbd9a734fdf711e565c51f67cb7d8dff3bfc8", + "embedded_source_sha256": "5cb5fdf9a3df7e99d93cb8a862391ec7194c532359d8ebe842d029f1451f1c98" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_cosmos_phase3_shared_cache_metrics.py::FakeCosmosContainer": { + "boundary": { + "sha256": "0bf8083f3b03b204edd2f422bf771f86ff9b31ef90280600a62145af36fa0559", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2e5da0fc5f42ceb0db06811b601b256e9985f92c4a571a30f5ede8e1b7d487dd" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_phase3_shared_cache_metrics.py" + ] + }, + "functional_tests/test_cosmos_query_plugin.py::FakeConfigCosmosContainer": { + "boundary": { + "sha256": "5b8cac6bb9f86d6868431c2d5e6d65b2a89a9aa4b34fa3d68e3668504409c964", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3d8c4f1a5acbd32daf9f94fe19bb05e9dea02a27b0c900db6bd57d938ee59901" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_query_plugin.py" + ] + }, + "functional_tests/test_cosmos_wave1_app_maintenance.py::FakeCosmosContainer": { + "boundary": { + "sha256": "f65b9661b0f4afbc29d28d93fdf4805ad0216a00fcca89698a7a80e3e3711ae9", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2e5da0fc5f42ceb0db06811b601b256e9985f92c4a571a30f5ede8e1b7d487dd" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave1_app_maintenance.py" + ] + }, + "functional_tests/test_cosmos_wave1_cache_fallback.py::FakeCosmosContainer": { + "boundary": { + "sha256": "9b8fe5a86c0243ba124692c260e2f5e18ee9dc0fbafb613f1136570787498bd9", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "199eb16df2d84c472913255dc87ca1aaf796dccb3a7297f162514734bb3bee61" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave1_cache_fallback.py" + ] + }, + "functional_tests/test_cosmos_wave2a_chat_bootstrap_cache.py::FakeCosmosContainer": { + "boundary": { + "sha256": "6948558a10feb437cead02c110392334a7c8b1e78f8d299452f5c78e9f1b45f8", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "cc6b2673fcb8ab1c6032fc3dd3b504ec8179cc7daa154fb39ef1447506a990d0" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave2a_chat_bootstrap_cache.py" + ] + }, + "functional_tests/test_cosmos_wave2a_custom_pages_cache.py::FakeCosmosContainer": { + "boundary": { + "sha256": "4a14f89da4e1978de9823c8921731ff2ee15b50bba6390b3885ed748f8e4de2d", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2e5da0fc5f42ceb0db06811b601b256e9985f92c4a571a30f5ede8e1b7d487dd" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave2a_custom_pages_cache.py" + ] + }, + "functional_tests/test_cosmos_wave2b_conversation_cache.py::FakeCosmosContainer": { + "boundary": { + "sha256": "3bcf0168a5bd42a3ecf8f035298710e426a513f824e009c1717dd19ef09064ca", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave2b_conversation_cache.py" + ] + }, + "functional_tests/test_cosmos_wave2b_conversation_cache.py::ConflictOnceFakeCosmosContainer": { + "boundary": { + "sha256": "d77b6994d2f4551ff214853dfa18c7d3204abbface4f25d8ead7ca761deec87c", + "methods": [ + "replace_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave2b_conversation_cache.py" + ] + }, + "functional_tests/test_cosmos_wave3a_indexing_maintenance.py::FakeCosmosContainer": { + "boundary": { + "sha256": "978b08186ba012d0c8f1b8727f4367153f4288c3d54fc0aad06b39292d6c585b", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave3a_indexing_maintenance.py" + ] + }, + "functional_tests/test_cosmos_wave3b_document_access_index.py::FakeCosmosContainer": { + "boundary": { + "sha256": "4da208451ec70ee785152fd23d7fdabd1eefbcf8c5b3c5d5e7f408734994505a", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave3b_document_access_index.py" + ] + }, + "functional_tests/test_cosmos_wave3b_document_access_index.py::FakeRepairBacklogStateWriteFailContainer": { + "boundary": { + "sha256": "9ed06655a2a45a7fc432afe41c1c41aaed2dea1e2cea776f95fcdc2e1f2bbbca", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave3b_document_access_index.py" + ] + }, + "functional_tests/test_cosmos_wave4a_document_access_backfill.py::FakeCosmosContainer": { + "boundary": { + "sha256": "74175cd3eb3f373e215deef12c6f7860fa71f793d53fae6cd126af8374eab045", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "592313eb753fe7b168e9549e54c206d2b4ca2c91a235bd8af257c64b11afb22e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave4a_document_access_backfill.py" + ] + }, + "functional_tests/test_cosmos_wave4a_document_access_backfill.py::FakeRepairBacklogStateWriteFailContainer": { + "boundary": { + "sha256": "9ed06655a2a45a7fc432afe41c1c41aaed2dea1e2cea776f95fcdc2e1f2bbbca", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "592313eb753fe7b168e9549e54c206d2b4ca2c91a235bd8af257c64b11afb22e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave4a_document_access_backfill.py" + ] + }, + "functional_tests/test_cosmos_wave4b_document_access_shadow_validation.py::FakeCosmosContainer": { + "boundary": { + "sha256": "b155142d8134208d4646c0a1e3b9fadd0635d5591c0e4b31ab5821f100856737", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "869465b8d2f98f89f078c9625547e485d1343f97e855b803a9d3d3b97d2ba672" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave4b_document_access_shadow_validation.py" + ] + }, + "functional_tests/test_cosmos_wave4b_document_access_shadow_validation.py::ConflictOnceShadowStateContainer": { + "boundary": { + "sha256": "95026b06529598da3d47d4c6c193e0fcdaa9b1a83ce3fc405273a730d449bf37", + "methods": [ + "replace_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "869465b8d2f98f89f078c9625547e485d1343f97e855b803a9d3d3b97d2ba672" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave4b_document_access_shadow_validation.py" + ] + }, + "functional_tests/test_cosmos_wave5a_document_access_read_switch.py::FakeCosmosContainer": { + "boundary": { + "sha256": "f5619645b160fa0d1506125247502e67eca439709d4011208d42c1e338af591e", + "methods": [ + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "49973a3fe47d9f043efd1809d044c83cbfcb9d8196d7f951d835a228f0aa33d2" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave5a_document_access_read_switch.py" + ] + }, + "functional_tests/test_cosmos_wave5a_document_access_read_switch.py::FakeRepairBacklogStateReadFailContainer": { + "boundary": { + "sha256": "e3d140a7fa460b25f96f2cd13148957a396aa45e42751d5db668767a689db80c", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "49973a3fe47d9f043efd1809d044c83cbfcb9d8196d7f951d835a228f0aa33d2" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave5a_document_access_read_switch.py" + ] + }, + "functional_tests/test_cosmos_wave6_document_access_cache.py::FakeCosmosContainer": { + "boundary": { + "sha256": "c82472ca8e6038647fdc9b017855385f94a68054268c4677d3b45d01ee76cc21", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "9cbcfd0bfdc926d51203d71640608ab42c5001f5aa4bd63a87c5a0b05407a378" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave6_document_access_cache.py" + ] + }, + "functional_tests/test_cosmos_wave6_document_access_cache.py::FakeFencedDocumentsContainer": { + "boundary": { + "sha256": "3940402fe081a96a6e5764f06d84b8474a4e66e69f9d746d4d87c88d44f4597b", + "methods": [ + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "9cbcfd0bfdc926d51203d71640608ab42c5001f5aa4bd63a87c5a0b05407a378" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave6_document_access_cache.py" + ] + }, + "functional_tests/test_cosmos_wave6_document_access_cache.py::FailingRepairDocumentContainer": { + "boundary": { + "sha256": "5a8b79e54e8adc9c8b02fe8d251963106307f3add5cafe1158b6ce244b64aa90", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "9cbcfd0bfdc926d51203d71640608ab42c5001f5aa4bd63a87c5a0b05407a378" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave6_document_access_cache.py" + ] + }, + "functional_tests/test_cosmos_wave6_document_access_cache.py::ToggleFailUpsertContainer": { + "boundary": { + "sha256": "f105e7a1fbffa90ecd5ce8409865c59dada0ca0b4415de81142be6ac4cd2bffd", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "9cbcfd0bfdc926d51203d71640608ab42c5001f5aa4bd63a87c5a0b05407a378" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_cosmos_wave6_document_access_cache.py" + ] + }, + "functional_tests/test_data_management_ai_search_backup_export.py::FakeJobContainer": { + "boundary": { + "sha256": "810acfb6f777f60ffcc708c84ba824c45dabd3c20c5c8c0fe0f4b2fb27e40daf", + "methods": [ + "create_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f58024c00a893d8318fc86f4817c4aee21f351b145a9d66e46c6c60d5d36ddcb" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_ai_search_backup_export.py" + ] + }, + "functional_tests/test_data_management_ai_search_backup_export.py::FakeItemStateContainer": { + "boundary": { + "sha256": "1e8e346908b034c279c1d580646d487b2da1c61c516c4cfad3c12f64abd428ac", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f58024c00a893d8318fc86f4817c4aee21f351b145a9d66e46c6c60d5d36ddcb" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_ai_search_backup_export.py" + ] + }, + "functional_tests/test_data_management_ai_search_migration_resilience.py::FakeJobContainer": { + "boundary": { + "sha256": "566eea21954fd0b34e97bcc18adb587d7f0c9220811e281302ba6be4912c2e0b", + "methods": [ + "create_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "e3c6e72ab80aae2b9cfe32f5bbe1639da55236478e1ecee8ca96e4c33f0d71a7" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_ai_search_migration_resilience.py" + ] + }, + "functional_tests/test_data_management_backup_durability.py::FakeJobContainer": { + "boundary": { + "sha256": "1e7aa905bb6cf319d0c7af56722d8c7ed11d868d724c0a2b0adbfd19fc36f1dc", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c4a4a354af2aa70cbad13304ba9b6c9e690730c2f009479cd93732cf804aa149" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_backup_durability.py" + ] + }, + "functional_tests/test_data_management_backup_durability.py::FakeItemStateContainer": { + "boundary": { + "sha256": "582837b574f48f26856843ccf613f6337182b565566b55ec2cfcdc99e805eb9b", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c4a4a354af2aa70cbad13304ba9b6c9e690730c2f009479cd93732cf804aa149" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_backup_durability.py" + ] + }, + "functional_tests/test_data_management_backup_parallelism.py::FakeJobContainer": { + "boundary": { + "sha256": "5fee25b2dbc920bc1668f8e59491757b219769c43251be22867da3c788a88ab0", + "methods": [ + "create_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3bca505e200858e46615e80f5a2af8d3a3f8d36894a16d17611d0c39ceaadc1e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_backup_parallelism.py" + ] + }, + "functional_tests/test_data_management_backup_parallelism.py::FakeItemStateContainer": { + "boundary": { + "sha256": "61278a199f4eeb338d4468f6787ef04def46473a3b4922a621318966f4eba448", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3bca505e200858e46615e80f5a2af8d3a3f8d36894a16d17611d0c39ceaadc1e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_backup_parallelism.py" + ] + }, + "functional_tests/test_data_management_blob_backup_transfers.py::FakeCosmosContainer": { + "boundary": { + "sha256": "b51cde142a78c9e8d6925c1916a1308a3d79550b59f9f84efa70c492f4fb2b84", + "methods": [ + "create_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c334e2bcf0f907bcd9e57c9e1ecc5c034031f8717ead60d2fe27cc1b9b580c0e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_blob_backup_transfers.py" + ] + }, + "functional_tests/test_data_management_blob_migration_resilience.py::FakeJobContainer": { + "boundary": { + "sha256": "eb1b15272aba95b53269252e762a69582547e21083cf9bfc3d332a88421f24ef", + "methods": [ + "create_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "5974356585aa5209eb3a95aa244f3ed32144a622ddd7eb50778ee072af0e4457" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_blob_migration_resilience.py" + ] + }, + "functional_tests/test_data_management_cosmos_migration_resilience.py::FakeJobContainer": { + "boundary": { + "sha256": "e3b15dcdf0e7701d9e21b0637fa0acaf8c3f7adab90190952e5b7cdbe35e4748", + "methods": [ + "create_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "86ffad215434c4d03ec4e8195400134d2a6b7c9eda2c4bae684a9cf73c9b7d72" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_cosmos_migration_resilience.py" + ] + }, + "functional_tests/test_data_management_cosmos_migration_resilience.py::FakeTargetContainer": { + "boundary": { + "sha256": "a4694b69b132eae2968490e47820b7c5f2e6d082f937a52c4b470f7191ed310b", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "86ffad215434c4d03ec4e8195400134d2a6b7c9eda2c4bae684a9cf73c9b7d72" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_cosmos_migration_resilience.py" + ] + }, + "functional_tests/test_data_management_cosmos_migration_resilience.py::test_cosmos_write_renews_heartbeat_while_request_is_in_flight.SlowTargetContainer": { + "boundary": { + "sha256": "d7d96109da7cf1982e9e9ca1954c121df2c81220ea9360c6261bd5b133578bde", + "methods": [ + "create_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "86ffad215434c4d03ec4e8195400134d2a6b7c9eda2c4bae684a9cf73c9b7d72" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_cosmos_migration_resilience.py" + ] + }, + "functional_tests/test_data_management_destination_cosmos_capacity.py::FakeJobContainer": { + "boundary": { + "sha256": "0ba585d8caf4105cbde4c283a36542e413383c9042efe94e0e78b612b5e2974d", + "methods": [ + "create_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2870dd068c55be83c21832ac34d97fa43c19d20adc1ee58c39c05e446c212950" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_destination_cosmos_capacity.py" + ] + }, + "functional_tests/test_data_management_destination_cosmos_capacity.py::FakeTargetContainer": { + "boundary": { + "sha256": "051267fe06a72562a7c693874003707ad6f905ff859d16b1ae753ce7167516f1", + "methods": [ + "create_item", + "delete_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2870dd068c55be83c21832ac34d97fa43c19d20adc1ee58c39c05e446c212950" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_destination_cosmos_capacity.py" + ] + }, + "functional_tests/test_data_management_incremental_migration_modes.py::FakeJobContainer": { + "boundary": { + "sha256": "9f784d318785d9d2257ab59aa7eefdc9492fa0f8a45d2a73393218384933f238", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4c08e60cbe34855a3c170f97606225bc2e3703445c6788458ccd5358b909fc37" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_incremental_migration_modes.py" + ] + }, + "functional_tests/test_data_management_job_step_status.py::StubContainer": { + "boundary": { + "sha256": "b58342fa28cbeacdd317963e47fdfb40ad78322bbd1317793b6de0fb9243c0ef", + "methods": [ + "create_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "e098e6d03b405c4c5415f0353da3ded435916016b3c762e07f5c782d2e080535" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_job_step_status.py" + ] + }, + "functional_tests/test_data_management_migration_cancellation.py::FakeJobContainer": { + "boundary": { + "sha256": "2d4b42ba8e4c55a7daa681595d74cf41045eae42362e66a2728892e007aa699e", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2870dd068c55be83c21832ac34d97fa43c19d20adc1ee58c39c05e446c212950" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_cancellation.py" + ] + }, + "functional_tests/test_data_management_migration_coordinator.py::FakeCoordinatorContainer": { + "boundary": { + "sha256": "74cbdac3d4e32c6fad003e35652c3d24adf13bc70b48d3db9da4d7766cb09a56", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8f0390dde9b3f787cfe360a9fc7f56cf81f6e47a1ec8a4943ce5320d902bfa30" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_coordinator.py" + ] + }, + "functional_tests/test_data_management_migration_manifest.py::FakeManifestContainer": { + "boundary": { + "sha256": "b4938081a97d0138378d631f728a999086a3ab3bc3918657655bbcd5cd515c50", + "methods": [ + "create_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ab05f04bc4c926d70d11691d8553a89a5d3ab40c9e3cd4f07f6ec0250535432d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_manifest.py" + ] + }, + "functional_tests/test_data_management_migration_manifest.py::FakeJobContainer": { + "boundary": { + "sha256": "10164a1f413a73dee8311b56d9263fe7e45d04277d1333fa198e6e2de6e989be", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ab05f04bc4c926d70d11691d8553a89a5d3ab40c9e3cd4f07f6ec0250535432d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_manifest.py" + ] + }, + "functional_tests/test_data_management_migration_orchestration.py::FakeJobContainer": { + "boundary": { + "sha256": "19cab06cbab19e887c8edc77c865c192e7b2511ab0fd669be5e9b0181df9af60", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2870dd068c55be83c21832ac34d97fa43c19d20adc1ee58c39c05e446c212950" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_orchestration.py" + ] + }, + "functional_tests/test_data_management_migration_preflight.py::FakeJobContainer": { + "boundary": { + "sha256": "4f2f6dedddab02d3324206996f9e80d6915411d2b7360a4bc4ac9e59e5fa5173", + "methods": [ + "create_item", + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ab05f04bc4c926d70d11691d8553a89a5d3ab40c9e3cd4f07f6ec0250535432d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_preflight.py" + ] + }, + "functional_tests/test_data_management_migration_reconciliation.py::FakeJobContainer": { + "boundary": { + "sha256": "f622d3457ad239c254986c80e3bcce9e6531c097b77a6fa4bb8c21df077081c0", + "methods": [ + "create_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7ed17f5d8c9de60c3bc2c8252571dbcb7b7ecf08b97701f452ab837bf52e2b5e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_reconciliation.py" + ] + }, + "functional_tests/test_data_management_migration_reconciliation.py::FakeCosmosContainer": { + "boundary": { + "sha256": "98093e74c747188f85c15f3ac1b59792c60a1c081a3d195b49996bd36c23a7ac", + "methods": [ + "delete_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7ed17f5d8c9de60c3bc2c8252571dbcb7b7ecf08b97701f452ab837bf52e2b5e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_reconciliation.py" + ] + }, + "functional_tests/test_data_management_migration_reconciliation.py::FakeSearchGateContainer": { + "boundary": { + "sha256": "e9d83682bcf1a6302696474aca855fcb49976e951605489b2dce59268d128194", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7ed17f5d8c9de60c3bc2c8252571dbcb7b7ecf08b97701f452ab837bf52e2b5e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_reconciliation.py" + ] + }, + "functional_tests/test_data_management_migration_recovery.py::FakeJobContainer": { + "boundary": { + "sha256": "299da354642eaffec52fa1c66429b78a516c0303ccc4ff1eec03e2c16f0b3f0d", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "89aa35b665941b9d2f04e1241ba9defdba48acc0cbff468518594a01f2675d67" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_recovery.py" + ] + }, + "functional_tests/test_data_management_migration_retry.py::FakeJobContainer": { + "boundary": { + "sha256": "ccf4adb13690f2d8db9a0dc5788cd9a31ca7021b6dd20128aba56a89b9a579a0", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "6ebefe9e1184126863bd218b2987dd7c4bf927d966ac6668142ea7d7bd0708a2" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_retry.py" + ] + }, + "functional_tests/test_data_management_migration_retry.py::FakeConditionalJobContainer": { + "boundary": { + "sha256": "02f5d9a1b2e576747586072091a41dc0b73092a9a4407bcd80fb2be4403a2d09", + "methods": [ + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "6ebefe9e1184126863bd218b2987dd7c4bf927d966ac6668142ea7d7bd0708a2" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_retry.py" + ] + }, + "functional_tests/test_data_management_migration_workflow_contract.py::FakeJobContainer": { + "boundary": { + "sha256": "51392ad9dc47ca98374ec8bc03cc6492a5ff1e3284e026567fa01c194bf06972", + "methods": [ + "create_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8af3bceb0ffde567e17e9af16b84efa26dfc464e81b7afeb4ad8507e041039c1" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_migration_workflow_contract.py" + ] + }, + "functional_tests/test_data_management_public_prompt_migration.py::FakeJobContainer": { + "boundary": { + "sha256": "010ac06827e371695ed8c02d4fc030deed453ea7caafabb88a9f99f7465b7512", + "methods": [ + "create_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b9a3ab25672d0c9e29c420d5ddb501f41058675f92c9ee83d009271de56457c3" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_public_prompt_migration.py" + ] + }, + "functional_tests/test_data_management_public_prompt_migration.py::FakePromptContainer": { + "boundary": { + "sha256": "da22c479cca5a86a7b97be76f451de142b91fa6cccd42c0d051a62acf871da11", + "methods": [ + "create_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b9a3ab25672d0c9e29c420d5ddb501f41058675f92c9ee83d009271de56457c3" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_public_prompt_migration.py" + ] + }, + "functional_tests/test_data_management_restore_workflow.py::FakeJobContainer": { + "boundary": { + "sha256": "dc70aa21154df668fce5601f1b5c0db2ae19340b2bb5c98612d2414935b86991", + "methods": [ + "create_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "a29470212ebdcf5b18387256db488c869c8cc756438402030b38fcda4b4c4776" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_restore_workflow.py" + ] + }, + "functional_tests/test_data_management_search_write_fence.py::FakeGateContainer": { + "boundary": { + "sha256": "f80b2b61caaf6ed23371471fae0e5c291cab1a831f9420d310e9423ea7988284", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "0bbed936318aa30734511d2f48f5b8a666203db6409f9850e4995b0a0ea25faf" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_search_write_fence.py" + ] + }, + "functional_tests/test_data_management_search_write_fence.py::ConflictHeavyGateContainer": { + "boundary": { + "sha256": "893c13a6c8e89d5ac08fcdf447fa471c9a37683effa28ed01aef3a5ee143a2ca", + "methods": [ + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "0bbed936318aa30734511d2f48f5b8a666203db6409f9850e4995b0a0ea25faf" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_search_write_fence.py" + ] + }, + "functional_tests/test_data_management_search_write_fence_authorization.py::FakeDocumentContainer": { + "boundary": { + "sha256": "a3e358957e94e377e64ee9b208dbed1e8572adbafc1b76a1e13f61031baba269", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4af4933dd56caa2c252251bb1b80f72d47982dd78211e33b6c372f31d09b7ed2" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_data_management_search_write_fence_authorization.py" + ] + }, + "functional_tests/test_document_action_token_usage_aggregation.py::FakeContainer": { + "boundary": { + "sha256": "e3b0c3ac83f2740747cfbf0ffb6f6db2fff2ac4fec060338564957487ff9177f", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2d140dff180790e2a86d1f649964299edd0c83473afd63f8e6f3d64204c073b5" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_document_action_token_usage_aggregation.py" + ] + }, + "functional_tests/test_document_analysis_work_recovery.py::AnalysisMemoryContainer": { + "boundary": { + "sha256": "753c65a3bb25721270098329c77ec9ceed989434b639701dd49c1eff9ec0890c", + "methods": [ + "delete_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "4b4278fd72804c2e70e8520a07537409a4fbeb00b53b3d77db8b92737dcc6f42" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_document_analysis_work_recovery.py" + ] + }, + "functional_tests/test_document_analysis_work_recovery.py::test_lost_unit_completion_acknowledgement_resumes_the_committed_payload::point-seam-1": { + "boundary": { + "sha256": "b12e8395b3837094867a4cb38a92a62b79a011343757f69a2b6c955d687a9e69", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "4b4278fd72804c2e70e8520a07537409a4fbeb00b53b3d77db8b92737dcc6f42" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_document_analysis_work_recovery.py" + ] + }, + "functional_tests/test_document_provenance_origin.py::ConversationStore": { + "boundary": { + "sha256": "d943e8cb283f884d3b33aef1973c7ba45f85ae468d64f7a96c3cbf7e54d00f96", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "0307cd1717ff3d0bda795e71133a23b8d70dba0dc4fbab0a73ec045f89b2df8b" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_document_provenance_origin.py" + ] + }, + "functional_tests/test_document_provenance_publication.py::test_an_unreadable_conversation_never_blocks_publication.UnavailableConversations": { + "boundary": { + "sha256": "d848b62fa55e3fcf9a26501b132816d727402c877a2241e42b82ff9dcb45174f", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "0e67fbb453d04d7dd5298e22e47c3da6d67e6595081c638b9249628db9af8d13" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_document_provenance_publication.py" + ] + }, + "functional_tests/test_document_provenance_versions_and_guards.py::ConversationReads": { + "boundary": { + "sha256": "69f27e199299001c1b7c9147fa38017fbbd22261be7da8c5db5816fe42e289cb", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "148538a78646624a3979525f01ec0c1f4d85a800092a237c137c115b39dfc9bb" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_document_provenance_versions_and_guards.py" + ] + }, + "functional_tests/test_document_search_metadata_sync.py::FakeDocumentsContainer": { + "boundary": { + "sha256": "328730eded73951ad31aafd5c24bebaad155ee9e6d8b6e59b6146b3b53f9b6d5", + "methods": [ + "create_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "31a2f26eebdbbea8a4271f2b1c1b534d60da811f4cab6f4e65e3063976ccf57b" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_document_search_metadata_sync.py" + ] + }, + "functional_tests/test_document_transform_sources.py::artifact_source::point-seam-1": { + "boundary": { + "sha256": "df5c308aea815ee21760a5807ae9222975d4de889f247b04445f333cddc95977", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "b5f65b0f3fabc70a0edaef885e91642e2bdd94f24ed8482b0295fc8ea5373612" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_document_transform_sources.py" + ] + }, + "functional_tests/test_document_transform_sources.py::artifact_source::point-seam-2": { + "boundary": { + "sha256": "26fa8c64e93c10c5ea72e63a4a52f8cf839bfd9769a0f4e4e8b9ef95d497a8cf", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "b5f65b0f3fabc70a0edaef885e91642e2bdd94f24ed8482b0295fc8ea5373612" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_document_transform_sources.py" + ] + }, + "functional_tests/test_fact_memory_profile_and_mini_sk.py::FakeFactContainer": { + "boundary": { + "sha256": "ca45e87d160cc2cc548e5b5a0a6a2b7756bdf7dc8a798873e4206932373e4f44", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ed74ee3422c6897f32b88c600a081b8acd433488ad01644226aa8007e318f0e7" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_fact_memory_profile_and_mini_sk.py" + ] + }, + "functional_tests/test_feedback_submission_authorization.py::FakeConversationContainer": { + "boundary": { + "sha256": "4f56feb2fdee56f9a16b1ddc4185fc7f6ddc7215b953cbab042c4a08046b352d", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8c69fce4303f85688c6e511e049c779dd7e1fc22e7b51b3e3709ae331cbecb46" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_feedback_submission_authorization.py" + ] + }, + "functional_tests/test_feedback_submission_authorization.py::FakeFeedbackContainer": { + "boundary": { + "sha256": "0b66a3b6619bdc8740699f9af1118555530e78ed9129a0319a1f084052ae5b0e", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8c69fce4303f85688c6e511e049c779dd7e1fc22e7b51b3e3709ae331cbecb46" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_feedback_submission_authorization.py" + ] + }, + "functional_tests/test_file_processing_log_cleanup.py::FakeContainer": { + "boundary": { + "sha256": "06d53ccdf9560425ed1e817239a10c6fd9605fa0fe5742d4e78d3199791dcca5", + "methods": [ + "delete_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "532e0c012e780de5fa9d248e29b2a9e2f1134575555a1df7f86d539177f62b5d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_file_processing_log_cleanup.py" + ] + }, + "functional_tests/test_file_sync_concurrent_write_safety.py::FakeContainer": { + "boundary": { + "sha256": "67f5d5b8fa38f8d5236e9e2a0f06f83424758d6d5e432748e6abd2d1a9e363b8", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "016c42b33c26778a9c563840280671bdc577eb9844818eec77cec8d1a2024f1c" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_file_sync_concurrent_write_safety.py" + ] + }, + "functional_tests/test_generated_artifact_lifecycle_authorization.py::FakeContainer": { + "boundary": { + "sha256": "691193ac86088e1e1428f951fba7ff4df848fd4c07c228a1e2965c1afec96a5a", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "e9499130d78e5ee6fb32512279a73a6ec2a79d4765f11b38187fc17f3bbb1f86" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_generated_artifact_lifecycle_authorization.py" + ] + }, + "functional_tests/test_global_action_user_audit_fallback.py::FakeContainer": { + "boundary": { + "sha256": "67ba030b6e0fa75b55fdfd67eb6ef67e91ec7ff3d7ad8cb3488881e3783fdbfc", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ff3b964960dc41d57ba72a37e89d9e22b101271c24ba35e6438ba1f4356adf95" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_global_action_user_audit_fallback.py" + ] + }, + "functional_tests/test_governance_activity_logging.py::_TestContainer": { + "boundary": { + "sha256": "38af4e0b659088b03b28e6cc635a2d848736795ea2890d64969b583bee65d876", + "methods": [ + "create_item", + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2e15f3bd3d955a17d59dc7a9d01e98cd15052fe3edecb4a2bca9fc8044fa6f16" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_governance_activity_logging.py" + ] + }, + "functional_tests/test_governance_activity_logging.py::_InMemoryContainer": { + "boundary": { + "sha256": "55cd9e7729194475f5d6cb377f263f242e6c8963bd9c87e646d7e34c04f5295b", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2e15f3bd3d955a17d59dc7a9d01e98cd15052fe3edecb4a2bca9fc8044fa6f16" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_governance_activity_logging.py" + ] + }, + "functional_tests/test_governance_activity_logging.py::test_log_governance_change_payload_shape._CaptureContainer": { + "boundary": { + "sha256": "aa53faaa41b71493553f94d440231d4b0cab88facff3f129543e60919cdec9b1", + "methods": [ + "create_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2e15f3bd3d955a17d59dc7a9d01e98cd15052fe3edecb4a2bca9fc8044fa6f16" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_governance_activity_logging.py" + ] + }, + "functional_tests/test_governance_enforcement_logic.py::_TestContainer": { + "boundary": { + "sha256": "98727859bee328810570165b1e5e8e7d1912b3cc4e3cbce9d63d0fede2807bd5", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "be46a5d17909f1afa752ec4b9e9327280ba47ef91a692cab07efd9ceaabf7288" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_governance_enforcement_logic.py" + ] + }, + "functional_tests/test_governance_enforcement_logic.py::test_item_policy_retarget_moves_existing_policy_document._RetargetContainer": { + "boundary": { + "sha256": "fe07b44ec9de4405f291a3dac0474b98b99cf56040c0c474066eb1daf26f56f7", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "be46a5d17909f1afa752ec4b9e9327280ba47ef91a692cab07efd9ceaabf7288" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_governance_enforcement_logic.py" + ] + }, + "functional_tests/test_group_bulk_endpoint_save_writer.py::test_an_uncertain_write_failure_keeps_the_staged_credential::point-seam-1": { + "boundary": { + "sha256": "9efa6d2be9d6958d1f0d31966538b195d95299b56d82c6a8bccd413505e72fd2", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "458fdcc8d40ba10bd2d743c7211dd8936109725afc285961cf1a9921c4efac5f" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_bulk_endpoint_save_writer.py" + ] + }, + "functional_tests/test_group_collaboration_source_storage_fix.py::TrackingContainer": { + "boundary": { + "sha256": "624d51cb151f27a503b9b93047754d606efd2f3e54634c66820576200edb16c3", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4029463e248875fcc10807601561ffb87d1d5eee42d2fe9b4c479e3850a840d5" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_group_collaboration_source_storage_fix.py" + ] + }, + "functional_tests/test_group_collaboration_source_storage_fix.py::::point-seam-1": { + "boundary": { + "sha256": "12f18785ec3b5177a1a7c4640fa80b511fbf592a191c95d6792999908dd7bcff", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "4029463e248875fcc10807601561ffb87d1d5eee42d2fe9b4c479e3850a840d5" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_collaboration_source_storage_fix.py" + ] + }, + "functional_tests/test_group_directory_apis.py::test_a_storage_failure_is_a_generic_500_without_the_exception_text::point-seam-1": { + "boundary": { + "sha256": "53a129d8269fb8d8c672707f59137686ffd5ae01194be745526e4cf7924bcec2", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "a0028b58a4a82c229332137247412b4e93fd81b127c589d62b4b56773fc57520" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_directory_apis.py" + ] + }, + "functional_tests/test_group_document_blob_upload_etag.py::EtagContainer": { + "boundary": { + "sha256": "f72c109202df244c2de6e2b5ba23426813b1b0547c9b1a5ab29edb35da01e462", + "methods": [ + "create_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4d2c75454c04c3b15f7e011ab5b0e9a37e28ea9d8d49fc244df67fe260cf02dd" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_group_document_blob_upload_etag.py" + ] + }, + "functional_tests/test_group_document_collaboration.py::NotificationStore": { + "boundary": { + "sha256": "fd83d961c5a88340e50e5aa5dea8b627e9ff90465606156fd6719ed0f469fe95", + "methods": [ + "delete_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_group_document_collaboration.py" + ] + }, + "functional_tests/test_group_document_collaboration.py::sharing::point-seam-1": { + "boundary": { + "sha256": "c03644aff628e2a3eef29f55c82602bb7d9f78f87a2472bf3a8358902e1758ce", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_document_collaboration.py" + ] + }, + "functional_tests/test_group_document_collaboration.py::test_lost_effect_checkpoint_acknowledgement_never_replays_completed_work::point-seam-1": { + "boundary": { + "sha256": "3a72acae523289dceff2aeb1992720e3acda78bd8858513aff40afa35ad44241", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_document_collaboration.py" + ] + }, + "functional_tests/test_group_document_collaboration.py::test_unknown_notification_create_acknowledgement_is_not_a_replayable_refusal::point-seam-1": { + "boundary": { + "sha256": "b57318009f91dbbfcbd974df4e9299c49111a288ab42463a37838bac818683e0", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_document_collaboration.py" + ] + }, + "functional_tests/test_group_document_collaboration.py::test_unknown_notification_create_acknowledgement_is_not_a_replayable_refusal::point-seam-2": { + "boundary": { + "sha256": "b2781f2c00998f02be7f2f50724d7cdf662af1c155f44b22bddf15ef28683791", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_document_collaboration.py" + ] + }, + "functional_tests/test_group_document_etag_guard.py::test_a_lost_response_commit_is_recognised_rather_than_retried::point-seam-1": { + "boundary": { + "sha256": "16b139e8e995e8fadceb8ec9340c3c18099dc124f29dc0993ca8275bb000125d", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "260ba27105274a5f9b809d9dc1ed3ed034efe76a3e13466400dbd417a04a599c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_document_etag_guard.py" + ] + }, + "functional_tests/test_group_document_etag_guard.py::test_a_none_cache_reason_lost_response_commit_is_recognised_without_a_bump::point-seam-1": { + "boundary": { + "sha256": "16b139e8e995e8fadceb8ec9340c3c18099dc124f29dc0993ca8275bb000125d", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "260ba27105274a5f9b809d9dc1ed3ed034efe76a3e13466400dbd417a04a599c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_document_etag_guard.py" + ] + }, + "functional_tests/test_group_document_management.py::MutableContainer": { + "boundary": { + "sha256": "24a9a73bf0e9a7557cdb5b89be4a319b20a631fcea70739a95f6c7b4faf62e33", + "methods": [ + "create_item", + "delete_item", + "patch_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4cedaa57c6a547144e32820585c5484b20534246ed0322569a4f55a3b9e5ca14" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_group_document_management.py" + ] + }, + "functional_tests/test_group_document_projection_fence.py::ConditionalSource": { + "boundary": { + "sha256": "e59e031c44eaed7c84800bbbd527329607a5ec98e4de41346ccdf7f6d079eb46", + "methods": [ + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f9678253d5f94f2bc91ffdda295fee2a81c11c01c35f7c762fec49a3859ac028" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_group_document_projection_fence.py" + ] + }, + "functional_tests/test_group_document_publication.py::ReceiptStore": { + "boundary": { + "sha256": "2aa58f7aeca39e036dcd875abf9119130e45373b4237809b1bdf2ce20ac18f6a", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "439edc9ca6db5fe920de447fd839793ab56393cedab67ca1b04851603ee3d733" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_group_document_publication.py" + ] + }, + "functional_tests/test_group_document_read_apis.py::ReadOnlyContainer": { + "boundary": { + "sha256": "37edaa6d4bc77a4cc85760f7cc989906e564ee80d1856f5d2de6bf4da31bf3ef", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3a9431f0b11483f22d1f5b5c8c01fcba4d21c8ed3c4d9fb8ae431fbe89392738" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_group_document_read_apis.py" + ] + }, + "functional_tests/test_group_endpoint_apis.py::test_a_lost_response_commit_is_reported_committed_and_its_key_kept.replace_then_lose_the_response::point-seam-1": { + "boundary": { + "sha256": "3ef2ef43fe07a5a90ab0d3915e5fda77c9b8b6f1ca8b4467abe5c7cd642157be", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "39a1d91917706f6db9d3f912480c0a3813f637d64b732ffbd12aa8eb1f097ec3" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_endpoint_apis.py" + ] + }, + "functional_tests/test_group_endpoint_apis.py::test_a_lost_response_commit_is_reported_committed_and_its_key_kept::point-seam-1": { + "boundary": { + "sha256": "b50b81a363d8b097b5746a0556394589aabf04f635d30ece4d462f2bb94bf6f5", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "39a1d91917706f6db9d3f912480c0a3813f637d64b732ffbd12aa8eb1f097ec3" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_endpoint_apis.py" + ] + }, + "functional_tests/test_group_endpoint_apis.py::test_an_uncertain_failure_keeps_staged_keys::point-seam-1": { + "boundary": { + "sha256": "3f7e4c14eab523b4ac70dd8744622a9359a91c49e06e00ce2e24bc3ff8c2a499", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "39a1d91917706f6db9d3f912480c0a3813f637d64b732ffbd12aa8eb1f097ec3" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_endpoint_apis.py" + ] + }, + "functional_tests/test_group_membership_apis.py::test_an_unexpected_failure_is_a_logged_generic_500::point-seam-1": { + "boundary": { + "sha256": "69967a7bec26f7925866d4e6a9099741af49b108ced0f26214f92a59335716ef", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "d291d81abc7bc89a1d1cbc3ba1142b8034ec105cb3298653f64a2eaeb819ae88" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_membership_apis.py" + ] + }, + "functional_tests/test_group_screening_fixture_parity.py::RealScreening.__init__::point-seam-1": { + "boundary": { + "sha256": "af33512d32e42fb2e8860a0c9f49fad194937e2fd9cd957234cfb7c5966658db", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "0b85da00d16d42d0232c364b48a07b77c9ba3aece4db3405f0cf0084d74c645f" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_screening_fixture_parity.py" + ] + }, + "functional_tests/test_group_settings_apis.py::test_a_storage_failure_mid_write_is_a_data_free_500::point-seam-1": { + "boundary": { + "sha256": "c8ad2bc393a568bbb2e08a5b6bb1befee9815552d7a06ae96f8666f1e9274906", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "b060fa01a84f8f864df39c3e6b933aade6c0bb1380fcad66681325da7456dbc2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_settings_apis.py" + ] + }, + "functional_tests/test_group_settings_apis.py::test_an_unexpected_failure_is_a_logged_data_free_500::point-seam-1": { + "boundary": { + "sha256": "36fc1099c4a13d53c875e51bde00667c2e197eefdf8e620a228f0077cf464519", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "b060fa01a84f8f864df39c3e6b933aade6c0bb1380fcad66681325da7456dbc2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_settings_apis.py" + ] + }, + "functional_tests/test_group_settings_legacy_fixes.py::test_a_storage_failure_answers_reviewed_text_and_logs_no_detail::point-seam-1": { + "boundary": { + "sha256": "c8ad2bc393a568bbb2e08a5b6bb1befee9815552d7a06ae96f8666f1e9274906", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "b06be0a0fd150f4e58c5a70feb36c9bff1a6511695eb78808d2b18e580a0e926" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_settings_legacy_fixes.py" + ] + }, + "functional_tests/test_group_tag_definition_writers.py::tag_environment::point-seam-1": { + "boundary": { + "sha256": "76433caafd6d3c20a1efb44fa9be91390721a06a1e368ea30cfd885dca3fee17", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "279a2c52556f2708b56ac14dddc977cf355d2b62f01c9477a78b319205b6a386" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_tag_definition_writers.py" + ] + }, + "functional_tests/test_group_tag_definition_writers.py::after_read::point-seam-1": { + "boundary": { + "sha256": "a0d566c18636c32ec440ab615ec4cae01fd6a216842cd7e0c98d6884a5b10d7d", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "279a2c52556f2708b56ac14dddc977cf355d2b62f01c9477a78b319205b6a386" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_group_tag_definition_writers.py" + ] + }, + "functional_tests/test_group_workflow_round_trip_preservation.py::WorkflowContainer": { + "boundary": { + "sha256": "fcfdcbc6eb450b7eefeef8ea71dd486450ab8253606f9124b0d57cd430110965", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "213a78c7899a26c20dc181f07157990609fe837a4fa5d6e42e411892d69c70f4" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_group_workflow_round_trip_preservation.py" + ] + }, + "functional_tests/test_image_chat_route_integration.py::MemoryContainer": { + "boundary": { + "sha256": "66c3681c61324062ea4f16f3292cfbc5f307e245c248af5b873f221e58082873", + "methods": [ + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "23548f44b2266b8b7fda3af985daaf1c99b171bca3c5c98a7c1659dafb6c058a" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_image_chat_route_integration.py" + ] + }, + "functional_tests/test_image_reference_resolver.py::ImageReferenceResolverTests.test_personal_metadata_reader_never_searches_group_or_public_containers.FakeContainer": { + "boundary": { + "sha256": "3432746f67549a02907ede93fb407775652811a8d5ddaeae6cbb9c7014d2d30f", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "0d82be48089ab62223b082c18d78e73c4f345b4d6c764aa7e567ad817f443290" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_image_reference_resolver.py" + ] + }, + "functional_tests/test_keyvault_external_notification_telemetry.py::FakeReminderContainer": { + "boundary": { + "sha256": "ced6026dd22762297ce7875f0ef300a761f54f91e7e875a27782001d3e7c2aa5", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ff3b964960dc41d57ba72a37e89d9e22b101271c24ba35e6438ba1f4356adf95" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_keyvault_external_notification_telemetry.py" + ] + }, + "functional_tests/test_large_image_api.py::FakeMessageContainer": { + "boundary": { + "sha256": "d1094cc92298cad5298db3ce7b9a69e434cec50a0d3ed4be234a8abb12b22430", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c776d34d76eba1a6dfa5178c57229551db9bac6378e6d2b2cae88a923706486d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_large_image_api.py" + ] + }, + "functional_tests/test_log_credential_key_redaction.py::install_cosmos_stub.StubContainer": { + "boundary": { + "sha256": "c6665c0f59b81a8b8a51c5bfdd3e7bb7575c4e804e4d98b1d99ff7c1c6c8b857", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "0fd9fbef22fb5a8d978431b9162ac4fa157cf4f3a1edd57bf1af564b3ea6d00d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_log_credential_key_redaction.py" + ] + }, + "functional_tests/test_log_injection_codeql_alerts_fix.py::CacheContainer": { + "boundary": { + "sha256": "850fc4dc0539b2eaf57663b899d929566c18b48c5c6722965d7deb6f3436c7de", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ca7c1f871f49511c5e45d1b1caf305bcd8b7878de35925ae7bc6dda0d3e4d778" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_log_injection_codeql_alerts_fix.py" + ] + }, + "functional_tests/test_m365_action_card_api.py::CardContainer": { + "boundary": { + "sha256": "5c5fa84ccf6faf43fe3f89db14a411da17ce9574e53fb77b3f1a7c2b345c615f", + "methods": [], + "kind": "class", + "inherited_bases": [ + "CosmosContainer" + ], + "imports_sha256": "223e6494bc6d16315ef13da74c898b605f8787c7c16c4c858e517cdac83b7746" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_m365_action_card_api.py" + ] + }, + "functional_tests/test_m365_action_lifecycle.py::MemoryContainer": { + "boundary": { + "sha256": "4741678cd1dc20e09f9b5c26e3947409724a125764dfe0c47eb40f9219dcf0ea", + "methods": [ + "create_item", + "delete_item", + "execute_item_batch", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7c17178a7266fe661f78e79c8e34dbf1613078b060537a245c7710c4417f18d6" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_m365_action_lifecycle.py" + ] + }, + "functional_tests/test_m365_action_lifecycle.py::test_exact_id_lookup_never_treats_storage_failure_as_absence::point-seam-1": { + "boundary": { + "sha256": "2e7b9535a14222fa8f62d879d5d4030861284bf8d85da24d2f30b18be6b24982", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7c17178a7266fe661f78e79c8e34dbf1613078b060537a245c7710c4417f18d6" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_m365_action_lifecycle.py" + ] + }, + "functional_tests/test_m365_action_lifecycle.py::test_migration_receipt_lookup_never_treats_storage_failure_as_absence::point-seam-1": { + "boundary": { + "sha256": "c287777136ee63a74e717bdd163ed58e713691c017e0f8a502c31d5ac0c802b2", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7c17178a7266fe661f78e79c8e34dbf1613078b060537a245c7710c4417f18d6" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_m365_action_lifecycle.py" + ] + }, + "functional_tests/test_m365_chat_action_cards.py::run_offline_scenarios.Container": { + "boundary": { + "sha256": "f2d33f0cfc0606ced1211bdd1a1649c3b03fd6f3f5545b4c28292344d93f0b15", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [ + "OfflineContainer" + ], + "imports_sha256": "157376cd360768efe2d84a5d030254dfdf587e56045075b21594e22884da2337" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_m365_chat_action_cards.py" + ] + }, + "functional_tests/test_m365_continuations.py::PendingJobs": { + "boundary": { + "sha256": "56c3aa51a4bb48204fb8b806ce6f2a60e16666ce15cb6b5a3bc6f9d6ff27a67c", + "methods": [], + "kind": "class", + "inherited_bases": [ + "CosmosContainer" + ], + "imports_sha256": "34742e0a941e9fb3d99d02e7086fb96f82eb337d5d5529d0fc3c8a01a0579e70" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_m365_continuations.py" + ] + }, + "functional_tests/test_m365_conversation_lifecycle.py::PendingContainer": { + "boundary": { + "sha256": "50e82aa336f310c9692377119748028f14af5dc5d012e462696123ed00b8e6da", + "methods": [ + "replace_item" + ], + "kind": "class", + "inherited_bases": [ + "CosmosContainer" + ], + "imports_sha256": "ade1afad3c494c1be72d915bb19e8e7171428de5454a8a50c29a85aa8287ec24" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_m365_conversation_lifecycle.py" + ] + }, + "functional_tests/test_m365_file_runtime.py::test_conditional_conflicts_retry_the_same_budget_with_fresh_etags::point-seam-1": { + "boundary": { + "sha256": "fb8f6c7d4f97eb72efc225356b65966ed8175882365ff6e34c87e99cb7bcd9bb", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "67e69c7f26dc001fad12112c8c8c75a41705da2963df550ac99fd30632b5582e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_m365_file_runtime.py" + ] + }, + "functional_tests/test_m365_file_runtime.py::test_final_conflict_exhaustion_is_an_error_not_an_empty_budget::point-seam-1": { + "boundary": { + "sha256": "03beaa2c2a904c20d0b089af667297cb11582c87f39f43636252ba7589aac1c6", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "67e69c7f26dc001fad12112c8c8c75a41705da2963df550ac99fd30632b5582e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_m365_file_runtime.py" + ] + }, + "functional_tests/test_m365_file_runtime.py::test_conflict_cannot_switch_to_another_request_budget::point-seam-1": { + "boundary": { + "sha256": "906ae1300b4f7097877fd71555578e9d7b27d46ef4ca3f7d247e06b4185b8587", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "67e69c7f26dc001fad12112c8c8c75a41705da2963df550ac99fd30632b5582e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_m365_file_runtime.py" + ] + }, + "functional_tests/test_m365_file_runtime.py::test_non_conflict_storage_failures_are_surfaced_without_retry::point-seam-1": { + "boundary": { + "sha256": "5dcb21190e289075c7878379ef1b7d479518edda960e5da2e9ab96ffa99d64e4", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "67e69c7f26dc001fad12112c8c8c75a41705da2963df550ac99fd30632b5582e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_m365_file_runtime.py" + ] + }, + "functional_tests/test_m365_pending_delivery.py::PendingContainer": { + "boundary": { + "sha256": "781a9a2f4b437798bb857da970ba2502e71cdf9918a4d7fa1abca12c6ea56747", + "methods": [], + "kind": "class", + "inherited_bases": [ + "CosmosContainer" + ], + "imports_sha256": "cd44d9968998c5e949b8a9f11772a70562ed1171aa42189b0e6f9549c044c7f3" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_m365_pending_delivery.py" + ] + }, + "functional_tests/test_m365_routes.py::M365RouteTests.test_dependency_errors_do_not_reveal_sdk_or_configuration_text::point-seam-1": { + "boundary": { + "sha256": "cea48015294e2bdb9f4be906ce1b7452838f89eb8de70ebbef5011013501d9c4", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "646eac4950eb719a6dac881fff31f2ace8523b5c386eb251003716698250bda7" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_m365_routes.py" + ] + }, + "functional_tests/test_m365_runtime_imports.py::embedded-PROBE::Container": { + "boundary": { + "sha256": "c3c82162303c319991945e0a07391391d4b5f3d1976a700c203e78d49aafc0c2", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "5d7607d00227de444f1b96c124f2e08824c04641e25c293b045f57fa0a9b8741", + "embedded_source_sha256": "e4bb84504993bb9aa316f4dddc893e6969d2e1264e6db89a804b9dca7cb4ed0d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_m365_runtime_imports.py" + ] + }, + "functional_tests/test_m365_settings_ingress.py::test_concurrent_removal_cannot_be_undone_by_a_stale_settings_write.Container": { + "boundary": { + "sha256": "8bc5d5da6998091069223c362b921aec80958cd21b8cbc686a3ae80a00edb842", + "methods": [ + "replace_item" + ], + "kind": "class", + "inherited_bases": [ + "CosmosContainer" + ], + "imports_sha256": "351b36f8b6a199f78871308200ed17f67bfa19dfdc08a6667342623569a67c48" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_m365_settings_ingress.py" + ] + }, + "functional_tests/test_mcp_legacy_stdio_management.py::MemoryContainer": { + "boundary": { + "sha256": "96d08538b372cc602d8abe54349672e82674a98b1bb16c6f6cb3b9c056d84381", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_mcp_legacy_stdio_management.py" + ] + }, + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_single_action_lookup_storage_errors_are_not_reported_as_absent_actions::point-seam-1": { + "boundary": { + "sha256": "f44ad55f6ecb7b0f6866aa6fa5fcfdde3171c80eccd3021b6d28d65156d442b3", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_mcp_legacy_stdio_management.py" + ] + }, + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_legacy_list_read_and_validation_failures_remain_visible::point-seam-1": { + "boundary": { + "sha256": "da84de4ca53f69b25bde1785d35bdc81055597e3547cb29ed106babb167cb963", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_mcp_legacy_stdio_management.py" + ] + }, + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_legacy_list_read_and_validation_failures_remain_visible::point-seam-2": { + "boundary": { + "sha256": "1abf3ee47780e06bd6f7e49db878beef651ec9885dafaab3ec442e18bfe98d10", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_mcp_legacy_stdio_management.py" + ] + }, + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_global_save_propagates_lookup_failures_without_writes::point-seam-1": { + "boundary": { + "sha256": "1653fa53442c2ff73063c907c6fa024d52aa8339e7694578a5f7f8a5995166fd", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_mcp_legacy_stdio_management.py" + ] + }, + "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_route_settings_preflight_entry_point_preserves_sources_and_propagates_failures::point-seam-1": { + "boundary": { + "sha256": "5f530b365d4d3744e34544bf00bb21285e9200e258fcd382e7a91354f8ba9f6f", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_mcp_legacy_stdio_management.py" + ] + }, + "functional_tests/test_mixed_source_hardening.py::test_citation_artifact_cancellation_rolls_back_partial_publication.CitationContainer": { + "boundary": { + "sha256": "54735623f0241a478ad905f5ad5daaa819b237d5023a9e1b734d099dae84fdd2", + "methods": [ + "delete_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4408d89070f741e64540573015de52d1bdb6715a3f89edf109b0f12e1e7fd2e4" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_mixed_source_hardening.py" + ] + }, + "functional_tests/test_mixed_source_manifest_contracts.py::FakeItemContainer": { + "boundary": { + "sha256": "24ba4aa7bf3c08c05cad242bfbfa4ae2d337171f6bf62f2b62acd8a995b769e2", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c66a388d4c4690dc7cd31255497ba8244b25cf70b6e9112659f709b5242b240e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_mixed_source_manifest_contracts.py" + ] + }, + "functional_tests/test_native_tabular_compute_service.py::MemoryContainer": { + "boundary": { + "sha256": "51c108748e764ca77d9ee43629976687d3edcfec66d1607531a1f74fd92ac839", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c304baf9af95ebecdac3a41502792f66a171c78a4de7db32ba67c2970dd56cf2" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_native_tabular_compute_service.py" + ] + }, + "functional_tests/test_native_tabular_compute_service.py::test_atomic_submission_race_preserves_one_owned_job::point-seam-1": { + "boundary": { + "sha256": "1bdaaaff6a7e22079eda405fe1a28a92da40ff2f67cf7b7f8450480a7525e2be", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "c304baf9af95ebecdac3a41502792f66a171c78a4de7db32ba67c2970dd56cf2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_native_tabular_compute_service.py" + ] + }, + "functional_tests/test_onenote_upload_dispatch.py::OneNoteUploadDispatchTests.run_dispatch::point-seam-1": { + "boundary": { + "sha256": "4e1d636093dd6d60dbb31e3d15ba417546d4cf46ec115b2c92dca0c37e8ed791", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "3e98118be2c2e12a9e216fadd654c8241642d0528d763f34a5019ab4fd56d849" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_onenote_upload_dispatch.py" + ] + }, + "functional_tests/test_orchestration_checkpoint_error_mapping.py::_fail_read::point-seam-1": { + "boundary": { + "sha256": "3e35d79e181b545da041acce22846df169b8fd8cf8d40f4bf4d75385d6065423", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "c005a367ec556c21fb9709a8b38d3342ad75be556e6fd25d1f401b1032898230" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_checkpoint_error_mapping.py" + ] + }, + "functional_tests/test_orchestration_cleanup_bootstrap.py::test_root_cleanup_does_not_coerce_non_mapping_authority::point-seam-1": { + "boundary": { + "sha256": "d25477701a063b4ec9eb00ae5ae819dc49f2c2402a94223e37c2e565b29a978e", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "01edeac6a183cb3c16f5194da8b41aaf635410556f1ce1c5a47a62a08bbb2083" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_cleanup_bootstrap.py" + ] + }, + "functional_tests/test_orchestration_continuation.py::test_result_read_rechecks_epoch_after_the_control_point_read::point-seam-1": { + "boundary": { + "sha256": "b9db7b512f12ea248e71f5592e102cb0a1b5a5196b4b8370985a55185f288d31", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "4f2ae2302607b6cc425baba0619c61f61004eacb3f8ce785c0375fce7fd9606b" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_continuation.py" + ] + }, + "functional_tests/test_orchestration_cosmos_response_contract.py::test_output_read_does_not_coerce_non_mapping_documents::point-seam-1": { + "boundary": { + "sha256": "ed77313ec6c261e459ef59076c389e757f9aaeb1372f5b76a997b1bb77b9687e", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "b5ef5089f52fd0efe406899e50214208bd5477cbeab34e3f5c72eb50a4124e80" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "functional_tests/test_orchestration_deletion_enrollment.py::test_cleanup_fences_and_enrolls_before_any_payload_sweep::point-seam-1": { + "boundary": { + "sha256": "71d12a59427f8279ba5887fad289581fc7cc7c597d50672102c3253ac3deda29", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "018189e9e54312fbb6e46a4761370d31cfa70f78621b47056c854117de855b91" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_deletion_enrollment.py" + ] + }, + "functional_tests/test_orchestration_deletion_enrollment.py::test_lost_parent_ack_has_real_guard_proof_for_missing_conversation_replay::point-seam-1": { + "boundary": { + "sha256": "dcc6542c722e5c4cda3d2e8c7fe32c243c2ce3428319734f1b8fe07243e3c5c4", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "018189e9e54312fbb6e46a4761370d31cfa70f78621b47056c854117de855b91" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_deletion_enrollment.py" + ] + }, + "functional_tests/test_orchestration_deliverables.py::test_the_approval_route_never_pays_twice_for_a_planned_image.Messages": { + "boundary": { + "sha256": "185603c419923e6a59ac652bf325f1d69e078281625d4eaa272ae673d45b1e15", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "5a172dca09372be6f191944f2ded71f1ffd21091325a2fc77a082de8eadb8daf" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_deliverables.py" + ] + }, + "functional_tests/test_orchestration_elicitation_context.py::MemoryContainer": { + "boundary": { + "sha256": "4c7512e8faa35eec8329abd247417a2c34ae132a19b3272256d833cc890d012c", + "methods": [ + "create_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8cc6cf8f8f8a4f8c5df25a27861d1632c4160c046cfb3e48acb1e6c217d50c3a" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_elicitation_context.py" + ] + }, + "functional_tests/test_orchestration_external_bootstrap.py::BoundedMemoryContainer": { + "boundary": { + "sha256": "d0b37f6c2d5e4054916b28f0a814f8db00c20d573ec485a79cf0843e57f8fbc9", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_external_bootstrap.py" + ] + }, + "functional_tests/test_orchestration_external_bootstrap.py::external_root::point-seam-1": { + "boundary": { + "sha256": "128a6979b10f4d6646c651bff76cdbd7ca18c2dbe2cef02cb29284f3d1ca1006", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_external_bootstrap.py" + ] + }, + "functional_tests/test_orchestration_external_bootstrap.py::external_root::point-seam-2": { + "boundary": { + "sha256": "8c3617de129777ab14269de13af1e1d0558e33c8dfa5f9d784ae2fd9ee90c481", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_external_bootstrap.py" + ] + }, + "functional_tests/test_orchestration_external_bootstrap.py::test_default_root_current_authority_storage_failures_are_operational::point-seam-1": { + "boundary": { + "sha256": "d6f8a585739ade682a621237de116c855149affcafa4937bb7c4fed543191deb", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_external_bootstrap.py" + ] + }, + "functional_tests/test_orchestration_external_bootstrap.py::test_identity_does_not_coerce_non_mapping_settings_into_authority::point-seam-1": { + "boundary": { + "sha256": "90c7d666e3fefb7404a9a64b64320dec2b8a1e4f47035ffbbbe17e0813ccb7e7", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_external_bootstrap.py" + ] + }, + "functional_tests/test_orchestration_external_metadata.py::RecordedContainer": { + "boundary": { + "sha256": "5aeae4f56eede4708fb864172f8da2aaee454efaa519f151c5541f266300481b", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [ + "OfflineContainer" + ], + "imports_sha256": "7e8e91dfa03d0f51193b0efedea4151fc296b477a4f3f77a670846ad86f7abfd" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_external_metadata.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_harness_strict_source_io_failures_remain_fenced_at_the_real_model_boundary::point-seam-1": { + "boundary": { + "sha256": "37998590203a13263aa03e900474a29a0e752cef8d5b23ca5f3a08c8dab307b0", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_initial_result_binding_outage_does_not_publish_a_terminal_outcome::point-seam-1": { + "boundary": { + "sha256": "c5ff4e5efcc4ad222aee835fc779775b80108c3b0b6cac7461bb47058894e15b", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_continuation_io_preserves_saved_work_for_retry::point-seam-1": { + "boundary": { + "sha256": "baaa4ce5df20663649b827a4920d91efda4cec0db088d1f5935d49ea361e9f95", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_external_runtime_callbacks_keep_signature_return_and_shared_service_identity::point-seam-1": { + "boundary": { + "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_external_runtime_callbacks_preserve_typed_failures_and_recheck_the_live_lease::point-seam-1": { + "boundary": { + "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_actual_preflight_preserves_current_metadata_failure_identity::point-seam-1": { + "boundary": { + "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_citation_delivery_rechecks_exact_sources_and_preserves_storage_uncertainty.recheck_source::point-seam-1": { + "boundary": { + "sha256": "c7f8bb94a1a8c1eff60c08adc0840bbc505c6eb74377671754ebc18c55a79c67", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_authority_infrastructure_never_becomes_a_headless_denial::point-seam-1": { + "boundary": { + "sha256": "1fe9e7710f877436ea9b8870308cf12b359df33d11262d1a03649f831ce5b520", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_checkpoint_read_outage_preserves_the_committed_file_before_publication::point-seam-1": { + "boundary": { + "sha256": "3b69833d6a85255c0bb6eba7f71253a0577f994f89fc1aa1a99e6bd11946c711", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_real_native_checkpoint_read_outage_does_not_poll_or_finalize::point-seam-1": { + "boundary": { + "sha256": "3586a71ead022f24807de996cb19caf838d1c453238971017baff7e28a856ca9", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_execution.py::test_execution_publication_authority_failure_closes_without_a_success_frame::point-seam-1": { + "boundary": { + "sha256": "c4ddbf15fb364bad038ea13c721bcc2b536f2ee7fd65210299fd114f0a169e62", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "7857eff202ead2d7d99709d4cbf86dc6fa434973b1610766dd332fe926a72794" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_execution.py" + ] + }, + "functional_tests/test_orchestration_harness_routes.py::test_bootstrap_metadata_reader_rechecks_real_owner_and_preserves_storage_failure::point-seam-1": { + "boundary": { + "sha256": "24b60080b3c3b0d12aef4e9eac73ea151d2e448b9b22775ccada900371586f9d", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "3df15877fc29acdf499a97880365631c96c2e7f57a793ff641394de3f38f64ec" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_routes.py" + ] + }, + "functional_tests/test_orchestration_harness_scheduler.py::test_scheduler_preserves_real_headless_authority_uncertainty::point-seam-1": { + "boundary": { + "sha256": "7b6ade42ce0aaa3cf1f1eae9bd68d413ac227e58c37b5ab02f3efecb0d06dd3d", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "111e3d3983d999c74da5dd9a09e82a4a89742653b0e383a2acd4a185a5b8bfb5" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_scheduler.py" + ] + }, + "functional_tests/test_orchestration_harness_scheduler.py::test_uncertain_admitted_output_preserves_minimal_step_wait_without_a_task::point-seam-1": { + "boundary": { + "sha256": "f9180769f49b8530a83e518f0ab96f6337154baefeb9daec3690d3c24b9523b3", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "111e3d3983d999c74da5dd9a09e82a4a89742653b0e383a2acd4a185a5b8bfb5" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_scheduler.py" + ] + }, + "functional_tests/test_orchestration_harness_scheduler.py::test_enrollment_restarts_after_a_process_dies_between_exact_output_tombstones::point-seam-1": { + "boundary": { + "sha256": "c2da4885e95daff94fd5ca52bcf4956bdc2a38b24bf329f9c30a92c1c192606c", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "111e3d3983d999c74da5dd9a09e82a4a89742653b0e383a2acd4a185a5b8bfb5" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_harness_scheduler.py" + ] + }, + "functional_tests/test_orchestration_image_references.py::test_candidate_computation_images_only_and_conversation_mismatch.Messages": { + "boundary": { + "sha256": "cdc61713da164f274594bbae0126dfff963e94cbf56ed47ba5e8ddb6b2d1c47a", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "5998a5c08f046abfc0fb031949b9999dd9cb866b6d81c1ae06156620090c6c95" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_image_references.py" + ] + }, + "functional_tests/test_orchestration_image_references.py::test_candidates_use_enriched_metadata_scopes_and_fold_uploads.Messages": { + "boundary": { + "sha256": "31043981f80bc924c4aeb73eeaf9dca056b89ef69ffc49790e49c99d8ae34dad", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "5998a5c08f046abfc0fb031949b9999dd9cb866b6d81c1ae06156620090c6c95" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_image_references.py" + ] + }, + "functional_tests/test_orchestration_initial_claim_recovery.py::test_initial_claim_persists_the_deadline_in_its_own_conditional_write::point-seam-1": { + "boundary": { + "sha256": "c74dd8d5b3ef150497d7929095733a5250ab34b2e170f7f957749111a4f507e2", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_initial_claim_recovery.py" + ] + }, + "functional_tests/test_orchestration_initial_claim_recovery.py::test_first_binding_reconciles_lost_acknowledgement_and_freezes_exact_value::point-seam-1": { + "boundary": { + "sha256": "9bafdca7440ca65fa0feccbbfc8af88413e0e403ef0a4d6ce190cff1a5d1b13a", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_initial_claim_recovery.py" + ] + }, + "functional_tests/test_orchestration_initial_claim_recovery.py::test_first_binding_cas_cannot_overwrite_a_concurrent_owner_or_stop::point-seam-1": { + "boundary": { + "sha256": "84116eaf3b5aa2bdd97132f173ab497926594348646d276191e795cba55e827a", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_initial_claim_recovery.py" + ] + }, + "functional_tests/test_orchestration_initial_claim_recovery.py::test_lost_initial_claim_acknowledgement_recovers_without_restarting_the_budget::point-seam-1": { + "boundary": { + "sha256": "9bafdca7440ca65fa0feccbbfc8af88413e0e403ef0a4d6ce190cff1a5d1b13a", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_initial_claim_recovery.py" + ] + }, + "functional_tests/test_orchestration_initial_claim_recovery.py::test_lost_first_binding_acknowledgement_cannot_adopt_a_successor_claim::point-seam-1": { + "boundary": { + "sha256": "07c559448bfca122d4a1e4399e851023283cea7cd9d9da7deb016fb40793cc81", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_initial_claim_recovery.py" + ] + }, + "functional_tests/test_orchestration_m365_actions.py::stub_modules::point-seam-1": { + "boundary": { + "sha256": "d91c96019afb7a1e76b21cde0832c2f483ce7eb6dd28756fe94d95ed70a1cf68", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "02d76403106789948241c5a6c6f142ee9bc0887b7ed4d286cf975d7c9113cc5e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_m365_actions.py" + ] + }, + "functional_tests/test_orchestration_native_infrastructure_failures.py::test_actual_pending_poll_transport_failure_preserves_original_wait::point-seam-1": { + "boundary": { + "sha256": "c6dd5b6be3fe538094b93795e72dcea4021a494b9df81033ae5ad99c3c2f8d78", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "fcd841881f01b91299486edba1f759e7d28d3979aabd56e936c30c5c4df4e26c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_native_infrastructure_failures.py" + ] + }, + "functional_tests/test_orchestration_native_infrastructure_failures.py::test_receipt_transport_uncertainty_is_not_absence_or_replacement::point-seam-1": { + "boundary": { + "sha256": "c2cf233ec239ea1cd9f42d83f61d73baa5673f7d2c9707092ac206dfea248212", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "fcd841881f01b91299486edba1f759e7d28d3979aabd56e936c30c5c4df4e26c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_native_infrastructure_failures.py" + ] + }, + "functional_tests/test_orchestration_native_infrastructure_runtime.py::test_native_wait_survives_transport_failure_and_finishes_the_original_job::point-seam-1": { + "boundary": { + "sha256": "ed54aa2d1661fe7c11af4d39268c4d21f1f4fa708b884fdf6d9c71ae3318d787", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "2ba59f1ce008c81c038c08335e14644bf487899a15382a488864b4171938dada" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_native_infrastructure_runtime.py" + ] + }, + "functional_tests/test_orchestration_native_infrastructure_runtime.py::test_scheduler_preserves_native_wait_and_recovers_after_actual_transport_outage::point-seam-1": { + "boundary": { + "sha256": "ed54aa2d1661fe7c11af4d39268c4d21f1f4fa708b884fdf6d9c71ae3318d787", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "2ba59f1ce008c81c038c08335e14644bf487899a15382a488864b4171938dada" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_native_infrastructure_runtime.py" + ] + }, + "functional_tests/test_orchestration_operation_runtime.py::test_saved_manual_draft_reference_crosses_bridge_before_receipt_failure::point-seam-1": { + "boundary": { + "sha256": "168061aa4c2b89f2593f679bfe73fc14cd2ff782856e101ae5b41895bb6d6034", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "cb6a0d336340e15616df2de2d26a66d50a6a7e8e533bf47d1d7f01b56bc35617" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_operation_runtime.py" + ] + }, + "functional_tests/test_orchestration_operation_runtime.py::test_receipt_conflict_retries_storage_not_the_effect::point-seam-1": { + "boundary": { + "sha256": "2045c0d623d225c9038b7b7a1f3d072990e5af0612e8bdbafc891fed8daf594a", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "cb6a0d336340e15616df2de2d26a66d50a6a7e8e533bf47d1d7f01b56bc35617" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_operation_runtime.py" + ] + }, + "functional_tests/test_orchestration_output_checkpoint_storage.py::checkpoint_failure::point-seam-1": { + "boundary": { + "sha256": "7de322490bb38b83502e4804974792304c9f1d82e28d6f82925d6dcaf27e5a31", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "6e33912aef2fd2ab18756059dc3bd8654dc866ed6cb7d231a4c781d28706a860" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_checkpoint_storage.py" + ] + }, + "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_rechecks_owner_before_deleting_bytes::point-seam-1": { + "boundary": { + "sha256": "4d98b4007b003fa25cd56538e007251cee606b3f5cf01dea62115892b26390ae", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "c919bfc5309975b0ea94d1b025d461c9afe52043e846fb9090149359ce182640" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_cleanup.py" + ] + }, + "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_message_delete_is_conditional_and_can_reconcile::point-seam-1": { + "boundary": { + "sha256": "48439c38770703ba79607d27a896fbc92a1e430f3ffb1903ef9f222609b0a43a", + "methods": [ + "delete_item" + ], + "kind": "seam", + "imports_sha256": "c919bfc5309975b0ea94d1b025d461c9afe52043e846fb9090149359ce182640" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_cleanup.py" + ] + }, + "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_finish_cas_preserves_uncertain_acknowledgements::point-seam-1": { + "boundary": { + "sha256": "50bd5bf58805c947653357cc0b956361e0bc6a3c1e5cb951574cf933d86d803e", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "c919bfc5309975b0ea94d1b025d461c9afe52043e846fb9090149359ce182640" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_cleanup.py" + ] + }, + "functional_tests/test_orchestration_output_deletion_pipeline.py::deletion_runtime::point-seam-1": { + "boundary": { + "sha256": "5ef121933122b1f6864820d2d82cfa18fdde0b679efdb101c6aaf4f6f6395b8e", + "methods": [ + "delete_item" + ], + "kind": "seam", + "imports_sha256": "f4240f0cb3140aac06864bd5788d2f1a1362ad435ce12004f89b6e264830328c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_deletion_pipeline.py" + ] + }, + "functional_tests/test_orchestration_output_deletion_pipeline.py::deletion_runtime::point-seam-2": { + "boundary": { + "sha256": "80f6898824794ba8e48185285f394c860b5b66592a28b3b32777a3be76a9bf28", + "methods": [ + "delete_item" + ], + "kind": "seam", + "imports_sha256": "f4240f0cb3140aac06864bd5788d2f1a1362ad435ce12004f89b6e264830328c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_deletion_pipeline.py" + ] + }, + "functional_tests/test_orchestration_output_deletion_pipeline.py::test_interrupted_deletion_enrollment_is_replayed_without_another_delete_request::point-seam-1": { + "boundary": { + "sha256": "dcc6542c722e5c4cda3d2e8c7fe32c243c2ce3428319734f1b8fe07243e3c5c4", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "f4240f0cb3140aac06864bd5788d2f1a1362ad435ce12004f89b6e264830328c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_deletion_pipeline.py" + ] + }, + "functional_tests/test_orchestration_output_deletion_pipeline.py::test_interrupted_deletion_enrollment_is_replayed_without_another_delete_request::point-seam-2": { + "boundary": { + "sha256": "91dbd5d9070c4e7a41848f7646bfe0c884cc98e2d21428adb6f8eed347464ca5", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "f4240f0cb3140aac06864bd5788d2f1a1362ad435ce12004f89b6e264830328c" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_deletion_pipeline.py" + ] + }, + "functional_tests/test_orchestration_output_enrollment.py::test_competing_enrollment_workers_keep_one_durable_fence_per_output::point-seam-1": { + "boundary": { + "sha256": "f65df07b3fbe134cd4474630b5d7a4e3812a8179d6a2409e7d7fd81599274692", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "4c2d210c3961eafe6e5c0ea4c9cf57660dec8e4b604583c6e3d77b2bb25b57d2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_enrollment.py" + ] + }, + "functional_tests/test_orchestration_output_enrollment.py::test_completion_marker_requires_persistence_and_reconciles_uncertain_ack::point-seam-1": { + "boundary": { + "sha256": "633c6c12e69eb3357e7a4b3a048d7082ea7aec4ad18afd83c92482749e7298db", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "4c2d210c3961eafe6e5c0ea4c9cf57660dec8e4b604583c6e3d77b2bb25b57d2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_output_enrollment.py" + ] + }, + "functional_tests/test_orchestration_output_lifecycle.py::OutputContainer": { + "boundary": { + "sha256": "688c05e3947507e7bde6564bc6edcf32d53037915fe56cc7e1c0961ac30eddad", + "methods": [], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "61b16b5b51ee64a8eb84296001992e7d4d6a879fcefde093b61f93ae6fb00fbd" + }, + "classification": "sdk-default", + "contract": "Lifecycle Cosmos containers return actual SDK point wrappers by default, with explicit plain compatibility; fixture-owned access callbacks normalize before strict producer authorization.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_orchestration_output_lifecycle.py::MessageContainer": { + "boundary": { + "sha256": "eb73f468c9aebb99d9d03f5126c9c353d09ebd7744620e09eda7282eac1a8946", + "methods": [ + "create_item", + "delete_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "61b16b5b51ee64a8eb84296001992e7d4d6a879fcefde093b61f93ae6fb00fbd" + }, + "classification": "sdk-default", + "contract": "Lifecycle Cosmos containers return actual SDK point wrappers by default, with explicit plain compatibility; fixture-owned access callbacks normalize before strict producer authorization.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_orchestration_output_lifecycle.py::test_process_loss_reconciles_intent_without_duplicate_visibility::point-seam-1": { + "boundary": { + "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "61b16b5b51ee64a8eb84296001992e7d4d6a879fcefde093b61f93ae6fb00fbd" + }, + "classification": "fault-injection", + "contract": "Explicit lifecycle point-write/read failure override; the named runtime regression verifies uncertain acknowledgements, ETag fencing, recovery, or bounded retries with SDK-default backing storage.", + "tests": [ + "functional_tests/test_orchestration_output_lifecycle.py::test_process_loss_reconciles_intent_without_duplicate_visibility" + ] + }, + "functional_tests/test_orchestration_output_lifecycle.py::test_uncertain_acknowledgements_are_success_only_after_authoritative_read::point-seam-1": { + "boundary": { + "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "61b16b5b51ee64a8eb84296001992e7d4d6a879fcefde093b61f93ae6fb00fbd" + }, + "classification": "fault-injection", + "contract": "Explicit lifecycle point-write/read failure override; the named runtime regression verifies uncertain acknowledgements, ETag fencing, recovery, or bounded retries with SDK-default backing storage.", + "tests": [ + "functional_tests/test_orchestration_output_lifecycle.py::test_uncertain_acknowledgements_are_success_only_after_authoritative_read" + ] + }, + "functional_tests/test_orchestration_output_lifecycle.py::test_stop_fences_every_publication_boundary_and_cleans_staging::point-seam-1": { + "boundary": { + "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "61b16b5b51ee64a8eb84296001992e7d4d6a879fcefde093b61f93ae6fb00fbd" + }, + "classification": "fault-injection", + "contract": "Explicit lifecycle point-write/read failure override; the named runtime regression verifies uncertain acknowledgements, ETag fencing, recovery, or bounded retries with SDK-default backing storage.", + "tests": [ + "functional_tests/test_orchestration_output_lifecycle.py::test_stop_fences_every_publication_boundary_and_cleans_staging" + ] + }, + "functional_tests/test_orchestration_output_lifecycle.py::test_commit_ack_and_recovery_read_loss_does_not_admit_another_attempt::point-seam-1": { + "boundary": { + "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "61b16b5b51ee64a8eb84296001992e7d4d6a879fcefde093b61f93ae6fb00fbd" + }, + "classification": "fault-injection", + "contract": "Explicit lifecycle point-write/read failure override; the named runtime regression verifies uncertain acknowledgements, ETag fencing, recovery, or bounded retries with SDK-default backing storage.", + "tests": [ + "functional_tests/test_orchestration_output_lifecycle.py::test_commit_ack_and_recovery_read_loss_does_not_admit_another_attempt" + ] + }, + "functional_tests/test_orchestration_output_lifecycle.py::test_persistent_manifest_failures_are_bounded_and_manual_reuses_exact_bytes::point-seam-1": { + "boundary": { + "sha256": "d3f0c12bf16613f094081342f326c6fdf14272b9837710f34ed10854f71b3577", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "61b16b5b51ee64a8eb84296001992e7d4d6a879fcefde093b61f93ae6fb00fbd" + }, + "classification": "fault-injection", + "contract": "Explicit lifecycle point-write/read failure override; the named runtime regression verifies uncertain acknowledgements, ETag fencing, recovery, or bounded retries with SDK-default backing storage.", + "tests": [ + "functional_tests/test_orchestration_output_lifecycle.py::test_persistent_manifest_failures_are_bounded_and_manual_reuses_exact_bytes" + ] + }, + "functional_tests/test_orchestration_output_lifecycle.py::test_persistent_manifest_failures_are_bounded_and_manual_reuses_exact_bytes::point-seam-2": { + "boundary": { + "sha256": "36d32c437e29a3a901deb26febdfc2c276ea4b9c26da4868e4b020f4e907dceb", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "61b16b5b51ee64a8eb84296001992e7d4d6a879fcefde093b61f93ae6fb00fbd" + }, + "classification": "fault-injection", + "contract": "Explicit lifecycle point-write/read failure override; the named runtime regression verifies uncertain acknowledgements, ETag fencing, recovery, or bounded retries with SDK-default backing storage.", + "tests": [ + "functional_tests/test_orchestration_output_lifecycle.py::test_persistent_manifest_failures_are_bounded_and_manual_reuses_exact_bytes" + ] + }, + "functional_tests/test_orchestration_plan_revision_routes.py::PlanRevisionRouteTests.test_storage_failure_does_not_publish_or_discard_previous_plan::point-seam-1": { + "boundary": { + "sha256": "4a31e910f226c3863439964a9c7d5030fa7f28a34872d685886a2cf2a56c55bc", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "6cd43b3e3802014fe852a9b7daa5f618e7c16cdb9f261b70522b907e24f322c2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_plan_revision_routes.py" + ] + }, + "functional_tests/test_orchestration_publication_policy.py::embedded-APPROVAL_PROBE::Messages": { + "boundary": { + "sha256": "9d00efeed0a0618fe94171eea2d94791baef086a596bfc99cbab09b8bd21e30a", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ab3b82810e6404ef9b0af93003923b75264ea4feaed33404df1f4b9064605e2e", + "embedded_source_sha256": "16d59c3efe36b5412dc98e128f4905e6870092ec9fb508ea905dc6c58d20a42a" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_publication_policy.py" + ] + }, + "functional_tests/test_orchestration_render_waiting_runtime.py::test_waiting_render_passes_full_checkpoint_to_public_resumer.observe::point-seam-1": { + "boundary": { + "sha256": "1cd995bf368b9ca03222758ada9076511e92f2bbba05b7ec7476aeae9745d1d0", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "3902ae6d69888dc1a63c08e5c5ab1f528df85f2346835d51e5f44ca69d3ac705" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_render_waiting_runtime.py" + ] + }, + "functional_tests/test_orchestration_render_waiting_runtime.py::test_initial_render_read_outage_preserves_admitted_wait_without_a_task::point-seam-1": { + "boundary": { + "sha256": "2545afafdf8fc320b2bd91ef95fee52b62023ba5a8104790f5f7afad290d025c", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "3902ae6d69888dc1a63c08e5c5ab1f528df85f2346835d51e5f44ca69d3ac705" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_render_waiting_runtime.py" + ] + }, + "functional_tests/test_orchestration_run_hydration_routes.py::_load_projections.UncheckedReplyMessages": { + "boundary": { + "sha256": "1c3733546915c19b2f6ba6c528c908399ee466e421be921f5b1e94b9044cab9a", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "2252a57ddf5c0a49498e46d69eddcc553511b699d1bc4de9a7475491d9f95f6a" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_run_hydration_routes.py" + ] + }, + "functional_tests/test_orchestration_shared_conversations.py::CollaborationMessages": { + "boundary": { + "sha256": "a7543cd2cf454403af1dcfe82af86528cf11b1b36c26633926f27620bb03170a", + "methods": [], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "b91d9d156c9c55cc819a7499feb9bd7b78933e3b0c653c91e4ab08450852c641" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_shared_conversations.py" + ] + }, + "functional_tests/test_orchestration_source_access.py::AuthorityContainer": { + "boundary": { + "sha256": "9513400f9f280bccfbd4cae5a830d35bc4c121299e56a647492b2ccdbc7c6a5d", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "0c76311787e2e1b7601506a0379d82dd0480a1421c462bd930a99bf67db1e01f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_source_access.py" + ] + }, + "functional_tests/test_orchestration_waiting_continuation.py::test_lost_claim_acknowledgment_reconciles_exact_submission::point-seam-1": { + "boundary": { + "sha256": "c89f8a8bb3c4d8cd89a3273b9f48db1a19acb14d5f6d9962d8126ab0fedd5348", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "a2fd3cdfd332347c4d487968a08d847dd8eaec6cf550eedadcb80ea9ae018f3b" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_waiting_continuation.py" + ] + }, + "functional_tests/test_orchestration_waiting_continuation.py::test_racing_claims_have_one_cas_winner::point-seam-1": { + "boundary": { + "sha256": "b3425dd4bfb5772fdc9683f1b663d3f6c7c4047dd1bb198b3b478f467257d88f", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "a2fd3cdfd332347c4d487968a08d847dd8eaec6cf550eedadcb80ea9ae018f3b" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_waiting_continuation.py" + ] + }, + "functional_tests/test_orchestration_waiting_continuation.py::test_cancellation_after_run_cas_finishes_without_dispatch::point-seam-1": { + "boundary": { + "sha256": "9a42fab524b7ba5ca9dc1e67aad2ab2b2400d49ce11ebeb8482a1115d121b4f8", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "a2fd3cdfd332347c4d487968a08d847dd8eaec6cf550eedadcb80ea9ae018f3b" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_orchestration_waiting_continuation.py" + ] + }, + "functional_tests/test_orchestration_workflow_handoff_routes.py::Items": { + "boundary": { + "sha256": "640ab0341ce6e42cee219747ca95c5b1e72009921c90b9bb03d37853e243414e", + "methods": [ + "delete_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "cd5e1c6a950561ef08c2232d14bb0bec24b383f0c14eba676c2053e588055bb9" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_workflow_handoff_routes.py" + ] + }, + "functional_tests/test_orchestration_workflow_proposal_routes.py::WorkflowStore": { + "boundary": { + "sha256": "9b4096e65d001610a4d9520e5d4c8e2e88a68c15b9d09c39cbb5091450a42e24", + "methods": [], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "70a0a1f2bdbe595501af7d20a94fe7b3c0915c04aade509b350a33bd1f2bf840" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_workflow_proposal_routes.py" + ] + }, + "functional_tests/test_orchestration_workflow_proposal_routes.py::RunStore": { + "boundary": { + "sha256": "fa5d98bd4a3615005d4b7d77346ab748a785887a56b5112a93f49c90389b1724", + "methods": [ + "replace_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "70a0a1f2bdbe595501af7d20a94fe7b3c0915c04aade509b350a33bd1f2bf840" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_workflow_proposal_routes.py" + ] + }, + "functional_tests/test_orchestration_workflow_results_answer.py::_RecordingThoughtsContainer": { + "boundary": { + "sha256": "aa616b7bb0cbbdb4311000d9ea49ead6d5cc7479afa3059e66c6c8802f9e0388", + "methods": [ + "create_item", + "patch_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "1bfe2691b537fcee1935841aa1a62569b08ac1c1db2b98929ff5a12d418ccf46" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_workflow_results_answer.py" + ] + }, + "functional_tests/test_orchestration_workflow_results_reads.py::test_point_reads_raise_retryable_failure_for_cosmos_errors_and_not_found_is_none.FailingContainer": { + "boundary": { + "sha256": "5fefba32c62ccd7944513e02e91ef795414e75e8a143b27b968107c569cb825f", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f0a32fc88f104db9c6e88d416eceaf3acc4e9c835722ccdbbbeb95f439de4bab" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_workflow_results_reads.py" + ] + }, + "functional_tests/test_orchestration_workflow_run_adapter.py::Items": { + "boundary": { + "sha256": "ce586a8e335f2db2f238012bdee116df8e3874236b64cd01628b8c211b15cc78", + "methods": [ + "delete_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "aa0f596827dcaf54819f20b0b8e247d5ae787abe2877d66e8fa953ab555435bb" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_workflow_run_adapter.py" + ] + }, + "functional_tests/test_orchestration_workflow_run_link_routes.py::Reads": { + "boundary": { + "sha256": "2f95e9bf5d4d894bada0f68a7fb2d28e5aad633129d64284222b6a29fef5c371", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "2106e2afa21601aa4996556171a1bc1934cc3e7b25c41e993f337a7b542bc1f7" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_workflow_run_link_routes.py" + ] + }, + "functional_tests/test_orchestration_workflow_run_wait_delivery.py::_Interleaved": { + "boundary": { + "sha256": "f6a8f88597c03c7ef95d385e7ca6507bdab90b4cf623fea1184011544af54178", + "methods": [ + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "94f024450e0625b75fc6507342279ef0e026bb698cafec9b456e906bbc1573ae" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_orchestration_workflow_run_wait_delivery.py" + ] + }, + "functional_tests/test_personal_conversation_followup_authorization.py::FakeConversationContainer": { + "boundary": { + "sha256": "fe8a9189d10707e1bda8a15039b23465d5dba637b7586b0539c675bbac56c8ab", + "methods": [ + "delete_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "86c4cca6541f56f0af6abb3052056ec171f4e6958298fe0c88e9c2d596411b8b" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_personal_conversation_followup_authorization.py" + ] + }, + "functional_tests/test_personal_conversation_followup_authorization.py::FakeMessageContainer": { + "boundary": { + "sha256": "728fb97860424e1741a6de7e87635d9d602888fbbd483e4c4190ea9c578074a3", + "methods": [ + "delete_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "86c4cca6541f56f0af6abb3052056ec171f4e6958298fe0c88e9c2d596411b8b" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_personal_conversation_followup_authorization.py" + ] + }, + "functional_tests/test_personal_identity_apis.py::test_raw_provider_error_is_not_returned_or_logged::point-seam-1": { + "boundary": { + "sha256": "79b03a2de3e722274e2f07283f8c3d45a94577d208f4801cc962621b2d2919c0", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "3e9ee2a38089b2422b2148860f5db37740cbe7d3e603249892c2b9c588d37b26" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_personal_identity_apis.py" + ] + }, + "functional_tests/test_personal_prompt_helper_user_id_fix.py::FakeContainer": { + "boundary": { + "sha256": "52a078239fcfe8a9904636f05b901bb13481277099f79b368b154b2b168e1ae5", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "a5f4609d1c132f694da212a0d8a657ea8e4b744b47ed2857fc1cbda519125212" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_personal_prompt_helper_user_id_fix.py" + ] + }, + "functional_tests/test_profile_last_login_activity_logs.py::FakeActivityLogsContainer": { + "boundary": { + "sha256": "1b69f35277fc478565867357358375a4720f594e39d2787d84b63d86f925ada8", + "methods": [ + "create_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "caaaa1f705eaef457ac92192aac6b0031c130d745a018a6c2d97f2276c6e6612" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_profile_last_login_activity_logs.py" + ] + }, + "functional_tests/test_prompt_variable_knowledge_fill.py::load_service::point-seam-1": { + "boundary": { + "sha256": "0ef107a271d121b886c1b860b73636be4bddaa481d5d65f26c4c1d5f07dea181", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "65918600cb8603b3684cd3e82b78d6eae50f236230ac7897f44750cc2684d74d" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_prompt_variable_knowledge_fill.py" + ] + }, + "functional_tests/test_public_document_management.py::MutablePublicContainer": { + "boundary": { + "sha256": "c8ac20b992a807a6cba029e75aae0dda69413daa1199afd44210e7fb258c2ed2", + "methods": [ + "create_item", + "delete_item", + "patch_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "553880db3d361da0fefbd82a9923ebaf754aa8bfcaeddd65ef080842b654a066" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_public_document_management.py" + ] + }, + "functional_tests/test_public_document_publication.py::PublicReceiptStore": { + "boundary": { + "sha256": "55d9a5c0dfa0859f9ced09bc1709dbae8fdeab62641f93a7022d27e4a34152b4", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3be037889ed7649e935c9f7a794bf8fb9b7d212c5c383592d9ef08420f4f2394" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_public_document_publication.py" + ] + }, + "functional_tests/test_public_document_read_apis.py::PublicReadOnlyContainer": { + "boundary": { + "sha256": "9c2b253f5898a7f60c62cdff69197ecd431386fd5e4e046a1067264fd67b7f7e", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "fd60f38240bd02ed5628fe66a52f28316bb13d47de3c27d21d561428c726aee5" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_public_document_read_apis.py" + ] + }, + "functional_tests/test_public_membership_apis.py::environment::point-seam-1": { + "boundary": { + "sha256": "e53281544bb8ce30cd861c5ef001c94eadbb432b24fa6188265495d82b35312f", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "29d3b45c4b554eed9e01366d594a64f81bcdda326b1d06d96c622ede62450aa5" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_public_membership_apis.py" + ] + }, + "functional_tests/test_public_settings_apis.py::test_a_storage_failure_mid_write_is_a_data_free_500::point-seam-1": { + "boundary": { + "sha256": "876e334126568b88417f7e3caaa2ef3c511e83f0e411571723803d88242d5898", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "1de2ac45b23d24591878948507b46cdea5c3951030d36ec0685d667604bec7d2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_public_settings_apis.py" + ] + }, + "functional_tests/test_public_settings_apis.py::test_an_unexpected_failure_is_a_logged_data_free_500::point-seam-1": { + "boundary": { + "sha256": "6cfd8b50869ba0e5b9445eecbb29c0cb71a5f07ec8aaac8d5c5a0c9a2664c4ca", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "1de2ac45b23d24591878948507b46cdea5c3951030d36ec0685d667604bec7d2" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_public_settings_apis.py" + ] + }, + "functional_tests/test_public_workspace_document_write_guard.py::test_a_lost_response_is_recognised_rather_than_retried::point-seam-1": { + "boundary": { + "sha256": "86dfbc50644298b9523ceee89c26457feab5d8e6a8eadfeff6afd2637a9ccd11", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "1cbff1f986cafff0175ca013ec8a12b85c3cbefc60b18d63a3e111dd0e7f737b" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_public_workspace_document_write_guard.py" + ] + }, + "functional_tests/test_retention_policy_conversation_scope_coverage.py::FakeContainer": { + "boundary": { + "sha256": "bf0960d429edc9fb43de204a2634f5681c41ecababa729380eba6fb0d9c5bfc0", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "52fe388cbbefd532e268c2c92c5563e4b1d0e3951d48ff2ca05882104b01a0d9" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_retention_policy_conversation_scope_coverage.py" + ] + }, + "functional_tests/test_rocksdb_plugin.py::FakeConfigCosmosContainer": { + "boundary": { + "sha256": "5b8cac6bb9f86d6868431c2d5e6d65b2a89a9aa4b34fa3d68e3668504409c964", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "5f129d82d468ad9058c1f26a0314edc0fe3260d85ce747ba22111117ac5bde5e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_rocksdb_plugin.py" + ] + }, + "functional_tests/test_security_authorization_hardening.py::test_chat_route_enforces_conversation_ownership_and_scope_canonicalization.DummyConversationContainer": { + "boundary": { + "sha256": "ed7161c569341d19501e2f90382864b167f7d20c7d0895f95d87639dd04ae38c", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "e69f9b80206b5eba6ef5545422ac1ff905224dfd4c479f7d81c794a3b612bf31" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_security_authorization_hardening.py" + ] + }, + "functional_tests/test_simplechat_conversation_messages.py::FakeConversationsContainer": { + "boundary": { + "sha256": "4c1886ca8ab93f6433e126fe90ba050ace06d3f41d7d54fb1ccf09397465d12f", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7c7abfdc44f1e5d4e8ced6c2a78c25822c15dd90c776e97f44c01ffc52f9335d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_simplechat_conversation_messages.py" + ] + }, + "functional_tests/test_simplechat_conversation_messages.py::FakeMessagesContainer": { + "boundary": { + "sha256": "48763810c271c509cd3b372047040dfec14d562a4ea9676fcab3dc5a8a7850a4", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7c7abfdc44f1e5d4e8ced6c2a78c25822c15dd90c776e97f44c01ffc52f9335d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_simplechat_conversation_messages.py" + ] + }, + "functional_tests/test_simplechat_operation_notifications.py::StubContainer": { + "boundary": { + "sha256": "3f12a4bb38227ddaf2ceb5fd9e3d005b65fbadcf59f29c09bfc9348892031187", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "85e9373e33822927deb4e79332016dec63ff56525a97538e9503dfda24fd6b74" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_simplechat_operation_notifications.py" + ] + }, + "functional_tests/test_sql_plugin_key_vault_secret_storage.py::FakeActionContainer": { + "boundary": { + "sha256": "a7023cb419a1bad1c04354738f7d957e762da185e598dece6e8d2a650f209fb4", + "methods": [ + "delete_item", + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7b48f862c9a51e1e2b67dbe757522ef29a09e3a1940ef28adebb5c38a022ee44" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_sql_plugin_key_vault_secret_storage.py" + ] + }, + "functional_tests/test_tableau_action_plugin.py::FakeConfigCosmosContainer": { + "boundary": { + "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "bf685435a91b4b88b84e9dcb47ef4f0860c6faa5f09ad75b9050b3617f47ced8" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_tableau_action_plugin.py" + ] + }, + "functional_tests/test_tabular_queue_run_output_schema_end_to_end.py::_FakeCosmosContainer": { + "boundary": { + "sha256": "a6fca6a663cd503746df9209bbe986637c9b339f8b0de77355116b77080d750e", + "methods": [ + "create_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f76480f3218706bf5a95c4b26e5cf730bd2af6f0024cd3f2e5e892b48b6711ec" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_tabular_queue_run_output_schema_end_to_end.py" + ] + }, + "functional_tests/test_tabular_row_orchestration_scale.py::_load_authorization_helper.ConversationContainer": { + "boundary": { + "sha256": "b656b8f254da0c8746843906a8871855c5a7b656bfba5ca1fdcc00cd39a17706", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8198d007039a1094adcd7f86359db494845287c17765bcdb66512d0fc62ab1ca" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_tabular_row_orchestration_scale.py" + ] + }, + "functional_tests/test_tabular_row_orchestration_scale.py::_load_idempotent_artifact_helper.ConversationContainer": { + "boundary": { + "sha256": "aec92e109c9c9a8b1a1808bb073d795b6de37171a8c44fa4dc765477bec689f5", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8198d007039a1094adcd7f86359db494845287c17765bcdb66512d0fc62ab1ca" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_tabular_row_orchestration_scale.py" + ] + }, + "functional_tests/test_tabular_row_orchestration_scale.py::_load_idempotent_artifact_helper.MessageContainer": { + "boundary": { + "sha256": "23f58333ddba97d954a2074ee01fe7a7ecc4b1df265d33b43a123c3903957582", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8198d007039a1094adcd7f86359db494845287c17765bcdb66512d0fc62ab1ca" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_tabular_row_orchestration_scale.py" + ] + }, + "functional_tests/test_user_plugin_bulk_save_id_preservation.py::UserPluginBulkSaveTests.test_missing_legacy_graph_id_is_rejected_before_batch_mutations::point-seam-1": { + "boundary": { + "sha256": "213031f1dc7d7bc9429878c86bd0f96a0354073136644a91f854986c2833600d", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "30c41490fef19beb45c043ba7cfc836d1a1316d111c12455e66a929cd99f40e4" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_user_plugin_bulk_save_id_preservation.py" + ] + }, + "functional_tests/test_user_plugin_bulk_save_id_preservation.py::UserPluginBulkSaveTests.test_non_missing_storage_errors_are_not_treated_as_absent_legacy_actions::point-seam-1": { + "boundary": { + "sha256": "213031f1dc7d7bc9429878c86bd0f96a0354073136644a91f854986c2833600d", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "30c41490fef19beb45c043ba7cfc836d1a1316d111c12455e66a929cd99f40e4" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_user_plugin_bulk_save_id_preservation.py" + ] + }, + "functional_tests/test_user_profile_idor_authorization.py::FakeUserSettingsContainer": { + "boundary": { + "sha256": "aaf17c1fad63a1cbc086c03af5e1f4885976385db5f5d36428c41a1340ac91a2", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "52a1c67bbbf2112e7bd8c132bc6fc02842692c4c91a3eea489b6c9445ebab05f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_user_profile_idor_authorization.py" + ] + }, + "functional_tests/test_user_profile_idor_authorization.py::FakeCollaborationStateContainer": { + "boundary": { + "sha256": "a329a9283868db39d91646deadaed6d1d82bbd45aa3fa92fdc7f0605c3734f1e", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "52a1c67bbbf2112e7bd8c132bc6fc02842692c4c91a3eea489b6c9445ebab05f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_user_profile_idor_authorization.py" + ] + }, + "functional_tests/test_v2_admin_global_editor_backend.py::FakeContainer": { + "boundary": { + "sha256": "8a18e563f259b24982d9d376f5b1b62b3f3991c680b00336df6f219197bb45f7", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ebfd6076aac71e8b0a86469a0bc0360ab0bb0ce472e6011270b27e04ab0fda80" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_admin_global_editor_backend.py" + ] + }, + "functional_tests/test_v2_collaboration_visual_style_fix.py::_FakeMessageContainer": { + "boundary": { + "sha256": "7ed6f533c1b4f7a0666448c9088cb25a5398ebf7faca1c1fafbb27b8fa7152cd", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8b4ca01eb97401ef4a0808851b58fc24c56bc5ece1d729320bae3b71cd04883c" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_collaboration_visual_style_fix.py" + ] + }, + "functional_tests/test_v2_collaboration_visual_style_fix.py::_get_conversation_kind._PersonalContainer": { + "boundary": { + "sha256": "9f8bcecc2673289fa2f0699c415871f97d0f0355c3cbc285ac3d1e7a5aef24d9", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8b4ca01eb97401ef4a0808851b58fc24c56bc5ece1d729320bae3b71cd04883c" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_collaboration_visual_style_fix.py" + ] + }, + "functional_tests/test_v2_control_center_action.py::ReadOnlyContainer": { + "boundary": { + "sha256": "7d0d527d78b9c9473ad3e677c08da38f3bb3dcff18e57eccf0e8af1363647005", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b7a9494603b7a946ce16f34b3c95e734abb3bbd73b5c3e1771e80a0625f53157" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_control_center_action.py" + ] + }, + "functional_tests/test_v2_control_center_dashboard.py::GuardedContainer": { + "boundary": { + "sha256": "f9b8382d33afbfc0da09c13903b8d594d515045bb23350f6dbb496b6a9698413", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c29f8cc17c8423139ab1a21ce838113b0bbef1f4e88ac4bc45171c5c08018945" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_control_center_dashboard.py" + ] + }, + "functional_tests/test_v2_control_center_groups.py::InventoryGroups": { + "boundary": { + "sha256": "12d5e47dfce596cb4efb500a5592f87cdfcaaa978e3bab3ce03325adcdb88c5d", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "729f134ef8f677932a9806e061fcebdaeb726749bebc785ff85d9498fa32142b" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_control_center_groups.py" + ] + }, + "functional_tests/test_v2_control_center_public_workspaces.py::WorkspaceQueries": { + "boundary": { + "sha256": "71f20d3205f2498135ec002acae340041e3ac29d9cfd5605ece54ca6c1d8d4fe", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b0be7393816a11d5bcaf8c60aa9bc0f8635618fcc8098c158bf8e21099442044" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_control_center_public_workspaces.py" + ] + }, + "functional_tests/test_v2_control_center_public_workspaces.py::Activity": { + "boundary": { + "sha256": "f08ef79d3cc5d5947ee69598873482d9b0eef0c373d88d226e840751144bd79f", + "methods": [ + "create_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b0be7393816a11d5bcaf8c60aa9bc0f8635618fcc8098c158bf8e21099442044" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_control_center_public_workspaces.py" + ] + }, + "functional_tests/test_v2_prompt_attachment_persistence.py::MemoryContainer": { + "boundary": { + "sha256": "f93430525a16921d70dcf172593288b5d2a4fc29619d52609706ea0785af8559", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "88a9b01c59258447569e3e3bf72a05a3a1ec0664a7e52d50e13702c63470a748" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_v2_prompt_attachment_persistence.py" + ] + }, + "functional_tests/test_workflow_alert_acknowledgment.py::FakeContainer": { + "boundary": { + "sha256": "b499cbc2c7af40718a1dca29632e5fbb8a1d5c90c0fbd72a2d6b4332c8565889", + "methods": [ + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "cbb43631c791f9a30f45caab035849574ceb86918565f23511dbe8204c0e02ad" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_alert_acknowledgment.py" + ] + }, + "functional_tests/test_workflow_assist_dry_run_parity.py::test_a_store_outage_is_a_503_never_a_missing_workflow.Failing": { + "boundary": { + "sha256": "5ec6e8adae198f392a26146e8bafa4f05211c5f2e5d91b5d4b4a90bc3765ecca", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "8d858efc9fd7424f21698e3bb47cb5be807002316da7c28bd047e02fffd966be" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_assist_dry_run_parity.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::ScriptedContainer": { + "boundary": { + "sha256": "2ae1de9e90a65a00d7bfd2aa2c178507be6ba08a5d9a6d027ddf9cf36fd43feb", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::test_the_store_reads_a_document_in_its_own_partition::point-seam-1": { + "boundary": { + "sha256": "01796adcaab17e27767db173c476d7b65e0e551c084728a2c6fd02d495fb4048", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::test_the_store_reads_a_document_in_its_own_partition::point-seam-2": { + "boundary": { + "sha256": "ff700980fe829bb9446ae752ada44ef208083e24d6cb18ab1fabfc15e2220b02", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_store_that_cannot_be_read_is_down::point-seam-1": { + "boundary": { + "sha256": "515891896b3fb6be0b962075132c4811f6300dd779848157a719c95e48a77fc4", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_create_that_finds_the_document_lost_a_race::point-seam-1": { + "boundary": { + "sha256": "146e5d7a517044d78b1c8a0de5f7a4916bd415a173178a073f28f4b655e4f231", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_create_that_fails_otherwise_is_the_store_being_down::point-seam-1": { + "boundary": { + "sha256": "8f7cb89055d77297a0a20f53739c62a4b97598a84454eab6ae5dcd43ccd3374c", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_replace_that_finds_another_write_lost_a_race::point-seam-1": { + "boundary": { + "sha256": "33d15ef637120178faac825ae93b3ca68da301769de95dd41f7e99a4e396faca", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::test_a_replace_that_fails_otherwise_is_the_store_being_down::point-seam-1": { + "boundary": { + "sha256": "ba8e5303562bb824dc89501de3ee7140ad4597343492f61ab757526f76a8283f", + "methods": [ + "replace_item" + ], + "kind": "seam", + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::ReadOnlyContainer": { + "boundary": { + "sha256": "300b20b8d364afb276133ddeb0eba0180b98871ece6186b646aabdf098891849", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_assist_limits_runtime.py::LimitContainer": { + "boundary": { + "sha256": "89d9f0fe5fb8f133ed3d402ffbfd702708713b879dc803ee9ade6cc58401759c", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_assist_limits_runtime.py" + ] + }, + "functional_tests/test_workflow_background_identity.py::UserSettingsContainer": { + "boundary": { + "sha256": "b4351853b0bb2a1c8e1a9e63dbd4bad226a6628e37a5b02287effe8b1e0b6bc2", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "b9e0c0a864e1daa5e1228d87e8d77d50aab75f84d636337446a3c570c1cd632a" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_background_identity.py" + ] + }, + "functional_tests/test_workflow_chat_delivery_concurrency.py::_barrier_first_run_reads::point-seam-1": { + "boundary": { + "sha256": "b8812329490aaacfc5917dad8e0a6e83bd661e38f23a53d5ae6674d6623d8e25", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "2fa623188ead79cd93344530e21b8b9c46f51d862bfb0e31bd41ef7b6bc52b60" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_chat_delivery_concurrency.py" + ] + }, + "functional_tests/test_workflow_chat_delivery_imports.py::embedded-PROBE::OfflineContainer": { + "boundary": { + "sha256": "2ced1cb8515091d014b91a2d9d9a25ab47b38f6e2feb4b2225ca02448a526ec5", + "methods": [ + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c1b9e78b8e586d8131ac392959bc67d29d5a828caca291cd5384816f3164b844", + "embedded_source_sha256": "30c96313d86b231a68225fa7f6ad5418dab3101d5bdd02bbf9b148e8b915650d" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_chat_delivery_imports.py" + ] + }, + "functional_tests/test_workflow_chat_delivery_off_golden.py::_capture::point-seam-1": { + "boundary": { + "sha256": "cc1e17e979336948070072f1ba5398afc1dceb8a8886f2d45269c4f55cb2186d", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "e666ba8178673d9a34345318c56b116a192a45a501d605863c1ebac4586ff837" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_chat_delivery_off_golden.py" + ] + }, + "functional_tests/test_workflow_definition_concurrency.py::Container": { + "boundary": { + "sha256": "90990ab76f9d8303a91ed42fccdaaa171f176826f7a9d8f089246cb651ed599d", + "methods": [ + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "21c9f4676f46cc28b1b5f6780c041177a914ac396ec1701436ce8b9339e2a658" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_definition_concurrency.py" + ] + }, + "functional_tests/test_workflow_definition_store_integration.py::WorkflowContainer": { + "boundary": { + "sha256": "372d6981fa4a40a3f65876a57bca6f9a92cd1272508d520468271723998c3f6d", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "97ed2d984bec77c1f515cfda166a6d6388dbe17011de595616da6c48b4e65c18" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_definition_store_integration.py" + ] + }, + "functional_tests/test_workflow_draft_service.py::test_a_failed_orchestration_count_fails_closed_wherever_the_cap_is_checked::point-seam-1": { + "boundary": { + "sha256": "8e9f032b660c6a86ec2b45645f105082e3389402993d1edb694b186a161ac6ee", + "methods": [ + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "6287d944e84245244686bbfb6273ae87b4e26a6a3f81d4d66170f540b90bde39" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_draft_service.py" + ] + }, + "functional_tests/test_workflow_durable_analysis.py::test_run_deletion_fences_never_prepared_and_existing_analyze_work::point-seam-1": { + "boundary": { + "sha256": "19506aac88f28a7097cf6ddf7314214013d73d409c40ff8ac99f39eafa76127c", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "230f9f7f5bb87187d9b693a5a90fb9369d9228744c2219534812cb6a73bdc1c7" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_durable_analysis.py" + ] + }, + "functional_tests/test_workflow_durable_execution.py::RuntimeContainer": { + "boundary": { + "sha256": "d453ac096807c6d57f558e7d10d0da3cb95b918a2383b8535dc7af190d9d1a2b", + "methods": [ + "create_item", + "execute_item_batch", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "d383d01c3eb7d59a65a932bbc66a9c5c1267e879d65fe3e78e13c050b9b28be0" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_durable_execution.py" + ] + }, + "functional_tests/test_workflow_for_each_execution.py::LoopJournalContainer": { + "boundary": { + "sha256": "4a6a066abde7e9c8d168437020c752db50a467742b3d105a8ad6b10d8e42ed1c", + "methods": [ + "execute_item_batch" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "d219351506bf861959b49538dfaca850e487b37839427dc51a2594057597118b" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_for_each_execution.py" + ] + }, + "functional_tests/test_workflow_handoff_end_to_end.py::e2e::point-seam-1": { + "boundary": { + "sha256": "5f2a0c606bcd0689cac7cfa0007d7c9b8199d52d5d0d4ad8e836cb391d63d97a", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "seam", + "imports_sha256": "5c190ba958ce7ab245b1311ceda3ff4188e5ff764b0508cb3c3303fcdc0962e5" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_handoff_end_to_end.py" + ] + }, + "functional_tests/test_workflow_loop_inputs.py::Container": { + "boundary": { + "sha256": "d5707e097bcdc17aef8dac6729e92f495bad81597d0eb1eeb277073a11094fb5", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "63f11121d5874fb7d1ce566835672c58373e395aea349525048fdda857777618" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_loop_inputs.py" + ] + }, + "functional_tests/test_workflow_plan_replay_execution.py::RuntimeContainer": { + "boundary": { + "sha256": "b3e84347ac22ff216726d85acbbefb3c890d325f191ae81eae9a8a4ee5aec729", + "methods": [ + "create_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "975f1a19080aa9f4e0f57fc5542be8f09725fdba1d60fd80f5533aa85884b731" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_plan_replay_execution.py" + ] + }, + "functional_tests/test_workflow_plan_replay_routes.py::WorkflowStore": { + "boundary": { + "sha256": "f7f998efe192e093fa73d6945ef05dc8ebe167e72fec2279ea0e1d5a4d9f8ccb", + "methods": [], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "017f7cbc10254614ffda8feea31ab921b6e54b2166e26cdbc4c3a33b6fcd5a01" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_plan_replay_routes.py" + ] + }, + "functional_tests/test_workflow_plan_replay_routes.py::test_a_store_failure_is_a_fixed_error_without_detail::point-seam-1": { + "boundary": { + "sha256": "a24bdb745cd5313beeb0ec09c6d5a5473a26df1951e989af03f250985de96b60", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "017f7cbc10254614ffda8feea31ab921b6e54b2166e26cdbc4c3a33b6fcd5a01" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_plan_replay_routes.py" + ] + }, + "functional_tests/test_workflow_private_analysis_records.py::Items": { + "boundary": { + "sha256": "46ab13715088760b2c98584ff5775c251d099d68d3ae68ef06fd9b40840b368c", + "methods": [ + "delete_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f806a6edf408a96e39ca0c4f1ec16a0615608f06db05b86c9517d118b96b241f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_private_analysis_records.py" + ] + }, + "functional_tests/test_workflow_repeat_recovery.py::test_lost_acknowledgement_does_not_duplicate_transitions_or_grants::point-seam-1": { + "boundary": { + "sha256": "34120c4d3fa4b52e4d18a9f5335db563e1c2258be45aeb464bfa54562627abc6", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "ee797e9a3cc2dbea12bfe42d6c2cc96a0f527e697b9d6bf55d8358165a05372f" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_repeat_recovery.py" + ] + }, + "functional_tests/test_workflow_reply_replaces_agent_posted_message.py::FakeContainer": { + "boundary": { + "sha256": "c3b916df13bfea644be4f03a68eecab3ce723c46de0e1edf85d3481386c8c43f", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "4e5bdb498c9bbd6ef72c205986af9dbfb8d4e68f726b7bdcdbc402b24b630119" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_reply_replaces_agent_posted_message.py" + ] + }, + "functional_tests/test_workflow_result_followup.py::Messages": { + "boundary": { + "sha256": "5c9d9857711e0f7f092acfd767ffc90faa6c65399a95c932a87bbec96e9867cf", + "methods": [ + "delete_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "309de0e9b44636c618819f3fe1e59b3584c2ca456b5c5e747f42290d730e06de" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_result_followup.py" + ] + }, + "functional_tests/test_workflow_result_store.py::FakeCosmosContainer": { + "boundary": { + "sha256": "134cf9be5f9422b71512c5092bbb46e0b73d41ddbaa0757cbe333e51c1c8c4d6", + "methods": [ + "create_item", + "delete_item", + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "d98517ba1cdf0c474561f926607eb6e8e8cc41455038e48496df17ef25700f9d" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_workflow_runtime_integration.py::ServiceContainer": { + "boundary": { + "sha256": "cf6b60969a853df82d4c46e03f98b8c17ea513eb53f1458a156eb01a97d03ac7", + "methods": [ + "create_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7ecf456dc7fe3d8c91c650bc09e43f8cb3551a9fa62e18d457800b0e79c1aad9" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_runtime_integration.py" + ] + }, + "functional_tests/test_workflow_runtime_store.py::FakeCosmosContainer": { + "boundary": { + "sha256": "5bebc7079a8a0e7a9d83626b44e2446392dd25e50ede4a5b00a3618fb048e500", + "methods": [ + "create_item", + "execute_item_batch", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c3cb22a3e4db31cecd8c5058f9ac3ac6d5632bb72bbd2aa572f8b5860f1af372" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_workflow_saved_output_artifacts.py::artifact_services::point-seam-1": { + "boundary": { + "sha256": "88e323862b49245a57a65c78d457bc54742113f456dadb842d15a567e7ed8cfe", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "d9b500c558082888ff2b1402d4ee41f1d5c4a4cc312a0242abe44f4c17a81e53" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_saved_output_artifacts.py" + ] + }, + "functional_tests/test_workflow_saved_output_artifacts.py::test_lost_acknowledgements_reuse_the_prepared_bytes_and_address.lose_message_ack::point-seam-1": { + "boundary": { + "sha256": "f37c0f95b9d4d4e01b58f1e4c30503ef75ee760dc9924b88c074a6c7bcc2a99b", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "d9b500c558082888ff2b1402d4ee41f1d5c4a4cc312a0242abe44f4c17a81e53" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_saved_output_artifacts.py" + ] + }, + "functional_tests/test_workflow_saved_output_artifacts.py::test_lost_acknowledgements_reuse_the_prepared_bytes_and_address::point-seam-1": { + "boundary": { + "sha256": "3677403bbadd3109fc734b2e8e284b2f2fe716fc3e7bd0a657f1f60336ce8365", + "methods": [ + "create_item" + ], + "kind": "seam", + "imports_sha256": "d9b500c558082888ff2b1402d4ee41f1d5c4a4cc312a0242abe44f4c17a81e53" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_saved_output_artifacts.py" + ] + }, + "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_delete_during_the_save_is_the_same_409::point-seam-1": { + "boundary": { + "sha256": "391b0532e53023d7867d4d155574f3be7f7bc37a5766bf94bd23f3ae6107df69", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "8db98064e1188c3c58aa730d8baae6731ae083eef71d64ff7313d22126f73686" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_settings_reviewed_messages.py" + ] + }, + "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_transient_read_failure_is_never_reported_as_a_deletion::point-seam-1": { + "boundary": { + "sha256": "ae7494c17a0c289cf186712d7d00626e5c235d776b17014dc30f45c2043cba49", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "8db98064e1188c3c58aa730d8baae6731ae083eef71d64ff7313d22126f73686" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_settings_reviewed_messages.py" + ] + }, + "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_lookup_that_fails_once_keeps_the_existing_conflict::point-seam-1": { + "boundary": { + "sha256": "0f68eb7720083ca755f15be2079b1936a946a01f2b48ba93defd2a5c51297bb9", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "8db98064e1188c3c58aa730d8baae6731ae083eef71d64ff7313d22126f73686" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_settings_reviewed_messages.py" + ] + }, + "functional_tests/test_workflow_structured_flow.py::JournalContainer": { + "boundary": { + "sha256": "01514881bead31139c1161bba38877149579962b4833c64181670728455e676a", + "methods": [ + "delete_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "d71c9069216784edf8fad46ad7a2520586855ede132dc4320e8a15e34f055000" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_structured_flow.py" + ] + }, + "functional_tests/test_workflow_structured_flow.py::test_v3_analyze_writes_retain_workflow_and_native_guard_fences::point-seam-1": { + "boundary": { + "sha256": "ee44424b34bde7b46437ffac6a6590206318d575d52008cda37352d88607444e", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "d71c9069216784edf8fad46ad7a2520586855ede132dc4320e8a15e34f055000" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_structured_flow.py" + ] + }, + "functional_tests/test_workflow_structured_flow.py::test_lost_decision_acknowledgement_does_not_double_admit_or_change_choice::point-seam-1": { + "boundary": { + "sha256": "34120c4d3fa4b52e4d18a9f5335db563e1c2258be45aeb464bfa54562627abc6", + "methods": [ + "execute_item_batch" + ], + "kind": "seam", + "imports_sha256": "d71c9069216784edf8fad46ad7a2520586855ede132dc4320e8a15e34f055000" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_workflow_structured_flow.py" + ] + }, + "functional_tests/test_workflow_task_result_handoff.py::RunItemsContainer": { + "boundary": { + "sha256": "651e8a567626bd17cfdc301dbaf50c49c28557940d444fab2522211c8eafdfcc", + "methods": [ + "upsert_item" + ], + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "ca9c2487b2e6b72466f2d1051dec21df6ac06b425abd2c945c786f8514700cba" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_workflow_task_result_handoff.py" + ] + }, + "functional_tests/test_yamcs_action_plugin.py::FakeConfigCosmosContainer": { + "boundary": { + "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c627a61e49bf8d17af74ea2e167c6ee7539348e10ea5cffa9c46b26610908c10" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_yamcs_action_plugin.py" + ] + }, + "functional_tests/test_yamcs_basic_auth.py::FakeConfigCosmosContainer": { + "boundary": { + "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558", + "methods": [ + "read_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f117480d3a78090c5ace2f23e79f1303a1bdc7b0fca5cb570ce9eb9cffa2c0a5" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_yamcs_basic_auth.py" + ] + }, + "functional_tests/test_support/document_analysis.py::document_analysis_runtime.screening_container::point-seam-1": { + "boundary": { + "sha256": "6c491bf2b0a1a366f5d9b29141d67eb4ac1a99d569278a4747e321e104eed41a", + "methods": [ + "read_item" + ], + "kind": "seam", + "imports_sha256": "107eb9066f1ecc0d67f3bc429d23d5e1fbe30a8dbed8caa641bd1f420a2caa3e" + }, + "classification": "explicit-compatibility", + "contract": "Existing test-local point override/fault seam, not the normal shared Cosmos response default. Its containing test supplies the scenario and restores the override.", + "tests": [ + "functional_tests/test_support/document_analysis.py" + ] + }, + "functional_tests/test_support/document_search_sync.py::FakeSettingsContainer": { + "boundary": { + "sha256": "09784ea857a5e2d05380363394b17e75c74f7c56871e118ce73ce2fa83852697", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "a11a1fe22dc9d9b6530e0fa8fadb4b4995fd26a55c0f70c55896a91305cb51c2" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/document_search_sync.py" + ] + }, + "functional_tests/test_support/group_action_harness.py::ActionContainer": { + "boundary": { + "sha256": "a38b12dd9c634020c7253ffc0b1bf08e368885b8fe1f18ac8fcf41eff2ee8c70", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "6139690a557838086e5fcd4909bbf4904599322dd4ed2e255fe6fb939243e6cd" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/group_action_harness.py" + ] + }, + "functional_tests/test_support/group_agent_harness.py::AgentContainer": { + "boundary": { + "sha256": "00375cd2029ca0c29dc60acaaf80ade356e85624fec50007b9963d83fa33ffdd", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "5579b532fb4db1915447c75f44514aa0cb516b3c9b63e84144cd2b599d9bdfc7" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/group_agent_harness.py" + ] + }, + "functional_tests/test_support/group_file_source_harness.py::FileSyncContainer": { + "boundary": { + "sha256": "1b712442ab84149d257040451581d28cf040afa3828cfa28f8ed349e1fa3cfe9", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "1cb31b7628867b66fe38d4b5739121e4eb762fa9e8d110f4e49e9f233e3b0636" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/group_file_source_harness.py" + ] + }, + "functional_tests/test_support/group_identity_harness.py::IdentityContainer": { + "boundary": { + "sha256": "27bb18cf6cd6ce629205a801b70834ef1c64ac349c71f03a4eef4e044f85203a", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ec843fa58efcd082613b8b331353601aca43ab626fc3fda586680b3081173beb" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/group_identity_harness.py" + ] + }, + "functional_tests/test_support/group_prompt_harness.py::PromptContainer": { + "boundary": { + "sha256": "5bfd774bf5bb4ab2a1da9b500db00ab2710588d508fd95ec421bd8b4520914f7", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f7b7919fafd58674149fd5cac11355b60cd598df81d755bc31025458b773bf5f" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/group_prompt_harness.py" + ] + }, + "functional_tests/test_support/m365.py::CosmosContainer": { + "boundary": { + "sha256": "7c38b7ac9265915041a96e492f029b8df646b6263d93d93aebc7c26d647ca0ee", + "methods": [ + "create_item", + "delete_item", + "execute_item_batch", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "68f620cee64e569b0c5387f8114f6ca20494c69b57fd037fe7ca9e73125cae25" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_support/offline_bootstrap.py::OfflineContainer": { + "boundary": { + "sha256": "583afdd52a3113205d25c56ef90bac3f8a28f03643191106d267fd9b2d81e269", + "methods": [ + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "6d2189887ce14a62f90f179bf6ccd1c74400274409dc19714881e17a260b8451" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_support/orchestration_harness_execution.py::HarnessMessageContainer": { + "boundary": { + "sha256": "fa2cd4a633f53b75d52b1b2ae93b8da7d47f16b6c868e825d1759bbd2dcaa9e2", + "methods": [ + "delete_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "36f76e7c8930a2c7d95590c017382459883e07cea17b80ca83da6800f9ff499d" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_support/orchestration_reference_world.py::RecordingContainer": { + "boundary": { + "sha256": "e158b4650dd9517a107ef8e35825a2ebede8d6b118613f68dda48af706451530", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "6b2895674946ec70db1100414855624648fd8113beef19ba93efc15f24238551" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/orchestration_reference_world.py" + ] + }, + "functional_tests/test_support/orchestration_results.py::ResultContainer": { + "boundary": { + "sha256": "e38fc732045dd1576c276eb13b62dcb03eca3cffd881b94d86d8d3f37992ea3e", + "methods": [ + "delete_item" + ], + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "78f1d5e92309b5d6f03f958c10cbcef533bdd7a23fe0f3bde5b2bd2e701f3fce" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_support/orchestration_results.py::ResultFixture": { + "boundary": { + "sha256": "63198c89a75bd78efc1200831688d5057a918da420ebd6dfb81132cf085b45e3", + "methods": [], + "kind": "domain", + "inherited_bases": [], + "imports_sha256": "78f1d5e92309b5d6f03f958c10cbcef533bdd7a23fe0f3bde5b2bd2e701f3fce" + }, + "classification": "domain-double", + "contract": "Domain runtime control/result reader or real-result fixture, not a Cosmos SDK container. Plain domain projections deliberately remain plain; the backing Cosmos container is separately inventoried.", + "tests": [ + "functional_tests/test_orchestration_cosmos_response_contract.py" + ] + }, + "functional_tests/test_support/orchestration_revisions.py::AtomicMemoryContainer": { + "boundary": { + "sha256": "45972adfa5bac7f069ae2a00047424aa5a208a8d14b6cc61afd1ab560397f5ee", + "methods": [ + "create_item", + "delete_item", + "execute_item_batch", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "a5271c5eba30cd26978bd66b16ae2c89bba4de3c753911b4d9298133304773cc" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_support/public_file_source_harness.py::FileSyncContainer": { + "boundary": { + "sha256": "1b712442ab84149d257040451581d28cf040afa3828cfa28f8ed349e1fa3cfe9", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f8de6c5a7b4aaf5b781b06a1e932326f107202a0da4dd67468f73d56c3a67613" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/public_file_source_harness.py" + ] + }, + "functional_tests/test_support/public_file_source_harness.py::WorkspaceContainer": { + "boundary": { + "sha256": "f49b606b75592181a2f901ecfce862d1047aa9b648d5cc714ee71b698b848429", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f8de6c5a7b4aaf5b781b06a1e932326f107202a0da4dd67468f73d56c3a67613" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/public_file_source_harness.py" + ] + }, + "functional_tests/test_support/public_identity_harness.py::IdentityContainer": { + "boundary": { + "sha256": "3d3c6048c1720e28a6cdae906ffe9e1cc77fd4e726e40d1265de1491389a784b", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f8de6c5a7b4aaf5b781b06a1e932326f107202a0da4dd67468f73d56c3a67613" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/public_identity_harness.py" + ] + }, + "functional_tests/test_support/public_identity_harness.py::WorkspaceContainer": { + "boundary": { + "sha256": "651c07a289cca91f8a16a9c54a931c1d1b8bc9fe8a71b3743f91247a31ae9b01", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f8de6c5a7b4aaf5b781b06a1e932326f107202a0da4dd67468f73d56c3a67613" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/public_identity_harness.py" + ] + }, + "functional_tests/test_support/public_prompt_harness.py::PromptContainer": { + "boundary": { + "sha256": "5bfd774bf5bb4ab2a1da9b500db00ab2710588d508fd95ec421bd8b4520914f7", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c6040f96ae2999e496048f391440367724e765c87af77bf33257e75312a6da84" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/public_prompt_harness.py" + ] + }, + "functional_tests/test_support/public_prompt_harness.py::WorkspaceContainer": { + "boundary": { + "sha256": "651c07a289cca91f8a16a9c54a931c1d1b8bc9fe8a71b3743f91247a31ae9b01", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "c6040f96ae2999e496048f391440367724e765c87af77bf33257e75312a6da84" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/public_prompt_harness.py" + ] + }, + "functional_tests/test_support/safety_review_harness.py::FakeSafetyContainer": { + "boundary": { + "sha256": "cb67a49db3261b30123e591318a0706316b595831592378ad3b42d0d69ac6d34", + "methods": [ + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7529235ac187fcb5cabb2aad66ee14a2f94cd7a69d682b8a569226095092e73a" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/safety_review_harness.py" + ] + }, + "functional_tests/test_support/safety_review_harness.py::FakeApprovalsContainer": { + "boundary": { + "sha256": "144428ee093881f8396a5807dc3f3c523e0b07f9f6e2c8344e23f0559ef0cff1", + "methods": [ + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "7529235ac187fcb5cabb2aad66ee14a2f94cd7a69d682b8a569226095092e73a" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/safety_review_harness.py" + ] + }, + "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeContainer": { + "boundary": { + "sha256": "8454999fc4a0ea33fb3932eab0e16d1649d7a31220b8e0c3191cfe31409bc6bc", + "methods": [ + "create_item", + "delete_item", + "read_item", + "replace_item", + "upsert_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ef38d1defac54b7f18c32d421b4d29994b5d854786f6ad0641ec34f3b2d96eff" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + }, + "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeRuntime": { + "boundary": { + "sha256": "ec5ab6b0c85b83361271b913dab9f08c6cb13f083783f63af558fd0acb20e982", + "methods": [], + "kind": "domain", + "inherited_bases": [], + "imports_sha256": "ef38d1defac54b7f18c32d421b4d29994b5d854786f6ad0641ec34f3b2d96eff" + }, + "classification": "domain-double", + "contract": "Domain runtime control/result reader or real-result fixture, not a Cosmos SDK container. Plain domain projections deliberately remain plain; the backing Cosmos container is separately inventoried.", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeRuntime.factory._Store": { + "boundary": { + "sha256": "dd59a6bd3a96e8435a52cd9357d9dcc8212528b04c43d1f0d7662a8538052683", + "methods": [], + "kind": "domain", + "inherited_bases": [], + "imports_sha256": "ef38d1defac54b7f18c32d421b4d29994b5d854786f6ad0641ec34f3b2d96eff" + }, + "classification": "domain-double", + "contract": "Domain runtime control/result reader or real-result fixture, not a Cosmos SDK container. Plain domain projections deliberately remain plain; the backing Cosmos container is separately inventoried.", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeResultReader": { + "boundary": { + "sha256": "f797ef7c33618013ece0d4fc09c3826ddcedd5e340b612c8a44c7ec451f7ec8e", + "methods": [], + "kind": "domain", + "inherited_bases": [], + "imports_sha256": "ef38d1defac54b7f18c32d421b4d29994b5d854786f6ad0641ec34f3b2d96eff" + }, + "classification": "domain-double", + "contract": "Domain runtime control/result reader or real-result fixture, not a Cosmos SDK container. Plain domain projections deliberately remain plain; the backing Cosmos container is separately inventoried.", + "tests": [ + "functional_tests/test_workflow_chat_delivery_worker.py" + ] + }, + "functional_tests/test_support/workflow_result_chat.py::FakeContainer": { + "boundary": { + "sha256": "455a123da3ff64f7b33030fa8e83df420360bdcbea33516897eadee353f4edf7", + "methods": [ + "read_item" + ], + "kind": "class", + "inherited_bases": [], + "imports_sha256": "3858d9cce55c112e0d1f610c8e73b814066fcdc2107140e3c11b8d795532cfd3" + }, + "classification": "legacy-inline", + "contract": "Unchanged inline Cosmos-shaped test container outside the migrated shared defaults. Its test-specific response behavior is an explicit staged-migration baseline, not blanket runtime SDK proof.", + "tests": [ + "functional_tests/test_support/workflow_result_chat.py" + ] + }, + "functional_tests/test_support/workflow_result_offline_app.py::Container": { + "boundary": { + "sha256": "ebf204f6808ba3aa25766d2466c4518feec3a1b7eb28cbf22e4829baeb724ed6", + "methods": [ + "read_item", + "replace_item" + ], + "kind": "class", + "inherited_bases": [ + "OfflineContainer" + ], + "imports_sha256": "d4cad5f55715280599e379353d012730a382650d793076829c17f33ca762d89e" + }, + "classification": "sdk-default", + "contract": "Migrated Cosmos container: actual pinned SDK point wrappers by default, explicit sdk_responses=False compatibility, plain query JSON; existing identity/ETag/failure behavior is preserved.", + "tests": [ + "functional_tests/test_cosmos_document_boundaries.py" + ] + } + } +} diff --git a/functional_tests/test_cosmos_document_boundaries.py b/functional_tests/test_cosmos_document_boundaries.py new file mode 100644 index 000000000..b768aeddc --- /dev/null +++ b/functional_tests/test_cosmos_document_boundaries.py @@ -0,0 +1,385 @@ +# test_cosmos_document_boundaries.py +"""Functional contracts for the SDK document boundary and reviewed owner inventory. + +Version: 0.261.324 +Implemented in: 0.261.324 + +No cloud client, configuration bootstrap, or network service is required. +""" + +import ast +import importlib +import importlib.util +from importlib.metadata import version +import json +import subprocess +import sys +from collections import UserDict +from copy import deepcopy +from pathlib import Path +from types import MappingProxyType + +import pytest +from azure.core import MatchConditions +from azure.cosmos import exceptions +from azure.cosmos._cosmos_responses import CosmosDict + +from cosmos_document_utils import normalize_cosmos_document +from functions_orchestration_result_contracts import ResultContractError, validate_json +from test_support.m365 import CosmosContainer +from test_support.orchestration_revisions import AtomicMemoryContainer + + +ROOT = Path(__file__).resolve().parents[1] +SPEC = importlib.util.spec_from_file_location( + "cosmos_boundary_checker", ROOT / "scripts" / "check_cosmos_response_boundaries.py", +) +checker = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(checker) + + +@pytest.mark.parametrize("wrapper", [dict, UserDict, MappingProxyType, lambda value: CosmosDict(value, response_headers={})]) +def test_document_normalizer_preserves_fields_etag_and_nested_identity(wrapper): + nested = {"rows": [{"value": "untouched"}]} + source = wrapper({"id": "record", "_etag": '"etag-1"', "_rid": "retained", "nested": nested}) + result = normalize_cosmos_document(source) + assert type(result) is dict + assert result == source and result is not source + assert result["nested"] is nested + assert result["_etag"] == '"etag-1"' and result["_rid"] == "retained" + result["new"] = True + assert "new" not in source + + +@pytest.mark.parametrize("value", [None, [], [("id", "record")], "record", 0, object()]) +def test_document_normalizer_rejects_non_documents(value): + with pytest.raises(TypeError): + normalize_cosmos_document(value) + + +def test_real_sdk_copy_is_not_normalization_and_domain_validator_stays_strict(): + source = CosmosDict({"id": "record", "_etag": "etag"}, response_headers={"x-ms-request-charge": "1"}) + copied = deepcopy(source) + assert type(copied) is CosmosDict + with pytest.raises(ResultContractError): + validate_json(copied) + normalized = normalize_cosmos_document(source) + validate_json(normalized) + nested_mapping = UserDict({"value": "not-domain-json"}) + value = normalize_cosmos_document({"nested": nested_mapping}) + assert value["nested"] is nested_mapping + with pytest.raises(ResultContractError): + validate_json(value) + + +def test_installed_sdk_matches_the_application_dependency_pin(): + requirements = (ROOT / "application" / "single_app" / "requirements.txt").read_text(encoding="utf-8") + pins = [line.split("==", 1)[1] for line in requirements.splitlines() if line.startswith("azure-cosmos==")] + installed = version("azure-cosmos") + assert len(pins) == 1 and installed == pins[0] + + +@pytest.mark.parametrize("optimized", [False, True]) +def test_utility_cold_import_has_no_bootstrap_or_sdk_dependency(optimized): + probe = """ +import importlib.abc +import socket +import sys +def blocked(*args, **kwargs): + raise RuntimeError('network forbidden') +socket.socket.connect = blocked +class RejectBootstrap(importlib.abc.MetaPathFinder): + def find_spec(self, fullname, path=None, target=None): + if fullname.split('.')[0] in {'config', 'azure', 'functions_settings', 'functions_appinsights'}: + raise RuntimeError('unexpected dependency: ' + fullname) +sys.meta_path.insert(0, RejectBootstrap()) +from cosmos_document_utils import normalize_cosmos_document +result = normalize_cosmos_document({'id': 'offline', '_etag': 'preserved'}) +if type(result) is not dict or result['_etag'] != 'preserved': + raise RuntimeError('invalid normalized document') +try: + normalize_cosmos_document([('id', 'offline')]) +except TypeError: + pass +else: + raise RuntimeError('non-mapping accepted') +""" + result = subprocess.run( + [sys.executable, *(["-O"] if optimized else []), "-c", probe], + cwd=ROOT / "application" / "single_app", capture_output=True, text=True, check=False, + ) + assert result.returncode == 0, result.stderr + + +@pytest.mark.parametrize("sdk_responses", [False, True], ids=["explicit-plain", "sdk-default"]) +@pytest.mark.parametrize("factory", [CosmosContainer, AtomicMemoryContainer]) +def test_shared_double_point_shapes_query_rows_etags_and_atomicity(factory, sdk_responses): + container = factory("group_id", sdk_responses=sdk_responses) + created = container.create_item(body={"id": "record", "group_id": "owner", "value": {"n": 1}}) + read = container.read_item(item="record", partition_key="owner") + updated = container.replace_item( + item="record", body={**read, "value": {"n": 2}}, + etag=read["_etag"], match_condition=MatchConditions.IfNotModified, + ) + upserted = container.upsert_item(body={**updated, "value": {"n": 3}}) + expected = CosmosDict if sdk_responses else dict + assert all(type(value) is expected for value in (created, read, updated, upserted)) + assert created["_etag"] == read["_etag"] != updated["_etag"] != upserted["_etag"] + rows = list(container.query_items(query="SELECT * FROM c", partition_key="owner")) + assert type(rows[0]) is dict and type(rows[0]["value"]) is dict + with pytest.raises(exceptions.CosmosResourceNotFoundError): + container.read_item(item="record", partition_key="someone-else") + with pytest.raises(exceptions.CosmosHttpResponseError): + container.replace_item( + item="record", body=dict(read), etag=read["_etag"], + match_condition=MatchConditions.IfNotModified, + ) + before = deepcopy(container.items) + with pytest.raises((exceptions.CosmosHttpResponseError, exceptions.CosmosBatchOperationError)): + container.execute_item_batch( + batch_operations=[ + ("create", ({"id": "staged", "group_id": "owner"},)), + ("replace", ("record", dict(upserted)), {"if_match_etag": "stale"}), + ], + partition_key="owner", + ) + assert container.items == before + + +def test_shared_double_sdk_mode_is_the_default(): + for factory in (CosmosContainer, AtomicMemoryContainer): + container = factory("group_id") + response = container.create_item(body={"id": "record", "group_id": "owner"}) + assert type(response) is CosmosDict + + +@pytest.mark.parametrize("sdk_responses", [False, True]) +@pytest.mark.parametrize("module_name,class_name,args", [ + ("test_workflow_result_store", "FakeCosmosContainer", ()), + ("test_workflow_runtime_store", "FakeCosmosContainer", ()), + ("test_support.offline_bootstrap", "OfflineContainer", ()), + ("test_support.workflow_result_offline_app", "Container", ("run_id",)), + ("test_support.workflow_chat_delivery_fakes", "FakeContainer", ("contract",)), + ("test_support.orchestration_results", "ResultContainer", ()), + ("test_support.orchestration_harness_execution", "HarnessMessageContainer", ()), + ("test_orchestration_output_lifecycle", "OutputContainer", ()), + ("test_orchestration_output_lifecycle", "MessageContainer", ()), +]) +def test_migrated_workflow_and_bootstrap_doubles_keep_explicit_compatibility( + module_name, class_name, args, sdk_responses, +): + module = importlib.import_module(module_name) + factory = getattr(module, class_name) + container = factory(*args, sdk_responses=sdk_responses) + created = container.create_item(body={ + "id": "record", "run_id": "owner", "conversation_id": "owner", "nested": {"value": "json"}, + }) + read = container.read_item(item="record", partition_key="owner") + default_container = factory(*args) + default = default_container.create_item(body={"id": "default", "run_id": "owner", "conversation_id": "owner"}) + expected = CosmosDict if sdk_responses else dict + assert type(created) is type(read) is expected + assert type(read["nested"]) is dict and type(default) is CosmosDict + + +def test_repository_boundary_inventory_has_no_unreviewed_or_stale_owners(): + inventory = json.loads(checker.INVENTORY.read_text(encoding="utf-8")) + actual, doubles = checker.scan_boundaries(), checker.scan_doubles() + errors = checker.validate_inventory(actual, doubles, inventory, domain_targets=checker.DOMAIN_DOUBLE_TARGETS) + assert errors == [], "\n".join(errors) + + +def test_inventory_guard_rejects_new_changed_stale_and_unexplained_boundaries(): + boundary = {"sha256": "one", "points": [], "queries": []} + review = {"boundary": boundary, "classification": "sdk-compatible", "contract": "mapping read", "tests": []} + errors = checker.validate_inventory({"owner": boundary}, {}, {"owners": {"owner": review}}) + assert any("Missing runtime evidence" in error for error in errors) + reviewed = {"owners": {"owner": {**review, "classification": "response-unused"}}} + errors = checker.validate_inventory({"new": boundary, "owner": {**boundary, "sha256": "two"}}, {}, reviewed) + assert any("Unreviewed" in error for error in errors) + assert any("Changed" in error for error in errors) + errors = checker.validate_inventory({}, {}, reviewed) + assert any("Stale" in error for error in errors) + refreshed = checker.refresh_inventory({"owner": {**boundary, "sha256": "two"}}, {}, reviewed) + assert refreshed["owners"]["owner"]["classification"] == "review-required" + + +def test_inventory_distinguishes_unused_returned_helper_and_query_responses(): + visitor = checker.BoundaryVisitor() + visitor.visit(ast.parse(""" +def boundary(container): + container.create_item(body={}) + reader = container.read_item + rows = container.query_items(query='SELECT * FROM c') + container.execute_item_batch(batch_operations=[]) + many = container.read_many(items=[]) + return container.read_item(item='id', partition_key='id') +""")) + boundary = visitor.owners["boundary"] + assert [entry["response"] for entry in boundary["points"]] == ["unused", "helper-reference", "returned"] + assert boundary["queries"][0]["method"] == "query_items" + assert [entry["method"] for entry in boundary["batches"]] == ["execute_item_batch", "read_many"] + assert [entry["response"] for entry in boundary["batches"]] == ["unused", "consumed"] + + +def test_inventory_guard_rejects_stale_or_new_legacy_exemptions(): + boundary = {"sha256": "one", "points": [], "queries": []} + legacy = {"boundary": boundary, "classification": "legacy-inline", "contract": "Existing inline Cosmos fake.", "tests": []} + errors = checker.validate_inventory({}, {"new": boundary}, {"doubles": {"new": legacy}}) + assert any("cannot use legacy-inline" in error for error in errors) + errors = checker.validate_inventory({}, {}, {"legacy_double_baseline": {"removed": "one"}}) + assert any("Stale legacy double exemption" in error for error in errors) + review = { + "boundary": boundary, "classification": "sdk-compatible", "contract": "Mapping field consumer.", + "tests": [], "evidence_scope": "sdk-api-and-source-review", + } + errors = checker.validate_inventory({"new": boundary}, {}, {"owners": {"new": review}}) + assert any("owner-runtime SDK evidence" in error for error in errors) + errors = checker.validate_inventory({}, {}, {"source_review_baseline": {"removed": "one"}}) + assert any("Stale source-only owner review" in error for error in errors) + + +def test_inventory_can_classify_a_similarly_named_non_cosmos_api_without_false_positive(): + boundary = {"sha256": "one", "points": [], "queries": []} + review = { + "boundary": boundary, "classification": "not-cosmos", + "contract": "FileIndex.read_item returns a scalar filename; this injected API is not a Cosmos container.", + "tests": [], + } + errors = checker.validate_inventory({"file-index": boundary}, {}, {"owners": {"file-index": review}}) + assert errors == [] + errors = checker.validate_inventory({}, {}, {"owners": {"file-index": review}}) + assert any("Stale" in error for error in errors) + + +def test_double_inventory_finds_nested_classes_namespace_and_point_fault_seams(): + doubles = checker.inspect_doubles("functional_tests/test_example.py", """ +def test_first(): + class Container: + def read_item(self): + return {} + mock = SimpleNamespace(read_item=lambda **kwargs: {}) + monkeypatch.setattr(mock, 'read_item', lambda **kwargs: None) +def test_second(): + class Container: + def read_item(self): + return {} +""") + assert set(doubles) == { + "functional_tests/test_example.py::test_first.Container", + "functional_tests/test_example.py::test_second.Container", + "functional_tests/test_example.py::test_first::point-seam-1", + "functional_tests/test_example.py::test_first::point-seam-2", + } + + +def test_inventory_includes_module_and_getattr_mediated_point_boundaries(): + visitor = checker.BoundaryVisitor() + visitor.visit(ast.parse(""" +settings = container.read_item(item='settings', partition_key='settings') +def owner(container): + write = getattr(container, 'create_item', None) + return getattr(container, 'read_item')(item='id', partition_key='id') +""")) + assert visitor.owners[""]["points"][0]["response"] == "consumed" + points = visitor.owners["owner"]["points"] + assert [(point["method"], point["response"]) for point in points] == [ + ("create_item", "helper-reference"), ("read_item", "returned"), + ] + + +def test_double_inventory_keeps_domain_mocks_distinct_from_inherited_cosmos_containers(): + doubles = checker.inspect_doubles( + "functional_tests/test_support/workflow_chat_delivery_fakes.py", """ +class FakeRuntime: + def factory(self): + class _Store: + def read(self): + return {'state': 'completed'} + return _Store() +class InheritedContainer(AtomicMemoryContainer): + pass +""") + assert doubles["functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeRuntime"]["kind"] == "domain" + assert doubles["functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeRuntime.factory._Store"]["kind"] == "domain" + inherited = doubles["functional_tests/test_support/workflow_chat_delivery_fakes.py::InheritedContainer"] + assert inherited["kind"] == "class" and inherited["inherited_bases"] == ["AtomicMemoryContainer"] + errors = checker.validate_inventory({}, {}, {}, domain_targets=["removed"]) + assert errors == ["Stale domain-double classification target: removed"] + + +def test_runtime_gate_selects_new_owner_and_sdk_double_evidence_automatically(): + targets = checker.runtime_test_targets({ + "owners": { + "new": {"evidence_scope": "owner-runtime", "tests": ["functional_tests/test_new_owner.py::test_sdk"]}, + "legacy": {"evidence_scope": "sdk-api-and-source-review", "tests": ["functional_tests/test_legacy_cloud.py"]}, + }, + "doubles": { + "new": {"classification": "sdk-default", "tests": ["functional_tests/test_new_double.py"]}, + "fault": {"classification": "fault-injection", "tests": ["functional_tests/test_fault.py"]}, + }, + }) + assert "functional_tests/test_new_owner.py::test_sdk" in targets + assert "functional_tests/test_new_double.py" in targets + assert "functional_tests/test_fault.py" in targets + assert "functional_tests/test_legacy_cloud.py" not in targets + assert checker.CORE_CONTRACT_TESTS <= set(targets) + + +def test_inventory_captures_write_only_cosmos_doubles_and_preserves_audit_metadata(): + doubles = checker.inspect_doubles("functional_tests/test_write_only.py", """ +class WriteOnly: + def create_item(self, body): + return body +""") + assert doubles["functional_tests/test_write_only.py::WriteOnly"]["methods"] == ["create_item"] + refreshed = checker.refresh_inventory({}, {}, {"audit": {"scope": "reviewed"}}) + assert refreshed["audit"] == {"scope": "reviewed"} + + +def test_new_compatibility_seams_cannot_bypass_runtime_fault_evidence(): + boundary = {"sha256": "old", "kind": "seam", "methods": ["read_item"]} + inventory = { + "doubles": {"seam": { + "boundary": boundary, "classification": "explicit-compatibility", + "contract": "Existing explicit scenario override", + "tests": ["functional_tests/test_cosmos_document_boundaries.py"], + }}, + "compatibility_seam_baseline": {"seam": checker.review_digest(boundary)}, + } + errors = checker.validate_inventory({}, {"seam": boundary}, inventory) + assert errors == [] + changed = {**boundary, "sha256": "new"} + errors = checker.validate_inventory({}, {"seam": changed}, inventory) + assert any("Stale compatibility seam" in error for error in errors) + assert any("runtime fault-injection evidence" in error for error in errors) + + +def test_inventory_captures_inline_cosmos_containers_inside_subprocess_probes(): + source = "PROBE = '''class OfflineContainer:\\n def read_item(self, item):\\n return {}\\n'''" + doubles = checker.inspect_doubles("functional_tests/test_probe.py", source) + key = "functional_tests/test_probe.py::embedded-PROBE::OfflineContainer" + assert doubles[key]["methods"] == ["read_item"] + assert doubles[key]["embedded_source_sha256"] + + +def test_network_guard_blocks_external_calls_but_allows_stdlib_socketpair(): + import socket + from unittest.mock import patch + + from test_support import cosmos_network_guard + + with patch.object(socket.socket, "connect", cosmos_network_guard._connect): + with socket.socket() as connection: + with pytest.raises(AssertionError, match="cannot access the network"): + connection.connect(("127.0.0.1", 443)) + left, right = cosmos_network_guard._socketpair() + try: + left.send(b"x") + received = right.recv(1) + assert received == b"x" + finally: + left.close() + right.close() + with pytest.raises(AssertionError, match="cannot access the network"): + cosmos_network_guard._blocked() diff --git a/functional_tests/test_m365_approvals_execution.py b/functional_tests/test_m365_approvals_execution.py index 347c45bf9..8d3433cf3 100644 --- a/functional_tests/test_m365_approvals_execution.py +++ b/functional_tests/test_m365_approvals_execution.py @@ -1,7 +1,7 @@ # test_m365_approvals_execution.py """ Functional tests for subject-owned Microsoft 365 approvals and scoped execution. -Version: 0.261.029 +Version: 0.261.324 Implemented in: 0.261.029 Validates real policy modules against conditional, paginated Cosmos fakes: @@ -54,17 +54,27 @@ def _module(name, **members): def load_real_legacy_approvals(container): + def unexpected_safety_callback(*args, **kwargs): + raise AssertionError("Legacy group approval coverage must not execute safety remediation.") + dependencies = { - "config": _module("config", cosmos_approvals_container=container, cosmos_groups_container=container), + "config": _module( + "config", cosmos_approvals_container=container, cosmos_groups_container=container, + cosmos_safety_container=container, + ), "functions_appinsights": _module("functions_appinsights", log_event=lambda *args, **kwargs: None), "functions_notifications": _module( "functions_notifications", create_notification=lambda **kwargs: None, delete_notifications_by_metadata=lambda **kwargs: None, create_m365_approval_notification=lambda approval: {"id": approval["id"]}, + mark_notification_read=unexpected_safety_callback, ), "functions_group": _module("functions_group", find_group_by_id=lambda value: None), - "functions_settings": _module("functions_settings", get_settings=lambda: {}), + "functions_settings": _module( + "functions_settings", get_settings=lambda: {}, + get_user_settings=unexpected_safety_callback, update_user_settings=unexpected_safety_callback, + ), "functions_debug": _module("functions_debug", debug_print=lambda *args, **kwargs: None), } spec = importlib.util.spec_from_file_location( diff --git a/functional_tests/test_m365_cosmos_sdk_contract.py b/functional_tests/test_m365_cosmos_sdk_contract.py index 9e590eb31..78dde354d 100644 --- a/functional_tests/test_m365_cosmos_sdk_contract.py +++ b/functional_tests/test_m365_cosmos_sdk_contract.py @@ -1,8 +1,9 @@ # test_m365_cosmos_sdk_contract.py """ Functional regressions for Microsoft 365 Cosmos replacement calls. -Version: 0.261.031 +Version: 0.261.324 Implemented in: 0.261.031 +Point/query response representation coverage added in: 0.261.324 Uses the installed Cosmos SDK and RequestsTransport with an autospecced HTTP session. Only remote responses are faked; the real SDK derives partition routing @@ -25,6 +26,7 @@ from azure.core import MatchConditions from azure.core.pipeline.transport import RequestsTransport from azure.cosmos import CosmosClient +from azure.cosmos._cosmos_responses import CosmosDict from azure.cosmos.exceptions import CosmosHttpResponseError, CosmosResourceNotFoundError from flask import Flask, g import pytest @@ -72,7 +74,26 @@ def request(self, method, url, *, data=None, headers=None, **kwargs): "id": "records", "_rid": "offline-container", "partitionKey": {"paths": [f"/{self.partition_field}"], "kind": "Hash", "version": 2}, } - elif "/docs/" in path and method in {"GET", "PUT"}: + elif method == "POST" and path == "/dbs/testdb/colls/records/docs": + request = json.loads(data) + partition = json.loads(headers["x-ms-documentdb-partitionkey"])[0] + if headers.get("x-ms-documentdb-isquery"): + if request.get("query") != "SELECT * FROM c": + raise AssertionError("Unexpected offline query.") + rows = [ + deepcopy(record) for (scope, _), record in self.records.items() + if scope == partition + ] + payload = {"Documents": rows, "_count": len(rows)} + else: + if request.get(self.partition_field) != partition: + raise AssertionError("Write changed its partition.") + key = (partition, request["id"]) + if key in self.records and not headers.get("x-ms-documentdb-is-upsert"): + status, payload = 409, {"code": "Conflict", "message": "The scoped item already exists."} + else: + status, payload = 201, self.seed(request) + elif "/docs/" in path and method in {"GET", "PUT", "PATCH"}: partition = json.loads(headers["x-ms-documentdb-partitionkey"])[0] item_id = path.rsplit("/", 1)[-1] existing = self.records.get((partition, item_id)) @@ -84,6 +105,13 @@ def request(self, method, url, *, data=None, headers=None, **kwargs): status, payload = 412, {"code": "PreconditionFailed", "message": "The item changed."} else: body = json.loads(data) + if method == "PATCH": + operations = body["operations"] + body = deepcopy(existing) + for operation in operations: + if operation["op"] != "replace" or operation["path"].count("/") != 1: + raise AssertionError("Unexpected offline patch.") + body[operation["path"][1:]] = operation["value"] if body.get(self.partition_field) != partition or body.get("id") != item_id: raise AssertionError("Replacement changed the authorized partition or item ID.") payload = self.seed(body) @@ -176,6 +204,35 @@ def test_real_sdk_routes_replacements_from_body_and_preserves_etag(cosmos_factor assert http.records[(original[partition_field], "record")]["status"] == "completed" +def test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain(cosmos_factory): + http, container = cosmos_factory("user_id") + http.seed({"id": "record", "user_id": "owner", "nested": {"items": [{"value": "json"}]}}) + point = container.read_item(item="record", partition_key="owner") + rows = list(container.query_items(query="SELECT * FROM c", partition_key="owner")) + assert type(point) is CosmosDict + assert type(point["nested"]) is dict and type(point["nested"]["items"][0]) is dict + assert len(rows) == 1 and type(rows[0]) is dict + assert rows[0] == dict(point) and type(rows[0]["nested"]) is dict + + +def test_real_sdk_returned_write_documents_use_the_same_top_level_wrapper(cosmos_factory): + _http, container = cosmos_factory("user_id") + created = container.create_item(body={"id": "record", "user_id": "owner", "status": "created"}) + upserted = container.upsert_item(body={**created, "status": "upserted"}) + replaced = container.replace_item( + item="record", body={**upserted, "status": "replaced"}, + etag=upserted["_etag"], match_condition=MatchConditions.IfNotModified, + ) + patched = container.patch_item( + item="record", partition_key="owner", + patch_operations=[{"op": "replace", "path": "/status", "value": "patched"}], + etag=replaced["_etag"], match_condition=MatchConditions.IfNotModified, + ) + assert all(type(value) is CosmosDict for value in (created, upserted, replaced, patched)) + assert len({value["_etag"] for value in (created, upserted, replaced, patched)}) == 4 + assert patched["status"] == "patched" and patched["user_id"] == "owner" + + def test_real_sdk_rejects_the_unsupported_partition_keyword(cosmos_factory): http, container = cosmos_factory("user_id") original = http.seed({"id": "record", "user_id": "owner"}) diff --git a/functional_tests/test_orchestration_email_review_flow.py b/functional_tests/test_orchestration_email_review_flow.py new file mode 100644 index 000000000..d5b58d061 --- /dev/null +++ b/functional_tests/test_orchestration_email_review_flow.py @@ -0,0 +1,119 @@ +# test_orchestration_email_review_flow.py +"""Durable outgoing references and current review cards in headless publication. + +Version: 0.261.324 +Implemented in: 0.261.324 +The real headless owner, checkpoint and finalization run with offline cloud I/O. +Producer bridge/effect coverage lives in test_orchestration_operation_runtime.py. +""" + +import importlib +import sys +from copy import deepcopy +from pathlib import Path + +import pytest + +# Production modules are imported by the shared harness before its offline fixture. +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'application' / 'single_app')) +from test_orchestration_harness_execution import harness, initialized_application +from test_support.orchestration_harness_execution import decoded_frames, input_binding + + +def producer_event(record): + m365 = importlib.import_module('functions_orchestration_m365') + return { + 'type': 'm365_pending_action_reference', 'run_id': record['id'], + 'step_id': 'prepare', 'user_message_id': record['user_message_id'], + 'reference': { + 'id': 'saved-action', 'user_id': record['user_id'], + 'conversation_id': record['conversation_id'], + 'request_id': m365.step_request_id(f"{record['id']}\x00prepare"), + }, + } + + +@pytest.mark.parametrize('later_failure', [False, True]) +@pytest.mark.parametrize('disconnect', [False, True]) +def test_new_action_survives_finalization_and_later_failure(harness, monkeypatch, later_failure, disconnect): + cards = importlib.import_module('functions_msgraph_pending_actions') + current = {'id': 'saved-action', 'status': 'pending', 'summary': {'subject': 'Prepared email'}} + reads = [] + + def resolve(user_id, conversation_id, **kwargs): + reads.append((user_id, conversation_id, kwargs)) + return [deepcopy(current)] + + monkeypatch.setattr(cards, 'get_chat_pending_action_cards', resolve) + harness.create(replies=[], final_response=input_binding('prepare')) + execution = harness.prepare() + record = harness.read() + event = producer_event(record) + + def reply(): + execution._progress(event) + execution._progress(event) + current['status'] = 'review_required' + if later_failure: + raise RuntimeError('PRIVATE_LATER_MODEL_FAILURE') + return 'Ready to review — not sent.' + + harness.replies.append(reply) + progress = [] + + def receive(frame): + progress.append(frame) + if disconnect: + raise ConnectionError('PRIVATE_UI_DISCONNECT') + + frames = execution.execute(emit=receive) + done = decoded_frames(frames)[-1] + saved = harness.read() + message = harness.assistant_messages()[0] + assert saved['m365_pending_action_ids'] == ['saved-action'] + assert message['metadata']['m365_pending_action_ids'] == ['saved-action'] + assert done['metadata']['m365_pending_action_ids'] == ['saved-action'] + assert done['m365_pending_actions'][0]['status'] == 'review_required' + assert done['message_saved'] and len(harness.assistant_messages()) == 1 + assert done['status'] == ('failed' if later_failure else 'completed') + assert all(user == record['user_id'] and conversation == record['conversation_id'] + for user, conversation, _kwargs in reads) + assert 'PRIVATE_' not in str(done) + if not disconnect: + live = [frame for frame in decoded_frames(progress) if frame.get('type') == 'm365_pending_action'] + assert live[0]['pending_action']['status'] == 'pending' + assert live[0]['user_message_id'] == record['user_message_id'] + assert live[0]['request_id'] == event['reference']['request_id'] + + +@pytest.mark.parametrize('field,value', [ + ('user_id', 'foreign-owner'), ('conversation_id', 'foreign-conversation'), + ('request_id', 'foreign-request'), +]) +def test_foreign_reference_cannot_be_attached(harness, monkeypatch, field, value): + harness.create(replies=['Prepared answer.'], final_response=input_binding('prepare')) + execution = harness.prepare() + event = producer_event(harness.read()) + event['reference'][field] = value + execution._progress(event) + execution.execute() + assert not harness.read().get('m365_pending_action_ids') + assert 'm365_pending_action_ids' not in harness.assistant_messages()[0]['metadata'] + + +def test_refresh_failure_retains_minimal_durable_link_without_retrying_effect(harness, monkeypatch): + cards = importlib.import_module('functions_msgraph_pending_actions') + + def unavailable(*args, **kwargs): + raise ConnectionError('PRIVATE_COSMOS_QUERY') + + monkeypatch.setattr(cards, 'get_chat_pending_action_cards', unavailable) + harness.create(replies=['Prepared answer.'], final_response=input_binding('prepare')) + execution = harness.prepare() + execution._progress(producer_event(harness.read())) + frames = execution.execute() + done = decoded_frames(frames)[-1] + assert done['status'] == 'completed' and done['message_saved'] + assert done['metadata']['m365_pending_action_ids'] == ['saved-action'] + assert done['m365_pending_actions_error']['error'] == 'm365_pending_actions_unavailable' + assert 'PRIVATE_' not in str(done) diff --git a/functional_tests/test_orchestration_harness_routes.py b/functional_tests/test_orchestration_harness_routes.py index f43adf855..394f9083f 100644 --- a/functional_tests/test_orchestration_harness_routes.py +++ b/functional_tests/test_orchestration_harness_routes.py @@ -1,7 +1,7 @@ # test_orchestration_harness_routes.py """ Real authenticated routes and bootstrap for orchestration file admission. -Version: 0.261.141 +Version: 0.261.324 Implemented in: 0.261.127 Initial-claim timing coverage added in: 0.261.129 Auto-routing admission and content-review file visibility added in: 0.261.131 @@ -57,10 +57,12 @@ def modules(): before = set(sys.modules) with offline_app_imports() as environment: + # Match the execution harness's real bootstrap entry before loading routes. + bootstrap = importlib.import_module("functions_orchestration_bootstrap") imported = SimpleNamespace( execution_loop=environment.loop, route=importlib.import_module("route_backend_orchestration"), - bootstrap=importlib.import_module("functions_orchestration_bootstrap"), + bootstrap=bootstrap, auth=importlib.import_module("functions_authentication"), config=importlib.import_module("config"), runs=importlib.import_module("functions_orchestration_runs"), diff --git a/functional_tests/test_orchestration_operation_runtime.py b/functional_tests/test_orchestration_operation_runtime.py index 303178322..865a3aae6 100644 --- a/functional_tests/test_orchestration_operation_runtime.py +++ b/functional_tests/test_orchestration_operation_runtime.py @@ -1,7 +1,7 @@ # test_orchestration_operation_runtime.py """Policy-governed M365 effects and claimed recovery through the real action runner. -Version: 0.261.322 +Version: 0.261.324 Implemented in: 0.261.321 Storage, Graph, tokens and the model are doubled; external network access is blocked. """ @@ -9,6 +9,7 @@ import importlib from copy import deepcopy import sys +from types import SimpleNamespace import pytest import requests @@ -83,9 +84,9 @@ def test_email_delivery_modes_and_retry_keep_one_effect(env, world, operations, assert 'send_mail' in world.loaded_functions[0] assert first['operation_receipts'] assert runtime.operation_summary(first['operation_receipts'], '') == ( - 'Microsoft 365 accepted the send.' if mode == 'auto_send' + 'Accepted for sending; recipient delivery is not confirmed.' if mode == 'auto_send' else 'Delivery scheduled; not yet sent.' if mode == 'draft_delayed' - else 'Draft prepared; awaiting review.' + else 'Ready to review — not sent.' ) if mode != 'auto_send': action = next(iter(world.pending.items.values())) @@ -129,7 +130,7 @@ def test_changed_payload_or_unknown_outcome_cannot_be_replayed(env, world, opera world.replies = [tool_call( 'm365_email-send_mail', to_recipients='different@example.test', subject='Changed', body_content='Changed', )] - with pytest.raises(env.actions.ActionExecutionError): + with pytest.raises(runtime.OperationRecoveryError): run_step(env, world, execution_intent='operate', journal=world.journal()) assert len(world.graph_calls) == 1 journal = world.journal() @@ -175,7 +176,7 @@ def refuse_result(_result): journal.sanitize = refuse_result key, _cached = journal.begin('ticket.create', {'title': 'Requested ticket'}) - with pytest.raises(ValueError): + with pytest.raises(runtime.OperationRecoveryError): journal.finish(key, {'id': 'created-ticket'}) with pytest.raises(runtime.OperationRecoveryError): journal.begin('ticket.create', {'title': 'Another ticket'}) @@ -197,7 +198,7 @@ def refuse_result(_result): origin={'run_id': 'run-2', 'attempt_index': 2, 'step_id': STEP}, execution_intent='operate', ): plugin = env.email.M365EmailPlugin(deepcopy(world.action)) - with pytest.raises(ValueError): + with pytest.raises(runtime.OperationRecoveryError): plugin.send_mail('recipient@example.test', 'Requested email', 'Prepared content.') with pytest.raises(runtime.OperationRecoveryError): plugin.send_mail('recipient@example.test', 'Another email', 'Do not send.') @@ -257,7 +258,7 @@ def load_plugin_from_manifest(self, manifest, user_id): assert runtime.operation_summary(result['operation_receipts'], '') == ( 'Microsoft 365 created the calendar event.' if mode == 'auto_send' else 'Delivery scheduled; not yet sent.' if mode == 'draft_delayed' - else 'Draft prepared; awaiting review.' + else 'Ready to review — not sent.' ) @@ -298,15 +299,16 @@ def test_agent_operation_uses_its_own_selection_and_rechecks_revocation(env, wor def test_unknown_graph_write_outcome_is_not_replayed(env, world, operations): + runtime, _delivery, _cards = operations world.action['additionalFields']['msgraph_mail_send_mode'] = 'auto_send' world.graph_error = requests.Timeout('simulated lost write response') world.replies = [send_call()] - with pytest.raises(env.actions.ActionExecutionError): + with pytest.raises(runtime.OperationRecoveryError): run_step(env, world, execution_intent='operate', journal=world.journal()) assert len(world.graph_calls) == 1 world.graph_error = None world.replies = [send_call()] - with pytest.raises(env.actions.ActionExecutionError): + with pytest.raises(runtime.OperationRecoveryError): run_step(env, world, execution_intent='operate', journal=world.journal()) assert len(world.graph_calls) == 1 @@ -323,6 +325,102 @@ def test_sign_in_repair_before_effect_allows_same_request_to_continue(env, world assert len(world.graph_calls) == 1 and result['operation_receipts'] +@pytest.mark.parametrize('sdk_responses', [False, True]) +def test_real_receipt_boundary_preserves_sdk_etag_and_completed_retry(operations, world, sdk_responses): + world.journal_store.sdk_responses = sdk_responses + first = world.journal() + key, _cached = first.begin('ticket.create', {'title': 'Requested ticket'}) + first.finish(key, {'id': 'created-ticket'}) + saved = world.journal_store.read_item(first.id, partition_key=ROOT_RUN) + assert type(saved) is not dict if sdk_responses else type(saved) is dict + assert saved['_etag'] and saved['calls'][key]['state'] == 'completed' + second = world.journal() + _key, cached = second.begin('ticket.create', {'title': 'Requested ticket'}) + assert cached == {'id': 'created-ticket'} + + +@pytest.mark.parametrize('publication_fails', [False, True]) +def test_saved_manual_draft_reference_crosses_bridge_before_receipt_failure( + env, world, operations, monkeypatch, publication_fails, +): + runtime, _delivery, _cards = operations + world.graph_response = (200, {'id': 'draft-1', 'changeKey': 'draft-v1'}) + world.replies = [send_call()] + references = [] + + def publish(reference): + references.append(reference) + if publication_fails: + raise ConnectionError('PRIVATE_UI_TRANSPORT') + + original = world.journal_store.replace_item + + def fail_finish(*args, **kwargs): + if any(call['state'] == 'completed' for call in kwargs['body']['calls'].values()): + raise ConnectionError('PRIVATE_RECEIPT_TRANSPORT') + return original(*args, **kwargs) + + monkeypatch.setattr(world.journal_store, 'replace_item', fail_finish) + journal = world.journal() + with env.orchestration.orchestration_action_card_events(publish): + with pytest.raises(runtime.OperationRecoveryError): + run_step(env, world, execution_intent='operate', journal=journal) + action = next(iter(world.pending.items.values())) + assert len(world.graph_calls) == len(world.pending.items) == len(references) == 1 + assert references[0] == { + 'id': action['id'], 'user_id': USER, 'conversation_id': CONVERSATION, + 'request_id': env.orchestration.step_request_id(f'{ROOT_RUN}\x00{STEP}'), + } + assert action['status'] == 'pending' + world.replies = [send_call()] + with pytest.raises(runtime.OperationRecoveryError): + run_step(env, world, execution_intent='operate', journal=world.journal()) + assert len(world.graph_calls) == len(world.pending.items) == 1 + + +def test_real_adapter_callback_relays_producer_identity(env, world, operations): + world.graph_response = (200, {'id': 'draft-1', 'changeKey': 'draft-v1'}) + world.replies = [send_call()] + events = [] + callback = env.adapters._m365_card_callback( + {'step_id': STEP}, SimpleNamespace(run_id='run-2', user_message_id='question-2'), events.append, + ) + with env.orchestration.orchestration_action_card_events(callback): + run_step(env, world, execution_intent='operate', journal=world.journal()) + action = next(iter(world.pending.items.values())) + assert events == [{ + 'type': 'm365_pending_action_reference', 'run_id': 'run-2', 'step_id': STEP, + 'user_message_id': 'question-2', + 'reference': { + 'id': action['id'], 'user_id': USER, 'conversation_id': CONVERSATION, + 'request_id': env.orchestration.step_request_id(f'{ROOT_RUN}\x00{STEP}'), + }, + }] + + +def test_receipt_conflict_retries_storage_not_the_effect(operations, world, monkeypatch): + from azure.cosmos.exceptions import CosmosAccessConditionFailedError + + first = world.journal() + key, _cached = first.begin('ticket.create', {'title': 'Requested ticket'}) + original = world.journal_store.replace_item + attempts = [] + + def conflict_once(*args, **kwargs): + attempts.append(kwargs['etag']) + if len(attempts) == 1: + raise CosmosAccessConditionFailedError(status_code=412) + return original(*args, **kwargs) + + monkeypatch.setattr(world.journal_store, 'replace_item', conflict_once) + first.finish(key, {'id': 'created-ticket'}) + assert len(attempts) == 2 and attempts[0] == attempts[1] + assert first.receipts == [{'function_name': 'ticket.create', 'result': {'id': 'created-ticket'}}] + second = world.journal() + _key, cached = second.begin('ticket.create', {'title': 'Requested ticket'}) + assert cached == {'id': 'created-ticket'} + + @pytest.mark.parametrize('input_limit', [128000, 1024]) def test_complete_named_content_respects_actual_model_budget(env, world, operations, monkeypatch, input_limit): runtime, _delivery, _cards = operations diff --git a/functional_tests/test_orchestration_output_lifecycle.py b/functional_tests/test_orchestration_output_lifecycle.py index 3cf094f00..86e701ae2 100644 --- a/functional_tests/test_orchestration_output_lifecycle.py +++ b/functional_tests/test_orchestration_output_lifecycle.py @@ -1,11 +1,12 @@ # test_orchestration_output_lifecycle.py """ Real retained-result/render/transport/commit/download lifecycle integration. -Version: 0.261.303 +Version: 0.261.324 Implemented in: 0.261.127 Container-only generated-file access covered in: 0.261.232 Merged documents rendered from their own lineage added in: 0.261.245 Failed files say why they could not be created in: 0.261.303 +SDK-shaped callback boundary normalized in: 0.261.324 Production modules (including the complete upload and download modules) run with external Azure I/O doubled. No AST-extracted service, model call, or provider is @@ -37,6 +38,7 @@ from azure.core.exceptions import AzureError, ResourceExistsError, ResourceNotFoundError from flask import Flask, g +from cosmos_document_utils import normalize_cosmos_document from content_screening.contracts import ( ScreeningConfigurationError, ScreeningError, @@ -77,8 +79,8 @@ class Crash(BaseException): class OutputContainer(AtomicMemoryContainer): - def __init__(self): - super().__init__("conversation_id") + def __init__(self, *, sdk_responses=True): + super().__init__("conversation_id", sdk_responses=sdk_responses) def query_items(self, query, parameters=None, partition_key=None, **kwargs): params = {entry["name"]: entry["value"] for entry in parameters or []} @@ -127,8 +129,8 @@ def query_items(self, query, parameters=None, partition_key=None, **kwargs): class MessageContainer(AtomicMemoryContainer): - def __init__(self): - super().__init__("conversation_id") + def __init__(self, *, sdk_responses=True): + super().__init__("conversation_id", sdk_responses=sdk_responses) self.before_create = None self.after_create = None @@ -302,12 +304,12 @@ def render(self, **kwargs): def restart(self, *, max_output_bytes=1024 * 1024): result_service = self.results.restart() - result_service.access.read_conversation = lambda conversation_id: self.conversations.read_item( + result_service.access.read_conversation = lambda conversation_id: normalize_cosmos_document(self.conversations.read_item( item=conversation_id, partition_key=conversation_id, - ) - result_service.access.read_run = lambda run_id: self.runs.read_item( + )) + result_service.access.read_run = lambda run_id: normalize_cosmos_document(self.runs.read_item( item=run_id, partition_key="conversation-1", - ) + )) store = OrchestrationOutputStore( self.runs, user_id="owner", conversation_id="conversation-1", read_conversation=result_service.access.read_conversation, diff --git a/functional_tests/test_support/cosmos_network_guard.py b/functional_tests/test_support/cosmos_network_guard.py new file mode 100644 index 000000000..ee44b5ace --- /dev/null +++ b/functional_tests/test_support/cosmos_network_guard.py @@ -0,0 +1,53 @@ +# cosmos_network_guard.py +"""Pytest plugin blocking network before collection for the Cosmos contract CI job. + +Version: 0.261.324 +Implemented in: 0.261.324 +""" + +import socket +from contextlib import ExitStack +from contextvars import ContextVar +from unittest.mock import patch + + +_PATCHES = None +_IN_SOCKETPAIR = ContextVar("cosmos_contract_socketpair", default=False) +_CONNECT = socket.socket.connect +_SOCKETPAIR = socket.socketpair + + +def _blocked(*args, **kwargs): + raise AssertionError("Cosmos response contract tests cannot access the network.") + + +def _connect(sock, address): + # Windows' asyncio wakeup pair uses the standard library's loopback fallback. + if _IN_SOCKETPAIR.get() and isinstance(address, tuple) and address[0] in {"127.0.0.1", "::1"}: + return _CONNECT(sock, address) + return _blocked() + + +def _socketpair(*args, **kwargs): + token = _IN_SOCKETPAIR.set(True) + try: + return _SOCKETPAIR(*args, **kwargs) + finally: + _IN_SOCKETPAIR.reset(token) + + +def pytest_sessionstart(session): + global _PATCHES + _PATCHES = ExitStack() + _PATCHES.enter_context(patch.object(socket.socket, "connect", _connect)) + _PATCHES.enter_context(patch.object(socket, "socketpair", _socketpair)) + for name in ("connect_ex", "sendto"): + _PATCHES.enter_context(patch.object(socket.socket, name, _blocked)) + _PATCHES.enter_context(patch.object(socket, "getaddrinfo", _blocked)) + + +def pytest_sessionfinish(session, exitstatus): + global _PATCHES + if _PATCHES is not None: + _PATCHES.close() + _PATCHES = None diff --git a/functional_tests/test_support/m365.py b/functional_tests/test_support/m365.py index c250749e8..febd1b008 100644 --- a/functional_tests/test_support/m365.py +++ b/functional_tests/test_support/m365.py @@ -1,5 +1,11 @@ # m365.py -"""Scoped cloud fakes for Microsoft 365 behavior tests (version 0.261.031).""" +"""Scoped cloud fakes for Microsoft 365 behavior tests. + +Version: 0.261.324 +Implemented in: 0.261.031 +SDK-shaped point responses are the default; sdk_responses=False is an explicit +legacy compatibility probe. Query rows remain plain JSON dictionaries. +""" import copy import threading @@ -7,6 +13,7 @@ from azure.core import MatchConditions from azure.cosmos import exceptions +from azure.cosmos._cosmos_responses import CosmosDict WORKFLOW_REVIEW = { @@ -64,8 +71,9 @@ def by_page(self, continuation_token=None): class CosmosContainer: """Implements conditional replace/batches, partitions, and native paging.""" - def __init__(self, partition_field="group_id"): + def __init__(self, partition_field="group_id", *, sdk_responses=True): self.partition_field = partition_field + self.sdk_responses = sdk_responses self.items = {} self.lock = threading.RLock() self.revision = 0 @@ -78,20 +86,24 @@ def _saved(self, body): self.revision += 1 return {**copy.deepcopy(body), "_etag": str(self.revision)} + def _response(self, body): + value = copy.deepcopy(dict(body)) + return CosmosDict(value, response_headers={}) if self.sdk_responses else value + def create_item(self, body=None, **kwargs): with self.lock: key = self._key(body) if key in self.items: raise exceptions.CosmosResourceExistsError(status_code=409, message="Already exists.") self.items[key] = self._saved(body) - return copy.deepcopy(self.items[key]) + return self._response(self.items[key]) def read_item(self, item, partition_key): with self.lock: key = partition_key, item if key not in self.items: raise exceptions.CosmosResourceNotFoundError(status_code=404, message="Not found.") - return copy.deepcopy(self.items[key]) + return self._response(self.items[key]) def replace_item(self, item, body, *, etag, match_condition): """Match Cosmos replace semantics: partition routing comes from the body.""" @@ -103,12 +115,12 @@ def replace_item(self, item, body, *, etag, match_condition): if self._key(body) != (partition_key, item): raise ValueError("Partition or id changed.") self.items[(partition_key, item)] = self._saved(body) - return copy.deepcopy(self.items[(partition_key, item)]) + return self._response(self.items[(partition_key, item)]) def upsert_item(self, body): with self.lock: self.items[self._key(body)] = self._saved(body) - return copy.deepcopy(self.items[self._key(body)]) + return self._response(self.items[self._key(body)]) def delete_item(self, item, partition_key): with self.lock: diff --git a/functional_tests/test_support/offline_bootstrap.py b/functional_tests/test_support/offline_bootstrap.py index 2bd3ee668..e2437c85d 100644 --- a/functional_tests/test_support/offline_bootstrap.py +++ b/functional_tests/test_support/offline_bootstrap.py @@ -1,5 +1,9 @@ # offline_bootstrap.py -"""External-I/O-only bootstrap seams for fresh-process application integration tests.""" +"""External-I/O-only bootstrap seams for fresh-process application integration tests. + +Version: 0.261.324 +Implemented in: 0.261.324 (SDK-shaped point response default) +""" import asyncio from contextlib import contextmanager @@ -11,23 +15,29 @@ from unittest.mock import patch from azure.cosmos.exceptions import CosmosResourceNotFoundError +from azure.cosmos._cosmos_responses import CosmosDict class OfflineContainer: - def __init__(self): + def __init__(self, *, sdk_responses=True): + self.sdk_responses = sdk_responses self.items = {} self.revision = 0 + def _response(self, body): + value = deepcopy(dict(body)) + return CosmosDict(value, response_headers={}) if self.sdk_responses else value + def read_item(self, item, partition_key, **kwargs): if item not in self.items: raise CosmosResourceNotFoundError(status_code=404) - return deepcopy(self.items[item]) + return self._response(self.items[item]) def upsert_item(self, body, **kwargs): self.revision += 1 saved = {**deepcopy(body), "_etag": str(self.revision)} self.items[saved["id"]] = saved - return deepcopy(saved) + return self._response(saved) create_item = upsert_item diff --git a/functional_tests/test_support/orchestration_harness_execution.py b/functional_tests/test_support/orchestration_harness_execution.py index 8db7af395..d08b33193 100644 --- a/functional_tests/test_support/orchestration_harness_execution.py +++ b/functional_tests/test_support/orchestration_harness_execution.py @@ -1,7 +1,7 @@ # orchestration_harness_execution.py """Initialized headless harness fixtures; only external storage/model I/O is doubled. -Version: 0.261.321 +Version: 0.261.324 Implemented in: 0.261.127 Publication-only admission guard updated in: 0.261.129 Direct result-store binding guard updated in: 0.261.130 @@ -171,8 +171,8 @@ def delete_blob(self, **kwargs): class HarnessMessageContainer(AtomicMemoryContainer): - def __init__(self): - super().__init__("conversation_id") + def __init__(self, *, sdk_responses=True): + super().__init__("conversation_id", sdk_responses=sdk_responses) def delete_item(self, item, partition_key, **kwargs): if "etag" not in kwargs: @@ -241,6 +241,10 @@ def __init__(self, monkeypatch): monkeypatch.setattr(self.bootstrap, "get_settings", lambda: deepcopy(self.settings)) monkeypatch.setattr(self.bootstrap, "get_user_settings", lambda user_id: {"settings": {}}) monkeypatch.setattr(self.planner, "AzureOpenAI", self.client) + # V2 authorized model bindings use the endpoint owner rather than the legacy planner. + monkeypatch.setattr( + importlib.import_module("functions_model_endpoint_runtime"), "AzureOpenAI", self.client, + ) monkeypatch.setattr(self.artifacts, "_service_factory", self.artifacts._service_factory) self.bootstrap.initialize_orchestration_artifact_access() diff --git a/functional_tests/test_support/orchestration_results.py b/functional_tests/test_support/orchestration_results.py index 5783e4c0d..450b2aa02 100644 --- a/functional_tests/test_support/orchestration_results.py +++ b/functional_tests/test_support/orchestration_results.py @@ -1,7 +1,7 @@ # orchestration_results.py """ External-I/O doubles and exact foundation fixtures. -Version: 0.261.125 +Version: 0.261.324 Implemented in: 0.261.125 """ @@ -71,8 +71,8 @@ def native_analysis(count=3): class ResultContainer(AtomicMemoryContainer): """Reuse the transactional fake with the shared result store's cleanup queries.""" - def __init__(self): - super().__init__("run_id") + def __init__(self, *, sdk_responses=True): + super().__init__("run_id", sdk_responses=sdk_responses) def delete_item(self, item, partition_key, **kwargs): if "etag" not in kwargs: diff --git a/functional_tests/test_support/orchestration_revisions.py b/functional_tests/test_support/orchestration_revisions.py index 7f002d374..e2112b84d 100644 --- a/functional_tests/test_support/orchestration_revisions.py +++ b/functional_tests/test_support/orchestration_revisions.py @@ -2,9 +2,10 @@ """ In-memory Cosmos boundary for conditional orchestration revision tests. -Version: 0.261.140 +Version: 0.261.324 Implemented in: 0.261.102 SDK-shaped point response coverage added in: 0.261.140 +SDK responses default in: 0.261.324; sdk_responses=False is a compatibility probe. Batch operations are formatted by the installed SDK and applied to a copy. A failed operation never makes preceding operations visible. Hooks permit deterministic races. @@ -21,7 +22,7 @@ class AtomicMemoryContainer: - def __init__(self, partition_field, *, sdk_responses=False): + def __init__(self, partition_field, *, sdk_responses=True): self.partition_field = partition_field self.sdk_responses = sdk_responses self.items = {} @@ -38,7 +39,7 @@ def __init__(self, partition_field, *, sdk_responses=False): self._lock = RLock() def _response(self, record): - value = deepcopy(record) + value = deepcopy(dict(record)) return CosmosDict(value, response_headers={}) if self.sdk_responses else value def _hook(self, name): diff --git a/functional_tests/test_support/workflow_chat_delivery_fakes.py b/functional_tests/test_support/workflow_chat_delivery_fakes.py index 46e53db35..8bdc59094 100644 --- a/functional_tests/test_support/workflow_chat_delivery_fakes.py +++ b/functional_tests/test_support/workflow_chat_delivery_fakes.py @@ -2,6 +2,9 @@ """ Reusable fakes for the workflow chat delivery tests. +Version: 0.261.324 +Implemented in: 0.261.324 (SDK-shaped Cosmos point defaults) + The fakes stand in for Cosmos containers, the durable runtime store, the result reader, the chat model and the notification helpers. The delivery contract and the worker under test stay real. Checks inside this module raise explicitly so they @@ -19,6 +22,7 @@ CosmosResourceExistsError, CosmosResourceNotFoundError, ) +from azure.cosmos._cosmos_responses import CosmosDict from functions_workflow_chat_delivery import ( build_chat_delivery_seed, @@ -94,8 +98,9 @@ def advance(self, **delta): class FakeContainer: """An in-memory container with ETag, 404, 409 and 412 semantics.""" - def __init__(self, name, items=None, query_handler=None, clock=None): + def __init__(self, name, items=None, query_handler=None, clock=None, *, sdk_responses=True): self.name = name + self.sdk_responses = sdk_responses self.items = {} self.calls = [] self.query_calls = [] @@ -109,8 +114,12 @@ def __init__(self, name, items=None, query_handler=None, clock=None): def _key(self, item_id): return str(item_id) + def _response(self, body): + value = copy.deepcopy(dict(body)) + return CosmosDict(value, response_headers={}) if self.sdk_responses else value + def _stamp(self, body): - stored = copy.deepcopy(body) + stored = copy.deepcopy(dict(body)) stored["_etag"] = f"etag-{self.name}-{next(self._etags)}" if self.clock is not None: stored["_ts"] = int(parse_iso(self.clock()).timestamp()) @@ -146,7 +155,7 @@ def read_item(self, item=None, partition_key=None, **kwargs): stored = self.items.get(self._key(item)) if stored is None: raise cosmos_error(404, "not found") - return copy.deepcopy(stored) + return self._response(stored) def replace_item(self, item=None, body=None, etag=None, match_condition=None, **kwargs): item_id = item.get("id") if isinstance(item, dict) else item @@ -159,19 +168,19 @@ def replace_item(self, item=None, body=None, etag=None, match_condition=None, ** raise cosmos_error(412, "precondition failed") updated = self._stamp(body) self.items[self._key(item_id)] = updated - return copy.deepcopy(updated) + return self._response(updated) def create_item(self, body=None, **kwargs): self.calls.append(("create_item", body.get("id"))) self._maybe_fail("create_item") if self._key(body.get("id")) in self.items: raise cosmos_error(409, "conflict") - return self.put(body) + return self._response(self.put(body)) def upsert_item(self, body=None, **kwargs): self.calls.append(("upsert_item", body.get("id"))) self._maybe_fail("upsert_item") - return self.put(body) + return self._response(self.put(body)) def delete_item(self, item=None, partition_key=None, **kwargs): item_id = item.get("id") if isinstance(item, dict) else item @@ -193,7 +202,7 @@ def query_items(self, query=None, parameters=None, partition_key=None, raise FakeCheckFailed(f"{self.name}: unexpected query {query!r}") params = {entry["name"]: entry["value"] for entry in parameters or []} rows = self.query_handler(self, query, params, partition_key) - return iter([copy.deepcopy(row) for row in rows]) + return iter([copy.deepcopy(dict(row)) for row in rows]) def writes(self, operation=None): names = ("replace_item", "create_item", "upsert_item", "delete_item") diff --git a/functional_tests/test_support/workflow_result_offline_app.py b/functional_tests/test_support/workflow_result_offline_app.py index f587b54ff..19272fd4c 100644 --- a/functional_tests/test_support/workflow_result_offline_app.py +++ b/functional_tests/test_support/workflow_result_offline_app.py @@ -1,8 +1,9 @@ # workflow_result_offline_app.py """ Offline application harness for the workflow-results-in-chat route tests. -Version: 0.261.214 +Version: 0.261.324 Implemented in: 0.261.214 +SDK-shaped point response defaults added in: 0.261.324 Boots the real application with only storage, the chat model and the network faked, so a test can drive the real JSON, SSE, history, export and collaboration @@ -61,8 +62,8 @@ def field_value(row, path): class Container(OfflineContainer): """Partition-aware offline storage that answers the queries these routes issue.""" - def __init__(self, partition_field="id"): - super().__init__() + def __init__(self, partition_field="id", *, sdk_responses=True): + super().__init__(sdk_responses=sdk_responses) self.partition_field = partition_field def read_item(self, item, partition_key, **kwargs): diff --git a/functional_tests/test_v2_m365_pending_actions_store.mjs b/functional_tests/test_v2_m365_pending_actions_store.mjs index 6511425cd..5e925a689 100644 --- a/functional_tests/test_v2_m365_pending_actions_store.mjs +++ b/functional_tests/test_v2_m365_pending_actions_store.mjs @@ -1,5 +1,5 @@ // test_v2_m365_pending_actions_store.mjs -// Version: 0.261.307 +// Version: 0.261.324 // Implemented in: 0.261.307 // Executes the state machine behind the Microsoft 365 outgoing-action cards against a fake server: // how a card is found, when it may be sent or cancelled, what happens when the server disagrees @@ -630,8 +630,7 @@ test('Send submits the version that was reviewed, once, with the Microsoft 365 s const card = cardOf(store, 'act-1'); assert.equal(card.action.status, 'sent'); assert.equal(card.busy, false); - assert.equal(card.notice.text, 'Send request checked. Review the server status and delivery note below.'); - assert.equal(card.notice.tone, 'info'); + assert.equal(card.notice, null, 'the authoritative sent status needs no duplicate generic send notice'); await stateOf(store).submit('act-1', 'send-now'); assert.equal(server.calls.length, 1, 'an action that went out cannot be sent again'); diff --git a/functional_tests/test_v2_m365_pending_actions_stream.mjs b/functional_tests/test_v2_m365_pending_actions_stream.mjs index 8214309e0..940f236f0 100644 --- a/functional_tests/test_v2_m365_pending_actions_stream.mjs +++ b/functional_tests/test_v2_m365_pending_actions_stream.mjs @@ -1,5 +1,5 @@ // test_v2_m365_pending_actions_stream.mjs -// Version: 0.261.307 +// Version: 0.261.324 // Implemented in: 0.261.307 // Executes the live paths that put a Microsoft 365 outgoing-action card in front of someone in V2 // chat: the notification hand-off that asks the page to bring a card into view, the SSE reader that @@ -16,6 +16,10 @@ import './test_support/tsResolve.mjs'; // The repository resolver must be registered before extensionless TypeScript imports load. const { useChatStore } = await import('../application/v2_ui/src/stores/chatStore.ts'); const { chatPendingActionsStore } = await import('../application/v2_ui/src/stores/m365PendingActionsStore.ts'); +const { useOrchestrationStore } = await import('../application/v2_ui/src/stores/orchestrationStore.ts'); +const { approveAndRunPlan } = await import('../application/v2_ui/src/lib/orchestrationController.ts'); +const { runOrchestration } = await import('../application/v2_ui/src/lib/orchestration.ts'); +const { normalizePlan } = await import('../application/v2_ui/src/lib/orchestrationPlan.ts'); const { carriesPendingActions, streamChat } = await import('../application/v2_ui/src/lib/sse.ts'); const { dispatchCollaborationEvent, subscribeToCollaborationEvents } = await import( '../application/v2_ui/src/lib/collaborationEvents.ts' @@ -129,6 +133,7 @@ function anchorOf(id) { visibleMessageIds: new Set(anchorable.map((message) => message.id)), lastMessageByRequestId: lastMessageByRequestId(anchorable), streamingUserMessageId: live && live.conversationId === pending.conversationId ? live.userMessageId : '', + streamingAtUserTurn: live?.placement === 'turn', }); } @@ -163,6 +168,7 @@ function holdStreams(answers = {}) { } catch { // The stream had already ended. } + }, { once: true }, ); @@ -197,6 +203,175 @@ function holdStreams(answers = {}) { }; } +const RUN_PATH = '/api/v2/orchestration/run'; + +/** Execute the real controller and SSE reader; only the HTTP boundary is synthetic. */ +async function withEmailRun(name, run) { + const conversationId = `email-${name}`; + const turnId = `turn-${name}`; + const userMessageId = `user-${name}`; + const runId = `run-${name}`; + openConversation(conversationId, { messages: [{ + id: userMessageId, role: 'user', conversation_id: conversationId, content: 'Prepare the email', + metadata: { orchestration_turn_id: turnId }, + }] }); + useOrchestrationStore.setState({ ...useOrchestrationStore.getInitialState() }, true); + const plan = normalizePlan({ + plan_id: `plan-${name}`, run_id: runId, turn_id: turnId, conversation_id: conversationId, + planner_contract_version: 2, intent: { summary: 'Prepare the email', complexity: 'simple' }, + steps: [{ + step_id: 'draft', capability_id: 'compose', title: 'Prepare the email', + arguments: {}, role: 'reason', estimated_cost: 'low', + }], + assumptions: [], status: 'awaiting_approval', approval: { mode: 'manual', state: 'pending' }, + validation: { valid: true, errors: [], warnings: [], repairs: [] }, + }); + useOrchestrationStore.getState().setPlan(conversationId, turnId, plan); + const cards = ['email-1', 'email-2'].map((id) => action(id, { + conversation_id: conversationId, request_id: `orch-${runId}-draft`, action_mode: 'manual', + })); + const streams = holdStreams({ + [LIST_PATH]: { pending_actions: [], continuation_token: '' }, + [`/api/v2/orchestration/runs/${runId}`]: { run: { + run_id: runId, conversation_id: conversationId, turn_id: turnId, plan, + status: 'failed', outcome: 'failed', finalization_status: 'failed', message_saved: false, + } }, + [`/api/v2/orchestration/runs/${runId}/steps`]: { steps: [] }, + ...Object.fromEntries(cards.map((card) => [`${LIST_PATH}/${card.id}`, { pending_action: card }])), + }); + const opened = streams.opened(RUN_PATH); + const running = approveAndRunPlan({ conversationId, turnId }); + await opened; + const creation = (card = cards[0], overrides = {}) => ({ + type: 'm365_pending_action', conversation_id: conversationId, run_id: runId, + step_id: 'draft', user_message_id: userMessageId, request_id: `orch-${runId}-draft`, + pending_action: card, ...overrides, + }); + const terminal = (overrides = {}) => ({ + type: 'orchestration_done', done: true, conversation_id: conversationId, run_id: runId, + turn_id: turnId, user_message_id: userMessageId, message_id: `answer-${name}`, + status: 'completed', outcome: 'completed', message_saved: true, full_content: 'Email prepared; review before sending.', + metadata: { m365_pending_action_ids: cards.map((card) => card.id) }, + m365_pending_actions: cards, ...overrides, + }); + try { + await run({ streams, running, cards, creation, terminal, conversationId, userMessageId }); + } finally { + try { + streams.emit(RUN_PATH, terminal()); + } catch { + // The test already closed this held reader. + } + streams.end(RUN_PATH); + await running; + await new Promise((resolve) => setTimeout(resolve, 0)); + streams.restore(); + resetStores(); + useOrchestrationStore.setState({ ...useOrchestrationStore.getInitialState() }, true); + } +} + +test('orchestration publishes two review cards beside the original request, then beneath its final reply', async () => { + await withEmailRun('complete', async ({ streams, running, cards, creation, terminal, userMessageId }) => { + assert.equal(store().liveStream.userMessageId, userMessageId); + for (const card of cards) streams.emit(RUN_PATH, creation(card)); + await settled(() => Object.keys(store().entries).length === 2, 'both draft cards'); + assert.equal(anchorOf('email-1'), userMessageId); + assert.equal(anchorOf('email-2'), userMessageId); + streams.emit(RUN_PATH, terminal()); + streams.end(RUN_PATH); + await running; + assert.equal(anchorOf('email-1'), 'answer-complete'); + assert.equal(anchorOf('email-2'), 'answer-complete'); + assert.equal(store().liveStream, null); + assert.equal(Object.keys(store().entries).length, 2); + assert.deepEqual(chat().messages.at(-1).metadata.m365_pending_action_ids, ['email-1', 'email-2']); + assert.deepEqual(chat().messages.at(-1).m365_pending_actions, cards); + assert.ok(streams.listRequests().length > 0, 'finish refresh remains a recovery fallback'); + assert.equal(streams.requests.filter((request) => request.path.match(/send-now|approve|cancel/)).length, 0); + }); +}); + +test('a failed report keeps the prepared draft and a distinct failed result; history restores authoritative references', async () => { + await withEmailRun('report-failed', async ({ streams, running, cards, creation, terminal, conversationId }) => { + streams.emit(RUN_PATH, creation()); + await settled(() => store().entries['email-1'], 'the prepared email'); + streams.emit(RUN_PATH, terminal({ + status: 'failed', outcome: 'failed', full_content: 'The email is prepared. The later report failed.', + m365_pending_actions: [cards[0]], metadata: { m365_pending_action_ids: ['email-1'] }, + })); + streams.end(RUN_PATH); + await running; + assert.equal(store().entries['email-1'].action.status, 'pending'); + assert.equal(anchorOf('email-1'), 'answer-report-failed'); + assert.equal(chat().messages.at(-1).metadata.orchestration.outcome, 'failed'); + const history = chat().messages.map(({ m365_pending_actions, ...message }) => message); + store().reset(); + store().setConversation(conversationId); + store().ingestMessages(history); + await settled(() => store().entries['email-1'], 'history reference to fetch current card'); + assert.equal(anchorOf('email-1'), 'answer-report-failed'); + }); +}); + +test('orchestration drops cross-conversation, stale-run and wrong-turn cards without adopting them', async () => { + await withEmailRun('scope', async ({ streams, cards, creation }) => { + streams.emit(RUN_PATH, creation(cards[0], { conversation_id: 'other' })); + streams.emit(RUN_PATH, creation(cards[0], { run_id: 'old-run' })); + streams.emit(RUN_PATH, creation(cards[0], { user_message_id: 'other-user-turn' })); + streams.emit(RUN_PATH, creation(cards[0], { step_id: 'not-in-plan' })); + streams.emit(RUN_PATH, { content: 'scope-checked' }); + await settled(() => chat().streamingContent === 'scope-checked'); + assert.deepEqual(Object.keys(store().entries), []); + useChatStore.setState({ activeConversationId: 'elsewhere', messages: [] }); + streams.emit(RUN_PATH, creation()); + await new Promise((resolve) => setTimeout(resolve, 0)); + assert.deepEqual(Object.keys(store().entries), []); + }); +}); + +test('a dropped orchestration stream keeps its saved card beside the request and refreshes without replay', async () => { + await withEmailRun('disconnect', async ({ streams, running, creation, userMessageId }) => { + streams.emit(RUN_PATH, creation()); + await settled(() => store().entries['email-1']); + // The attempt-read fallback is HTTP only, not an execution retry. + streams.end(RUN_PATH); + await settled(() => store().liveStream === null, 'the live surface to finish'); + assert.equal(anchorOf('email-1'), userMessageId); + assert.equal(store().entries['email-1'].action.status, 'pending'); + assert.ok(streams.listRequests().length); + await running; + assert.equal(streams.requests.filter((request) => request.path === RUN_PATH).length, 1); + }); +}); + +test('the real orchestration SSE reader treats card creation as an action frame, not answer text', async () => { + const streams = holdStreams(); + const events = []; + try { + const opened = streams.opened(RUN_PATH); + const running = runOrchestration({ conversation_id: 'reader', run_id: 'reader-run', plan_id: 'reader-plan' }, { + onM365PendingActions: () => events.push('card'), + onContent: () => events.push('content'), + onDone: () => events.push('done'), + }); + await opened; + streams.emit(RUN_PATH, { + type: 'm365_pending_action', conversation_id: 'reader', run_id: 'reader-run', + step_id: 'draft', user_message_id: 'user-reader', pending_action: action(), + content: 'This progress summary is not the final answer.', + }); + streams.emit(RUN_PATH, { content: 'Final reply.' }); + streams.emit(RUN_PATH, { done: true, status: 'completed' }); + streams.end(RUN_PATH); + const result = await running; + assert.equal(result.accumulated, 'Final reply.'); + assert.deepEqual(events, ['card', 'content', 'done']); + } finally { + streams.restore(); + } +}); + /** Run a test against a real send in `conversationId` whose reply stream the test controls. */ async function withLiveReply(conversationId, run, { answers = {}, text = 'Email Dana the numbers' } = {}) { openConversation(conversationId); diff --git a/functional_tests/test_v2_orchestration_streaming_surface.mjs b/functional_tests/test_v2_orchestration_streaming_surface.mjs index 77791b0e7..c1328b0fd 100644 --- a/functional_tests/test_v2_orchestration_streaming_surface.mjs +++ b/functional_tests/test_v2_orchestration_streaming_surface.mjs @@ -1,5 +1,5 @@ // test_v2_orchestration_streaming_surface.mjs -// Version: 0.261.256 +// Version: 0.261.324 // Implemented in: 0.261.256 // Executes the real chat store, orchestration store and orchestration controller to check who // owns the streaming surface during an orchestrated turn. While a plan runs, the plan card is the @@ -306,7 +306,7 @@ test('a turn re-keyed to the server conversation id keeps its phase', () => { test('every write that takes the streaming flag says who owns it', () => { const store = readFileSync(new URL('../application/v2_ui/src/stores/chatStore.ts', import.meta.url), 'utf8'); const takes = store.match(/streaming: true,/g) ?? []; - const owners = [...store.matchAll(/streaming: true,\s*\n\s*orchestrationSurface: (null|phase),/g)] + const owners = [...store.matchAll(/streaming: true,\s*(?:retryPresentation: presentation,\s*)?orchestrationSurface: (null|phase),/g)] .map((match) => match[1]); assert.ok(takes.length >= 5, 'the chat starters and the orchestration seam are all present'); assert.equal(owners.length, takes.length, 'a stream that takes `streaming` must name its owner'); @@ -316,5 +316,5 @@ test('every write that takes the streaming flag says who owns it', () => { new URL('../application/v2_ui/src/lib/orchestrationController.ts', import.meta.url), 'utf8', ); const runs = controller.match(/beginOrchestrationTurn\([^)]*'running'\)/g) ?? []; - assert.deepEqual(runs, ["beginOrchestrationTurn(conversationId, '', false, undefined, undefined, 'running')"]); + assert.deepEqual(runs, ["beginOrchestrationTurn(conversationId, '', false, turnId, undefined, 'running')"]); }); diff --git a/functional_tests/test_workflow_result_store.py b/functional_tests/test_workflow_result_store.py index 565a857c1..0e7dc706e 100644 --- a/functional_tests/test_workflow_result_store.py +++ b/functional_tests/test_workflow_result_store.py @@ -1,11 +1,11 @@ # test_workflow_result_store.py """ Functional tests for durable, scoped workflow task-result persistence. -Version: 0.261.305 +Version: 0.261.324 Implemented in: 0.261.106 HNS directory cleanup implemented in: 0.261.305 -JSON-copying Cosmos and byte-copying Blob fakes exercise immutable writes, +SDK-shaped point responses, plain query rows and byte-copying Blob fakes exercise immutable writes, backend selection, bounded range reads, identity/integrity checks, quota enforcement, and cleanup beyond a history page. No deployed app is imported. """ @@ -29,6 +29,7 @@ ServiceRequestError, ) from azure.cosmos.exceptions import CosmosResourceExistsError, CosmosResourceNotFoundError +from azure.cosmos._cosmos_responses import CosmosDict STORE_PATH = Path(__file__).resolve().parents[1].joinpath( @@ -48,7 +49,10 @@ def canonical_bytes(value): class FakeCosmosContainer: - def __init__(self): + """Plain point responses require the explicit compatibility option.""" + + def __init__(self, *, sdk_responses=True): + self.sdk_responses = sdk_responses self.records = {} self.reads = [] self.creates = [] @@ -61,6 +65,10 @@ def __init__(self): self.delete_error = None self.query_error = None + def _response(self, record): + value = json_copy(record) + return CosmosDict(value, response_headers={}) if self.sdk_responses else value + def create_item(self, *, body): self.creates.append(body["id"]) if self.fail_create_at == len(self.creates): @@ -69,7 +77,7 @@ def create_item(self, *, body): if key in self.records: raise CosmosResourceExistsError(status_code=409, message="Fake provider conflict.") self.records[key] = json_copy(body) - return json_copy(self.records[key]) + return self._response(self.records[key]) def read_item(self, *, item, partition_key): self.reads.append((partition_key, item)) @@ -77,7 +85,7 @@ def read_item(self, *, item, partition_key): raise self.read_error if (partition_key, item) not in self.records: raise CosmosResourceNotFoundError(status_code=404, message="Fake provider item details.") - return json_copy(self.records[(partition_key, item)]) + return self._response(self.records[(partition_key, item)]) def delete_item(self, *, item, partition_key): if self.delete_error is not None: diff --git a/functional_tests/test_workflow_runtime_store.py b/functional_tests/test_workflow_runtime_store.py index fee64e9e0..af532c238 100644 --- a/functional_tests/test_workflow_runtime_store.py +++ b/functional_tests/test_workflow_runtime_store.py @@ -1,7 +1,7 @@ # test_workflow_runtime_store.py """ Functional tests for the durable workflow runtime-control journal. -Version: 0.261.111 +Version: 0.261.324 Implemented in: 0.261.111 These tests validate milestone 3 runtime-control durability: scoped control-row @@ -18,6 +18,7 @@ from pathlib import Path from azure.core import MatchConditions +from azure.cosmos._cosmos_responses import CosmosDict from azure.cosmos.exceptions import ( CosmosHttpResponseError, CosmosResourceExistsError, @@ -49,7 +50,10 @@ def advance(self, seconds): class FakeCosmosContainer: - def __init__(self): + """SDK point documents by default; plain mode is an explicit compatibility case.""" + + def __init__(self, *, sdk_responses=True): + self.sdk_responses = sdk_responses self.records = {} self.etag_counter = 0 self.before_replace = None @@ -60,6 +64,10 @@ def __init__(self): def _key(self, partition_key, item): return (partition_key, item) + def _response(self, record): + value = json_copy(record) + return CosmosDict(value, response_headers={}) if self.sdk_responses else value + def _with_etag(self, record): self.etag_counter += 1 copied = json_copy(record) @@ -71,13 +79,13 @@ def create_item(self, *, body): if key in self.records: raise CosmosResourceExistsError(status_code=409, message="Fake duplicate") self.records[key] = self._with_etag(body) - return json_copy(self.records[key]) + return self._response(self.records[key]) def read_item(self, *, item, partition_key): key = self._key(partition_key, item) if key not in self.records: raise CosmosResourceNotFoundError(status_code=404, message="Fake missing") - return json_copy(self.records[key]) + return self._response(self.records[key]) def replace_item(self, *, item, body, etag, match_condition): key = self._key(body["run_id"], item) @@ -91,7 +99,7 @@ def replace_item(self, *, item, body, etag, match_condition): raise CosmosHttpResponseError(status_code=412, message="Fake stale etag") self.records[key] = self._with_etag(body) self.replaces.append(json_copy(self.records[key])) - return json_copy(self.records[key]) + return self._response(self.records[key]) def force_replace(self, body): key = self._key(body["run_id"], body["id"]) diff --git a/scripts/check_cosmos_response_boundaries.py b/scripts/check_cosmos_response_boundaries.py new file mode 100644 index 000000000..3b369a216 --- /dev/null +++ b/scripts/check_cosmos_response_boundaries.py @@ -0,0 +1,399 @@ +# check_cosmos_response_boundaries.py +"""Maintain reviewed Cosmos point boundaries and test-double representation contracts. + +This is a change/inventory guard, not a static proof of interprocedural safety. +Regeneration retains reviews only for unchanged boundary implementations. +""" + +import argparse +import ast +import hashlib +import json +import os +import subprocess +import sys +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +INVENTORY = ROOT / "functional_tests" / "cosmos_response_boundaries.json" +POINT_METHODS = frozenset({ + "read_item", "create_item", "replace_item", "upsert_item", "patch_item", "delete_item", +}) +BATCH_METHODS = frozenset({"execute_item_batch", "read_many"}) +CLASSIFICATIONS = frozenset({ + "normalized-strict", "sdk-compatible", "response-unused", "not-cosmos", +}) +DOUBLE_CLASSIFICATIONS = frozenset({ + "sdk-default", "legacy-inline", "domain-double", "fault-injection", "explicit-compatibility", +}) +COSMOS_DOUBLE_BASES = frozenset({ + "AtomicMemoryContainer", "CosmosContainer", "OfflineContainer", "FakeCosmosContainer", "ResultContainer", +}) +DOMAIN_DOUBLE_TARGETS = frozenset({ + "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeRuntime", + "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeRuntime.factory._Store", + "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeResultReader", + "functional_tests/test_support/orchestration_results.py::ResultFixture", +}) +CORE_CONTRACT_TESTS = frozenset({ + "functional_tests/test_cosmos_document_boundaries.py", + "functional_tests/test_orchestration_cosmos_response_contract.py", + "functional_tests/test_orchestration_operation_runtime.py", + "functional_tests/test_orchestration_email_review_flow.py", + "functional_tests/test_orchestration_operation_imports.py", + "functional_tests/test_orchestration_result_imports.py", + "functional_tests/test_orchestration_failure_telemetry.py", + "functional_tests/test_m365_cosmos_sdk_contract.py", + "functional_tests/test_m365_pending_authorization.py", + "functional_tests/test_workflow_chat_delivery_concurrency.py", + "functional_tests/test_workflow_chat_delivery_save_guard.py", + "functional_tests/test_orchestration_harness_execution.py::test_catalog_and_scheduler_fixtures_share_current_transport_types", +}) + + +def _digest(node): + return hashlib.sha256(ast.dump(node, include_attributes=False).encode("utf-8")).hexdigest() + + +def review_digest(boundary): + return hashlib.sha256(json.dumps(boundary, sort_keys=True).encode("utf-8")).hexdigest() + + +def _python_files(directory): + for parent, directories, filenames in os.walk(directory): + directories[:] = sorted( + name for name in directories if name not in {".venv", "node_modules", "__pycache__"} + ) + for name in sorted(filenames): + if name.endswith(".py"): + yield Path(parent) / name + + +class BoundaryVisitor(ast.NodeVisitor): + def __init__(self): + self.scope = [] + self.owners = {} + + def visit_ClassDef(self, node): + self.scope.append(node.name) + self.generic_visit(node) + self.scope.pop() + + def visit_FunctionDef(self, node): + self.scope.append(node.name) + self._record_scope(node, ".".join(self.scope)) + self.generic_visit(node) + self.scope.pop() + + visit_AsyncFunctionDef = visit_FunctionDef + + def visit_Module(self, node): + self._record_scope(node, "") + self.generic_visit(node) + + def _record_scope(self, node, owner): + points = [] + queries = [] + batches = [] + parents = {child: parent for parent in ast.walk(node) for child in ast.iter_child_nodes(parent)} + pending = list(ast.iter_child_nodes(node)) + children = [] + while pending: + child = pending.pop(0) + if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)): + continue + children.append(child) + pending.extend(ast.iter_child_nodes(child)) + for child in sorted(children, key=lambda value: (getattr(value, "lineno", 0), getattr(value, "col_offset", 0))): + methods = POINT_METHODS | BATCH_METHODS | {"query_items", "read_all_items"} + if isinstance(child, ast.Attribute) and child.attr in methods: + method, receiver = child.attr, child.value + elif ( + isinstance(child, ast.Call) and isinstance(child.func, ast.Name) + and child.func.id == "getattr" and len(child.args) > 1 + and isinstance(child.args[1], ast.Constant) and child.args[1].value in methods + ): + method, receiver = child.args[1].value, child.args[0] + else: + continue + parent = parents.get(child) + called = isinstance(parent, ast.Call) and parent.func is child + statement = parents.get(parent) if called else parent + exposure = ( + "unused" if isinstance(statement, ast.Expr) + else "returned" if isinstance(statement, ast.Return) + else "consumed" if called else "helper-reference" + ) + entry = { + "method": method, + "receiver": ast.unparse(receiver), + "response": exposure, + } + target = ( + queries if method in {"query_items", "read_all_items"} + else batches if method in BATCH_METHODS else points + ) + target.append(entry) + if points or queries or batches: + self.owners[owner] = {"sha256": _digest(node), "points": points, "queries": queries, "batches": batches} + + +def scan_boundaries(root=ROOT): + owners = {} + for directory in ("application", "scripts", "deployers"): + for path in _python_files(root / directory): + visitor = BoundaryVisitor() + tree = ast.parse(path.read_text(encoding="utf-8-sig")) + visitor.visit(tree) + module_digest = _digest(tree) + for name, value in visitor.owners.items(): + value["module_sha256"] = module_digest + owners[f"{path.relative_to(root).as_posix()}::{name}"] = value + return owners + + +def inspect_doubles(filename, source): + doubles = {} + + class DoubleVisitor(ast.NodeVisitor): + def __init__(self, filename): + self.filename = filename + self.scope = [] + self.seams = {} + + def visit_FunctionDef(self, node): + self.scope.append(node.name) + self.generic_visit(node) + self.scope.pop() + + visit_AsyncFunctionDef = visit_FunctionDef + + def visit_ClassDef(self, node): + self.scope.append(node.name) + methods = {item.name for item in node.body if isinstance(item, ast.FunctionDef)} + key = f"{self.filename}::{'.'.join(self.scope)}" + inherited = [ + ast.unparse(base) for base in node.bases + if isinstance(base, ast.Name) and base.id in COSMOS_DOUBLE_BASES + ] + cosmos = bool(methods & (POINT_METHODS | BATCH_METHODS) or inherited) + if cosmos or key in DOMAIN_DOUBLE_TARGETS: + doubles[key] = { + "sha256": _digest(node), "methods": sorted(methods & (POINT_METHODS | BATCH_METHODS)), + "kind": "class" if cosmos else "domain", "inherited_bases": inherited, + } + self.generic_visit(node) + self.scope.pop() + + def visit_Call(self, node): + methods = {keyword.arg for keyword in node.keywords} & (POINT_METHODS | BATCH_METHODS) + patched = ( + isinstance(node.func, ast.Attribute) and node.func.attr in {"setattr", "object"} + and len(node.args) > 1 and isinstance(node.args[1], ast.Constant) + and node.args[1].value in POINT_METHODS | BATCH_METHODS + ) + if patched: + methods.add(node.args[1].value) + if methods: + scope = ".".join(self.scope) or "" + sequence = self.seams.get(scope, 0) + 1 + self.seams[scope] = sequence + key = f"{self.filename}::{scope}::point-seam-{sequence}" + doubles[key] = {"sha256": _digest(node), "methods": sorted(methods), "kind": "seam"} + self.generic_visit(node) + + tree = ast.parse(source) + DoubleVisitor(filename).visit(tree) + for node in ast.walk(tree): + if ( + not isinstance(node, ast.Assign) or not isinstance(node.value, ast.Constant) + or not isinstance(node.value.value, str) + or not any(f"def {method}(" in node.value.value for method in POINT_METHODS | BATCH_METHODS) + ): + continue + targets = [target.id for target in node.targets if isinstance(target, ast.Name)] + if not targets: + continue + try: + embedded_tree = ast.parse(node.value.value) + except SyntaxError: + continue + embedded = inspect_doubles(f"{filename}::embedded-{targets[0]}", node.value.value) + for value in embedded.values(): + value["embedded_source_sha256"] = _digest(embedded_tree) + doubles.update(embedded) + imports = [ + node for node in ast.walk(tree) if isinstance(node, (ast.Import, ast.ImportFrom)) + ] + imports_digest = _digest(ast.Module(body=imports, type_ignores=[])) + for value in doubles.values(): + value["imports_sha256"] = imports_digest + return doubles + + +def scan_doubles(root=ROOT): + doubles = {} + for directory in ("functional_tests", "ui_tests"): + for path in _python_files(root / directory): + doubles.update(inspect_doubles( + path.relative_to(root).as_posix(), path.read_text(encoding="utf-8-sig"), + )) + return doubles + + +def validate_inventory(actual, doubles, inventory, root=ROOT, *, domain_targets=()): + errors = [] + evidence_cache = {} + for section, current, classifications in ( + ("owners", actual, CLASSIFICATIONS), ("doubles", doubles, DOUBLE_CLASSIFICATIONS), + ): + reviewed = inventory.get(section, {}) + for key in sorted(current.keys() | reviewed.keys()): + if key not in reviewed: + errors.append(f"Unreviewed {section}: {key}") + continue + if key not in current: + errors.append(f"Stale {section} review: {key}") + continue + entry = reviewed[key] + if entry.get("boundary") != current[key]: + errors.append(f"Changed {section} requires review: {key}") + if entry.get("classification") not in classifications or not entry.get("contract", "").strip(): + errors.append(f"Missing classification/consumer contract: {key}") + if section == "owners" and entry.get("classification") in {"normalized-strict", "sdk-compatible"}: + if entry.get("evidence_scope") not in {"owner-runtime", "sdk-api-and-source-review"}: + errors.append(f"Missing runtime evidence scope: {key}") + elif entry.get("evidence_scope") == "owner-runtime" and entry.get("tests") == [ + "functional_tests/test_cosmos_document_boundaries.py" + ]: + errors.append(f"Utility-only test is not owner-runtime evidence: {key}") + evidence = entry.get("tests", []) + if entry.get("classification") not in {"response-unused", "not-cosmos", "domain-double", "legacy-inline"}: + if not evidence: + errors.append(f"Missing runtime evidence: {key}") + for test in evidence: + filename, _, function = test.partition("::") + path = root / filename + if not path.resolve().is_relative_to(root.resolve()) or not filename.startswith(("functional_tests/", "ui_tests/")): + errors.append(f"Evidence must be a repository test: {test}") + continue + if filename not in evidence_cache: + evidence_cache[filename] = ( + {node.name for node in ast.walk(ast.parse(path.read_text(encoding="utf-8-sig"))) + if isinstance(node, ast.FunctionDef)} + if path.is_file() else None + ) + names = evidence_cache[filename] + if names is None: + errors.append(f"Missing evidence file: {test}") + elif function and function not in names: + errors.append(f"Stale evidence function: {test}") + baseline = inventory.get("legacy_double_baseline", {}) + for key, digest in baseline.items(): + if key not in doubles or review_digest(doubles[key]) != digest: + errors.append(f"Stale legacy double exemption: {key}") + for key, entry in inventory.get("doubles", {}).items(): + if entry.get("classification") == "legacy-inline" and ( + key not in doubles or baseline.get(key) != review_digest(doubles[key]) + ): + errors.append(f"New/changed Cosmos double cannot use legacy-inline: {key}") + seam_baseline = inventory.get("compatibility_seam_baseline", {}) + for key, digest in seam_baseline.items(): + if key not in doubles or review_digest(doubles[key]) != digest: + errors.append(f"Stale compatibility seam exemption: {key}") + for key, entry in inventory.get("doubles", {}).items(): + if entry.get("classification") == "explicit-compatibility" and ( + key not in doubles or doubles[key].get("kind") != "seam" + or seam_baseline.get(key) != review_digest(doubles[key]) + ): + errors.append(f"New/changed seam needs runtime fault-injection evidence: {key}") + owner_baseline = inventory.get("source_review_baseline", {}) + for key, digest in owner_baseline.items(): + if key not in actual or review_digest(actual[key]) != digest: + errors.append(f"Stale source-only owner review: {key}") + for key, entry in inventory.get("owners", {}).items(): + if entry.get("evidence_scope") == "sdk-api-and-source-review": + if key not in actual or owner_baseline.get(key) != review_digest(actual[key]): + errors.append(f"New/changed owner needs owner-runtime SDK evidence: {key}") + for key in domain_targets: + if key not in doubles: + errors.append(f"Stale domain-double classification target: {key}") + return errors + + +def refresh_inventory(current, doubles, previous): + """Never assign a compatibility classification or preserve a changed review automatically.""" + result = { + **previous, + "schema_version": 1, + "legacy_double_baseline": previous.get("legacy_double_baseline", {}), + "source_review_baseline": previous.get("source_review_baseline", {}), + "owners": {}, "doubles": {}, + } + for section, entries in (("owners", current), ("doubles", doubles)): + for key, boundary in sorted(entries.items()): + prior = previous.get(section, {}).get(key, {}) + result[section][key] = ( + prior if prior.get("boundary") == boundary else { + "boundary": boundary, "classification": "review-required", + "contract": "", "tests": [], + } + ) + return result + + +def runtime_test_targets(inventory): + targets = set(CORE_CONTRACT_TESTS) + for section in ("owners", "doubles"): + for entry in inventory.get(section, {}).values(): + if entry.get("evidence_scope") == "owner-runtime" or entry.get("classification") in { + "sdk-default", "domain-double", "fault-injection", + }: + targets.update(entry.get("tests", [])) + return sorted(targets) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + mode = parser.add_mutually_exclusive_group() + mode.add_argument("--refresh", action="store_true", help="Stage changed boundaries for manual review.") + mode.add_argument("--run-contracts", action="store_true", help="Run core and reviewed owner/double SDK tests with network blocked.") + args = parser.parse_args() + previous = json.loads(INVENTORY.read_text(encoding="utf-8")) if INVENTORY.exists() else {} + owners, doubles = scan_boundaries(), scan_doubles() + if args.refresh: + result = refresh_inventory(owners, doubles, previous) + INVENTORY.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8") + return 0 + errors = validate_inventory(owners, doubles, previous, domain_targets=DOMAIN_DOUBLE_TARGETS) + for error in errors: + print(error) + print(f"Cosmos boundary review: {len(owners)} owners, {len(doubles)} doubles, {len(errors)} review gaps.") + if errors: + return 1 + if args.run_contracts: + targets = runtime_test_targets(previous) + environment = { + **os.environ, + "PYTHONPATH": os.pathsep.join(( + str(ROOT / "application" / "single_app"), str(ROOT / "functional_tests"), + os.environ.get("PYTHONPATH", ""), + )), + } + selectors = [] + for target in targets: + filename, separator, scope = target.partition("::") + selectors.append(str(ROOT / filename) + (separator + scope if scope else "")) + return subprocess.run( + [ + sys.executable, "-m", "pytest", "-p", "test_support.cosmos_network_guard", + *selectors, "-q", "--disable-warnings", "--tb=short", + ], + cwd=ROOT, env=environment, check=False, + ).returncode + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/ui_tests/test_v2_m365_pending_action_cards.py b/ui_tests/test_v2_m365_pending_action_cards.py index 8de541f8c..4c1488ab9 100644 --- a/ui_tests/test_v2_m365_pending_action_cards.py +++ b/ui_tests/test_v2_m365_pending_action_cards.py @@ -1,7 +1,7 @@ # test_v2_m365_pending_action_cards.py """ UI test for Microsoft 365 pending-action cards in the V2 chat. -Version: 0.261.307 +Version: 0.261.324 Implemented in: 0.261.307 This test ensures that a saved outgoing Microsoft 365 email or calendar action is drawn in the V2 @@ -39,10 +39,9 @@ LIST_PATH = "/api/msgraph/pending-actions" USER_TEXT = "Email Ann the quarterly numbers" REPLY_TEXT = "I saved a draft email to Ann. Review it below before it goes out." -PENDING_STATUS = "Pending \u2014 not sent." +PENDING_STATUS = "Ready to review \u2014 not sent." SENT_STATUS = "Accepted for sending \u2014 recipient delivery is not confirmed." CANCELLED_STATUS = "Cancelled \u2014 no further delivery is scheduled for this action." -SEND_NOTICE = "Send request checked. Review the server status and delivery note below." CANCEL_NOTICE = ( "Cancellation checked. The server status below is authoritative; " "this does not recall an already sent item." @@ -78,7 +77,7 @@ method, path, search: target.search, headers: { ...(init.headers || {}) }, body: typeof init.body === 'string' ? JSON.parse(init.body) : null, }); - if (path === '/api/chat/stream') { + if (path === '/api/chat/stream' || path === '/api/v2/orchestration/run') { return new Response(new ReadableStream({ start(controller) { window.pushChatFrame = (frame) => controller.enqueue(encoder.encode(`data: ${JSON.stringify(frame)}\n\n`)); @@ -272,6 +271,7 @@ def test_card_follows_its_reply_from_streaming_to_saved(page): expect(card).to_have_count(1) expect(card).to_have_attribute("data-pending-action-id", "act-live") expect(card.get_by_test_id("v2-pending-action-status")).to_have_text(PENDING_STATUS) + expect(card.locator('[data-status="pending"]')).to_have_text("Ready to review") expect(card.get_by_test_id("v2-pending-action-send")).to_be_enabled() expect(card.get_by_test_id("v2-pending-action-cancel")).to_be_enabled() expect(root.get_by_test_id("v2-pending-action-slot")).to_have_count(1) @@ -313,6 +313,97 @@ def test_card_follows_its_reply_from_streaming_to_saved(page): assert errors == [] +@pytest.mark.parametrize("viewport", [{"width": 1440, "height": 1000}, {"width": 390, "height": 844}]) +@pytest.mark.parametrize("report_failed", [False, True]) +def test_orchestrated_email_review_stays_with_its_turn_and_requires_explicit_keyboard_choice(page, viewport, report_failed): + """A live manual draft is reviewable before the report, and never sends on preparation or reload.""" + _require_bundle() + errors = _collect_page_errors(page) + page.set_viewport_size(viewport) + draft_warning = "The original Outlook draft remains. Do not send the retained draft again." + action = pending_action("act-orchestrated", action_mode="manual", delivery_note=draft_warning) + user_message = { + "id": "u-orchestrated", "conversation_id": CONVERSATION_ID, "role": "user", "content": USER_TEXT, + "metadata": {"orchestration_turn_id": "email-turn"}, + } + with harness_build.start_static_server() as origin: + root = _open_chat(page, origin, messages=[user_message], by_id=[action]) + page.evaluate("""() => { + const H = window.OrchHarness; + const plan = H.plan.normalizePlan({ + plan_id: 'email-plan', run_id: 'email-run', turn_id: 'email-turn', + conversation_id: 'conversation-m365', planner_contract_version: 2, + intent: {summary: 'Prepare the email', complexity: 'simple'}, + steps: [{step_id: 'draft', capability_id: 'compose', title: 'Prepare the email', + arguments: {}, role: 'reason', estimated_cost: 'low'}], + assumptions: [], status: 'awaiting_approval', approval: {mode: 'manual', state: 'pending'}, + validation: {valid: true, errors: [], warnings: [], repairs: []}, + }); + H.stores.orchestration.useOrchestrationStore.getState().setPlan('conversation-m365', 'email-turn', plan); + void H.controller.approveAndRunPlan({conversationId: 'conversation-m365', turnId: 'email-turn'}); + }""") + page.wait_for_function("() => typeof window.pushChatFrame === 'function'") + creation = { + "type": "m365_pending_action", "conversation_id": CONVERSATION_ID, "run_id": "email-run", + "step_id": "draft", "user_message_id": "u-orchestrated", "request_id": "orch-email-run-draft", + "pending_action": action, + } + page.evaluate("(frame) => window.pushChatFrame(frame)", creation) + card = root.get_by_test_id("v2-pending-action-card") + expect(card).to_have_count(1) + expect(card.get_by_test_id("v2-pending-action-status")).to_have_text(PENDING_STATUS) + expect(root.get_by_test_id("v2-pending-actions-section")).to_have_count(0) + user = root.locator('[id="message-u-orchestrated"]') + expect(user.get_by_test_id("v2-pending-action-card")).to_have_count(1) + summary = card.locator("summary") + summary.focus() + summary.press("Enter") + expect(card.get_by_test_id("v2-pending-action-body")).to_be_visible() + assert not _posts_to_actions(page) + + reply_text = "The email is prepared. The later report failed." if report_failed else REPLY_TEXT + status = "failed" if report_failed else "completed" + terminal = { + "type": "orchestration_done", "done": True, "conversation_id": CONVERSATION_ID, + "run_id": "email-run", "turn_id": "email-turn", "user_message_id": "u-orchestrated", + "message_id": "email-answer", "status": status, "outcome": status, "message_saved": True, + "full_content": reply_text, "metadata": {"m365_pending_action_ids": [action["id"]]}, + "m365_pending_actions": [action], + } + page.evaluate("""(frame) => { window.pushChatFrame(frame); window.closeChatFrames(); }""", terminal) + expect(root.locator('[id="message-email-answer"]').get_by_test_id("v2-pending-action-card")).to_have_count(1) + expect(card.get_by_test_id("v2-pending-action-status")).to_have_text(PENDING_STATUS) + expect(root.get_by_text(reply_text, exact=True).first).to_be_visible() + expect(root.get_by_test_id("v2-pending-actions-section")).to_have_count(0) + expect(card).to_have_count(1) + assert not _posts_to_actions(page) + assert page.evaluate("() => document.documentElement.scrollWidth <= window.innerWidth") + + # Reload with ids alone; the owner-authorized detail read recovers the same position. + saved_reply = { + "id": "email-answer", "conversation_id": CONVERSATION_ID, "role": "assistant", + "content": reply_text, "metadata": {"m365_pending_action_ids": [action["id"]]}, + } + root = _open_chat(page, origin, messages=[user_message, saved_reply], by_id=[action]) + card = root.locator('[id="message-email-answer"]').get_by_test_id("v2-pending-action-card") + expect(card).to_have_count(1) + expect(root.get_by_test_id("v2-pending-actions-section")).to_have_count(0) + expect(card.get_by_test_id("v2-pending-action-status")).to_have_text(PENDING_STATUS) + assert not _posts_to_actions(page) + choice = card.get_by_test_id("v2-pending-action-cancel" if report_failed else "v2-pending-action-send") + expect(choice).to_be_enabled() + choice.focus() + choice.press("Enter") + expect(card.get_by_test_id("v2-pending-action-status")).to_have_text(CANCELLED_STATUS if report_failed else SENT_STATUS) + expect(card.get_by_text(draft_warning, exact=True)).to_be_visible() + if not report_failed: + expect(card.locator('[data-status="sent"]')).to_have_text("Accepted for sending") + expect(card.get_by_test_id("v2-pending-action-notice")).to_have_count(0) + assert len(_posts_to_actions(page)) == 1 + assert _posts_to_actions(page)[0]["body"] == {"expected_version": "v1"} + assert errors == [] + + def test_reopened_conversation_draws_cards_under_their_reply_or_in_the_section(page): _require_bundle() errors = _collect_page_errors(page) @@ -405,7 +496,7 @@ def test_send_and_cancel_act_on_the_saved_version_and_report_the_servers_answer( send_card.get_by_test_id("v2-pending-action-send").click() expect(send_card.get_by_test_id("v2-pending-action-status")).to_have_text(SENT_STATUS) - expect(send_card.get_by_test_id("v2-pending-action-notice")).to_have_text(SEND_NOTICE) + expect(send_card.get_by_test_id("v2-pending-action-notice")).to_have_count(0) expect(send_card.get_by_test_id("v2-pending-action-send")).to_have_count(0) expect(send_card.get_by_test_id("v2-pending-action-cancel")).to_have_count(0) # The other card is untouched by it.