diff --git a/application/single_app/admin_settings_fields.py b/application/single_app/admin_settings_fields.py index 09a98f471..5949aca7c 100644 --- a/application/single_app/admin_settings_fields.py +++ b/application/single_app/admin_settings_fields.py @@ -2557,10 +2557,10 @@ { "key": "enable_office_embedded_image_analysis", "type": "switch", - "label": "Analyze images embedded in DOCX and PPTX files", + "label": "Analyze images embedded in DOCX, PPTX, and Excel files", "help": ( - "Neither extraction engine describes figures inside Word and PowerPoint " - "files. With this on, embedded images are pulled out, analysed with " + "Native extraction does not describe image pixels inside Word, PowerPoint, " + "or Excel files. With this on, embedded images are pulled out, analysed with " "whichever engine backs the selected extraction mode, and indexed as " "their own citable chunks. Works with Standard extraction too." ), diff --git a/application/single_app/config.py b/application/single_app/config.py index 0e1c90c28..3dde6e2f0 100644 --- a/application/single_app/config.py +++ b/application/single_app/config.py @@ -103,7 +103,7 @@ EXECUTOR_MAX_WORKERS = 30 CHAT_STREAM_EXECUTOR_MAX_WORKERS = max(8, int(os.getenv('SIMPLECHAT_CHAT_STREAM_WORKERS', '32') or '32')) SESSION_TYPE = 'filesystem' -VERSION = "0.261.407" +VERSION = "0.261.409" 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/content_screening/access.py b/application/single_app/content_screening/access.py index f03685900..b2a538e12 100644 --- a/application/single_app/content_screening/access.py +++ b/application/single_app/content_screening/access.py @@ -93,6 +93,7 @@ "group_document_collaboration_operation", "document_share_details", "public_document_projection_writer", "public_document_collaboration_operation", + "excel_native_inventory", # Recomputed per request from current authorization, so a stored copy is # always stale. The group projection re-adds them after serialization. "document_actions", "document_collaboration_actions", @@ -1068,6 +1069,23 @@ def _with_origin_kind(payload, document): return payload +def _with_current_excel_metadata(payload, document): + metadata = payload.get("accessibility_metadata") + marker = document.get(SCREENING_FIELD) + if ( + not isinstance(metadata, Mapping) or metadata.get("format") not in {"xlsx", "xlsm", "xls"} + or not isinstance(marker, Mapping) + ): + return payload + active = marker.get("active_blob") + inventory = metadata.get("inventory_storage") + digest = inventory.get("source_sha256") if isinstance(inventory, Mapping) else None + if not isinstance(active, Mapping) or not digest or active.get("content_hash") != digest: + payload.pop("accessibility_metadata", None) + payload["native_inspection_status"] = "requires_active_source_inspection" + return payload + + def public_document_payload(document): if not isinstance(document, Mapping): return {} @@ -1080,7 +1098,7 @@ def public_document_payload(document): payload["status"] = resolve_metadata_completion_status( document.get("status"), document.get("metadata_extraction_status"), ) - return payload + return _with_current_excel_metadata(payload, document) try: _require_available_metadata(document) config = import_module("config") @@ -1116,7 +1134,7 @@ def public_document_payload(document): document.get("status"), document.get("metadata_extraction_status"), ) payload["num_chunks"] = chunk_count_for_response(document) - return payload + return _with_current_excel_metadata(payload, document) def public_documents_payload(documents, user_id=None, *, metadata_reader=None): diff --git a/application/single_app/content_screening/extraction.py b/application/single_app/content_screening/extraction.py index d70649cec..9298e63ee 100644 --- a/application/single_app/content_screening/extraction.py +++ b/application/single_app/content_screening/extraction.py @@ -9,6 +9,7 @@ from dataclasses import dataclass, field from datetime import date, datetime, time from pathlib import Path +from typing import Callable from content_screening.contracts import ( CONTENT_METADATA_FIELDS, @@ -43,6 +44,8 @@ class ExtractionCapture: completed: bool = False preloaded_text: bool = False failure_code: str | None = None + artifact_storage: object | None = field(default=None, repr=False, compare=False) + heartbeat: Callable[[], None] | None = field(default=None, repr=False, compare=False) def _append(self, target, unit): self.characters += len(unit.text) diff --git a/application/single_app/content_screening/publication.py b/application/single_app/content_screening/publication.py index af3f77b54..4e3468043 100644 --- a/application/single_app/content_screening/publication.py +++ b/application/single_app/content_screening/publication.py @@ -2,6 +2,7 @@ """Application-side projection of inspected canonical content.""" import hashlib +import io import json import mimetypes from urllib.parse import quote @@ -171,6 +172,34 @@ def _remove_previous_raw_projection(document, scan, projection, storage): ) +def _tabular_publication_chunks(units, file_name, max_characters, *, include_native, schema_text=None): + chunks = publication_chunks([ + ContentUnit("table-schema", table_schema_text(units) if schema_text is None else schema_text, {"kind": "schema"}), + ], max_characters) + if not include_native or not any(unit.locator.get("kind") == "excel_native" for unit in units): + return chunks + prefix = f"### Excel native inspection\nWorkbook: {file_name}\nSearch preview; complete records are in the native inventory.\n" + if len(prefix) >= max_characters: + prefix = "### Excel native inspection\n" + if len(prefix) >= max_characters: + raise ScreeningValidationError("The publication chunk size cannot fit the Excel native evidence marker.") + remaining = 1000000 + for unit in units: + if unit.locator.get("kind") != "excel_native" or remaining <= len(prefix): + continue + preview = ContentUnit(unit.unit_id, unit.text[:remaining], unit.locator) + for chunk in publication_chunks([preview], max_characters - len(prefix)): + if remaining <= len(prefix): + break + text = prefix + chunk["chunk_text"][:remaining - len(prefix)] + chunks.append({ + **chunk, "chunk_text": text, "chunk_sequence": len(chunks) + 1, + "end": chunk["start"] + len(text) - len(prefix), + }) + remaining -= len(text) + return chunks + + def publish_document(document, units, scan, actor_id, *, storage): helpers = _document_helpers() subject = subject_from_document(document) @@ -195,9 +224,14 @@ def publish_document(document, units, scan, actor_id, *, storage): max(1, helpers.get_embedding_usable_tokens(settings) // 4), ) if structured_sheets(units): - chunks = publication_chunks([ - ContentUnit("table-schema", table_schema_text(units), {"kind": "schema"}), - ], max_characters) + extension = "." + file_name.rsplit(".", 1)[-1].lower() + schema_text = None + if extension in {".xlsx", ".xlsm", ".xls"}: + schema_text = helpers._build_tabular_schema_summary(io.BytesIO(content), file_name, extension) + chunks = _tabular_publication_chunks( + units, file_name, max_characters, include_native=not scan.get("sanitized"), + schema_text=schema_text, + ) else: chunks = publication_chunks(units, max_characters) if not chunks: diff --git a/application/single_app/content_screening/service.py b/application/single_app/content_screening/service.py index 7cf8c93e9..f81577d58 100644 --- a/application/single_app/content_screening/service.py +++ b/application/single_app/content_screening/service.py @@ -472,7 +472,7 @@ def process_screened_upload(document_id, user_id, temp_file_path, original_filen def _extract_and_inspect(scan, actor_id, source_path, processor, *, repository, storage, extraction_mode_override=None): subject = Subject.from_dict(scan["subject"]) scan, owner = _claim_scan(repository, _read_scan(repository, scan["id"])) - capture = ExtractionCapture(subject, scan["id"], scan["original_file_name"]) + capture = ExtractionCapture(subject, scan["id"], scan["original_file_name"], artifact_storage=storage) last_heartbeat = _now() def heartbeat(): @@ -1049,6 +1049,11 @@ def reprocess_document(subject, actor_id, extraction_mode, *, repository=None, s def prepare_document_deletion(document, actor_id, *, repository=None, storage=None): """Revoke a screened document before removing private evidence and originals.""" if SCREENING_FIELD not in document: + if ( + "excel_native_inventory" in document + or str(document.get("file_name") or "").lower().endswith((".xlsx", ".xlsm", ".xls")) + ): + _storage(storage).delete_revision(subject_from_document(document)) return repository = _repository(repository) subject = subject_from_document(document) diff --git a/application/single_app/excel_workbook_reader.py b/application/single_app/excel_workbook_reader.py new file mode 100644 index 000000000..b9df0fad2 --- /dev/null +++ b/application/single_app/excel_workbook_reader.py @@ -0,0 +1,1001 @@ +# excel_workbook_reader.py +"""Read saved workbook cells and table boundaries without executing Excel.""" + +from collections import Counter, OrderedDict +from copy import deepcopy +import hashlib +import io +import json +import math +import os +import posixpath +import re +import zipfile +from threading import RLock + +from defusedxml.ElementTree import iterparse +from defusedxml.ElementTree import fromstring +from openpyxl.formula.translate import Translator, TranslatorError +from openpyxl.styles.numbers import BUILTIN_FORMATS, is_date_format +from openpyxl.utils.cell import get_column_letter, range_boundaries +from openpyxl.utils.datetime import CALENDAR_MAC_1904, CALENDAR_WINDOWS_1900, from_excel +import xlrd + +from functions_office_media import ( + OFFICE_ZIP_ALLOWED_COMPRESSION, + OFFICE_ZIP_MAX_ENTRIES, + _read_zip_entry_bounded, +) + + +EXCEL_WORKBOOK_SCHEMA_VERSION = "2.0" +EXCEL_XML_PART_MAX_BYTES = 16 * 1024 * 1024 +EXCEL_SHEET_MAX_BYTES = 256 * 1024 * 1024 +EXCEL_SCAN_MAX_BYTES = 512 * 1024 * 1024 +EXCEL_SHARED_STRINGS_MAX_CHARS = 64 * 1024 * 1024 +EXCEL_MAX_SHEETS = 100 +EXCEL_MAX_TABLES = 5000 +EXCEL_MAX_PREVIEW_ROWS = 500 +EXCEL_PREVIEW_MAX_BYTES = 1024 * 1024 +EXCEL_PREVIEW_MAX_COLUMNS = 128 +EXCEL_MAX_COLUMNS = 16384 +EXCEL_MAX_ROWS = 1048576 +_INTEGER = re.compile(r"^[+-]?\d+$") +_CELL = re.compile(r"^\$?([A-Z]{1,3})\$?([1-9]\d*)$") +_LAYOUT_ELEMENTS = { + "mergeCell", "col", "pane", "pageMargins", "pageSetup", "printOptions", + "sheetFormatPr", "sheetView", "autoFilter", "sheetPr", +} +_MANIFEST_CACHE = OrderedDict() +_MANIFEST_LOCK = RLock() +_MANIFEST_CACHE_MAX_BYTES = 16 * 1024 * 1024 + + +def local_name(tag): + return tag.rsplit("}", 1)[-1] + + +def local_attribute(element, name, default=""): + return next((value for key, value in element.attrib.items() if local_name(key) == name), default) + + +def first_element(element, name): + return next((child for child in element.iter() if local_name(child.tag) == name), None) + + +def element_text(element): + return "".join(element.itertext()) if element is not None else "" + + +def cell_coordinates(reference): + match = _CELL.fullmatch(str(reference or "").upper()) + if not match: + raise ValueError("Invalid Excel cell reference.") + column = 0 + for letter in match[1]: + column = column * 26 + ord(letter) - ord("A") + 1 + row = int(match[2]) + if column > EXCEL_MAX_COLUMNS or row > EXCEL_MAX_ROWS: + raise ValueError("Excel cell reference is outside worksheet bounds.") + return row, column + + +def bounded_range(reference): + try: + bounds = range_boundaries(str(reference or "").replace("$", "")) + except (TypeError, ValueError) as error: + raise ValueError("Invalid Excel table range.") from error + low_column, low_row, high_column, high_row = bounds + if ( + any(type(value) is not int for value in bounds) + or not 1 <= low_column <= high_column <= EXCEL_MAX_COLUMNS + or not 1 <= low_row <= high_row <= EXCEL_MAX_ROWS + ): + raise ValueError("Excel table range is outside worksheet bounds.") + return bounds + + +def _range_reference(low_column, low_row, high_column, high_row): + return f"{get_column_letter(low_column)}{low_row}:{get_column_letter(high_column)}{high_row}" + + +def _blank_cell(reference): + return { + "cell": reference, "value": None, "raw_value": None, "value_type": "blank", + "value_status": "blank", "formula": None, "formula_type": None, + "formula_reference": None, "cached_value_available": True, "style_id": 0, + } + + +class _BoundedXmlStream: + def __init__(self, stream, reader, limit): + self.stream = stream + self.reader = reader + self.limit = limit + self.bytes_read = 0 + + def read(self, size=-1): + size = min(65536, size) if size >= 0 else 65536 + data = self.stream.read(size) + self.bytes_read += len(data) + self.reader.scanned_xml_bytes += len(data) + if self.bytes_read > self.limit or self.reader.scanned_xml_bytes > EXCEL_SCAN_MAX_BYTES: + raise ValueError("Excel XML scan exceeded its supported byte limit.") + return data + + +class _Region: + """An inferred occupied region, retaining samples but never all its rows.""" + + def __init__(self, row, low_column, high_column): + self.low_row = row + self.high_row = row + self.low_column = low_column + self.high_column = high_column + self.row_count = 0 + self.samples = [] + self.header_signature = None + self.repeated_header_rows = [] + self.repeated_header_count = 0 + self.ambiguous = False + self._last_row = None + + def observe(self, row, cells): + if self._last_row == row: + return + self._last_row = row + self.high_row = row + self.row_count += 1 + occupied = { + column: cell for column, cell in cells.items() + if self.low_column <= column <= self.high_column + } + if len(self.samples) < 8: + self.samples.append((row, deepcopy(occupied))) + self._choose_header() + signature = self._signature(occupied) + if ( + self.header_signature is not None and signature == self.header_signature + and row != self.header_row + ): + self.repeated_header_count += 1 + if len(self.repeated_header_rows) < 100: + self.repeated_header_rows.append(row) + + def _signature(self, cells): + return tuple( + (cells.get(column) or {}).get("value") + for column in range(self.low_column, self.high_column + 1) + ) + + def _choose_header(self): + self.header_row = None + self.title_rows = [] + self.header_status = "absent" + if not self.samples: + return + index = 0 + if len(self.samples[0][1]) == 1 and self.high_column > self.low_column: + if len(self.samples) < 2: + return + self.title_rows.append(self.samples[0][0]) + index = 1 + row, cells = self.samples[index] + values = self._signature(cells) + nonblank = [value for value in values if value is not None and value != ""] + if not nonblank or not all(isinstance(value, str) for value in nonblank): + return + if len(nonblank) == 1: + later = self.samples[index + 1:] + if not any( + any(cell["value_type"] not in ("text", "blank") for cell in sample.values()) + for _, sample in later + ): + self.header_status = "ambiguous" + return + self.header_row = row + self.header_status = "ambiguous" if self.ambiguous else "inferred" + self.header_signature = values + + def descriptor(self, sheet): + self._choose_header() + header_cells = next((cells for row, cells in self.samples if row == self.header_row), {}) + labels = [] + for column in range(self.low_column, self.high_column + 1): + value = (header_cells.get(column) or {}).get("value") + labels.append(str(value) if value is not None and value != "" else get_column_letter(column)) + names = _unique_column_names(labels, self.low_column) + reference = _range_reference(self.low_column, self.low_row, self.high_column, self.high_row) + identity = hashlib.sha256(f"{sheet['part']}\0{reference}".encode()).hexdigest()[:20] + return { + "id": f"region-{identity}", "name": f"Data block {reference}", "sheet": sheet["name"], + "origin": "inferred", "range": reference, "min_row": self.low_row, + "max_row": self.high_row, "min_column": self.low_column, + "max_column": self.high_column, "header_row": self.header_row, + "header_row_count": int(self.header_row is not None), "header_status": self.header_status, + "title_rows": self.title_rows, "totals_row_count": 0, + "data_start_row": (self.header_row + 1) if self.header_row else self.low_row, + "data_end_row": self.high_row, + "row_count": self.row_count - len(self.title_rows) - int(self.header_row is not None) - self.repeated_header_count, + "repeated_header_rows": self.repeated_header_rows, + "repeated_header_count": self.repeated_header_count, + "header_signature": list(self.header_signature) if self.header_signature is not None else None, + "columns": [ + {"id": get_column_letter(column), "name": name, "column": column} + for column, name in zip(range(self.low_column, self.high_column + 1), names) + ], + } + + +def _unique_column_names(labels, low_column): + counts = Counter(labels) + return [ + f"{label} [{get_column_letter(low_column + index)}]" if counts[label] > 1 else label + for index, label in enumerate(labels) + ] + + +class _Regions: + def __init__(self): + self.active = [] + self.finished = [] + self.last_row = None + + def add(self, row, cells): + occupied = sorted( + column for column, cell in cells.items() + if cell["value_status"] != "blank" + ) + if not occupied: + self._close() + self.last_row = row + return + if self.last_row is not None and row > self.last_row + 1: + self._close() + runs = [] + start = end = occupied[0] + for column in occupied[1:]: + if column == end + 1: + end = column + else: + runs.append((start, end)) + start = end = column + runs.append((start, end)) + touched = [] + for low, high in runs: + matches = [region for region in self.active if low <= region.high_column and high >= region.low_column] + if len(matches) == 1: + region = matches[0] + region.low_column = min(region.low_column, low) + region.high_column = max(region.high_column, high) + elif not matches: + region = _Region(row, low, high) + self.active.append(region) + else: + region = matches[0] + region.ambiguous = True + for other in matches[1:]: + self.active.remove(other) + self.finished.append(other) + if region not in touched: + touched.append(region) + for region in list(self.active): + if region not in touched: + self.active.remove(region) + self.finished.append(region) + for region in touched: + region.observe(row, cells) + self.last_row = row + if len(self.active) + len(self.finished) > EXCEL_MAX_TABLES: + raise ValueError("Workbook contains more supported data regions than can be inspected.") + + def _close(self): + self.finished.extend(self.active) + self.active = [] + + def finish(self, sheet): + self._close() + return [region.descriptor(sheet) for region in self.finished] + + +class ExcelWorkbookReader: + """A bounded source reader shared by inspection, previews, and analytical replay.""" + + def __init__(self, source, extension=None): + self.source = source + self.extension = (extension or os.path.splitext(os.fspath(source))[1] if isinstance(source, (str, os.PathLike)) else extension or ".xlsx").lower() + self.archive = None + self.legacy = None + self._owns_archive = not isinstance(source, zipfile.ZipFile) + self._xml_cache = {} + self._shared_strings = None + self._number_formats = None + self._manifest = None + self._sheet_cache = {} + self.scanned_xml_bytes = 0 + self.epoch = CALENDAR_WINDOWS_1900 + self.coverage_notes = [] + if self.extension == ".xls": + if isinstance(source, (bytes, bytearray)): + self.legacy = xlrd.open_workbook(file_contents=bytes(source), on_demand=True, formatting_info=True, ragged_rows=True) + else: + self.legacy = xlrd.open_workbook(source, on_demand=True, formatting_info=True, ragged_rows=True) + self.sheets = [ + {"name": self.legacy.sheet_names()[index], "part": f"biff-sheet-{index}", "index": index, + "type": "worksheet", "state": self.legacy.sheet_by_index(index).visibility} + for index in range(min(self.legacy.nsheets, EXCEL_MAX_SHEETS)) + ] + self.workbook_relationships = {} + else: + self.archive = source if isinstance(source, zipfile.ZipFile) else zipfile.ZipFile( + io.BytesIO(bytes(source)) if isinstance(source, (bytes, bytearray)) else source + ) + names = self.archive.namelist() + if len(names) > OFFICE_ZIP_MAX_ENTRIES or len(names) != len(set(names)): + self.close() + raise ValueError("Invalid or oversized workbook package.") + relationships = self.relationships("") + workbook_part = next((value["part"] for value in relationships.values() if value["kind"] == "officeDocument" and not value["external"]), "xl/workbook.xml") + root = self.read_xml(workbook_part) + self.workbook_relationships = self.relationships(workbook_part) + properties = first_element(root, "workbookPr") + if properties is not None and properties.get("date1904") in ("1", "true"): + self.epoch = CALENDAR_MAC_1904 + self.sheets = [] + entries = first_element(root, "sheets") + entries = list(entries) if entries is not None else [] + if len(entries) > EXCEL_MAX_SHEETS: + self.coverage_notes.append(f"Only the first {EXCEL_MAX_SHEETS} sheets were inspected.") + for entry in entries[:EXCEL_MAX_SHEETS]: + relation = self.workbook_relationships.get(local_attribute(entry, "id")) + if not relation or relation["external"] or relation["kind"] not in ("worksheet", "chartsheet"): + self.coverage_notes.append("A sheet relationship was unavailable or unsupported.") + continue + if not entry.get("name") or len(entry.get("name")) > 128: + raise ValueError("A worksheet name exceeds its supported bound.") + self.sheets.append({ + "name": entry.get("name", ""), "part": relation["part"], + "type": relation["kind"], "state": entry.get("state", "visible"), + }) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() + + def close(self): + if self.archive is not None and self._owns_archive: + self.archive.close() + if self.legacy is not None: + self.legacy.release_resources() + + @property + def sheet_names(self): + return [sheet["name"] for sheet in self.sheets] + + def read_xml(self, part, required=True): + if part in self._xml_cache: + return self._xml_cache[part] + if part not in self.archive.namelist(): + if not required: + return None + raise ValueError("A required workbook part is missing.") + data = _read_zip_entry_bounded(self.archive, part, EXCEL_XML_PART_MAX_BYTES) + if data is None: + raise ValueError("Workbook metadata XML exceeds its supported byte limit.") + self.scanned_xml_bytes += len(data) + if self.scanned_xml_bytes > EXCEL_SCAN_MAX_BYTES: + raise ValueError("Excel XML scan exceeded its supported byte limit.") + root = fromstring(data) + self._xml_cache[part] = root + return root + + def relationships(self, part): + path = posixpath.join(posixpath.dirname(part), "_rels", posixpath.basename(part) + ".rels") + root = self.read_xml(path, required=False) + result = {} + for element in root if root is not None else []: + target = local_attribute(element, "Target") + external = local_attribute(element, "TargetMode").lower() == "external" + resolved = None + if not external: + if any(character in target for character in ("\\", ":", "?", "#")): + self.coverage_notes.append("Invalid package relationship targets were not followed.") + continue + resolved = posixpath.normpath(target.lstrip("/") if target.startswith("/") else posixpath.join(posixpath.dirname(part), target)) + if resolved.startswith("../") or resolved in ("..", ".", ""): + self.coverage_notes.append("Out-of-package relationship targets were not followed.") + continue + result[local_attribute(element, "Id")] = { + "kind": local_attribute(element, "Type").rsplit("/", 1)[-1], + "part": resolved, "external": external, "target": target, + } + return result + + def resolve_sheet(self, name): + exact = next((sheet for sheet in self.sheets if sheet["name"] == name), None) + if exact: + return exact + matches = [sheet for sheet in self.sheets if sheet["name"].strip().casefold() == str(name or "").strip().casefold()] + if len(matches) != 1: + raise ValueError("The requested worksheet was not found or is ambiguous.") + return matches[0] + + def _strings(self): + if self._shared_strings is not None: + return self._shared_strings + self._shared_strings = [] + relation = next((value for value in self.workbook_relationships.values() if value["kind"] == "sharedStrings" and not value["external"]), None) + if relation is None: + return self._shared_strings + count = 0 + root = None + with self._xml_events(relation["part"], EXCEL_SHEET_MAX_BYTES) as events: + for event, element in events: + if root is None and event == "start": + root = element + if event == "end" and local_name(element.tag) == "si": + value = element_text(element) + count += len(value) + if count > EXCEL_SHARED_STRINGS_MAX_CHARS or len(self._shared_strings) >= 1000000: + raise ValueError("Workbook shared strings exceed their supported memory bound.") + self._shared_strings.append(value) + element.clear() + if root is not None: + root.clear() + return self._shared_strings + + def _formats(self): + if self._number_formats is not None: + return self._number_formats + self._number_formats = ["General"] + relation = next((value for value in self.workbook_relationships.values() if value["kind"] == "styles" and not value["external"]), None) + if relation is None: + return self._number_formats + root = self.read_xml(relation["part"]) + custom = {int(element.get("numFmtId")): element.get("formatCode", "") for element in root.iter() if local_name(element.tag) == "numFmt"} + xfs = first_element(root, "cellXfs") + if xfs is not None: + if len(xfs) > 20000: + raise ValueError("Workbook styles exceed their supported count.") + self._number_formats = [ + custom.get(int(xf.get("numFmtId", 0)), BUILTIN_FORMATS.get(int(xf.get("numFmtId", 0)), "General")) + for xf in xfs + ] or ["General"] + return self._number_formats + + def _xml_events(self, part, limit): + return _XmlEvents(self, part, limit) + + def _cell(self, element, row_style, column_styles, shared_formulas): + reference = element.get("r") + _, column = cell_coordinates(reference) + style = element.get("s") + if style is None: + style = row_style or next((value for low, high, value in column_styles if low <= column <= high), "0") + result = _blank_cell(reference) + result["style_id"] = int(style) + formats = self._formats() + result["number_format"] = formats[result["style_id"]] if 0 <= result["style_id"] < len(formats) else None + formula = next((child for child in element if local_name(child.tag) == "f"), None) + value_element = next((child for child in element if local_name(child.tag) == "v"), None) + raw = value_element.text if value_element is not None else None + kind = element.get("t", "n") + if formula is not None: + text = formula.text or "" + result["formula_type"] = formula.get("t", "normal") + result["formula_reference"] = formula.get("ref") + identifier = formula.get("si") + if result["formula_type"] == "shared" and identifier is not None: + if text: + shared_formulas[identifier] = (reference, "=" + text) + elif identifier in shared_formulas: + origin, original = shared_formulas[identifier] + try: + text = Translator(original, origin=origin).translate_formula(reference).lstrip("=") + except TranslatorError as error: + raise ValueError("A shared formula reference could not be inspected.") from error + else: + result["formula_type"] = "unresolved_shared" + result["formula"] = "=" + text if text else None + result["cached_value_available"] = raw is not None + if raw is None: + result["value_status"] = "cache_missing" + if kind == "inlineStr": + raw = element_text(first_element(element, "is")) + value, value_type = raw, "text" + elif kind == "s": + strings = self._strings() + index = int(raw) if raw is not None else -1 + if not 0 <= index < len(strings): + raise ValueError("A workbook shared string reference is invalid.") + value, value_type = strings[index], "text" + elif raw is None: + value, value_type = None, "blank" + elif kind == "b": + if raw not in ("0", "1"): + raise ValueError("A saved workbook Boolean is invalid.") + value, value_type = raw == "1", "boolean" + elif kind in ("str", "d", "e"): + value = raw + value_type = {"str": "text", "d": "date", "e": "error"}[kind] + else: + try: + value = int(raw) if _INTEGER.fullmatch(raw) else float(raw) + except ValueError as error: + raise ValueError("A saved workbook numeric value is invalid.") from error + if not math.isfinite(value): + raise ValueError("A saved workbook numeric value is not finite.") + value_type = "number" + if result["number_format"] and is_date_format(result["number_format"]): + try: + value = from_excel(value, self.epoch).isoformat() + except (OverflowError, ValueError) as error: + raise ValueError("A saved workbook date is invalid.") from error + value_type = "date" + result.update(value=value, raw_value=raw, value_type=value_type) + if result["value_status"] != "cache_missing": + result["value_status"] = "blank" if value is None or value == "" else "error" if value_type == "error" else "saved" + return result + + def iter_sheet_rows(self, sheet, metadata=None): + sheet = self.resolve_sheet(sheet) if isinstance(sheet, str) else sheet + if self.legacy is not None: + legacy = self.legacy.sheet_by_index(sheet["index"]) + for row_index in range(legacy.nrows): + cells = {} + for column in range(legacy.row_len(row_index)): + cell = legacy.cell(row_index, column) + reference = f"{get_column_letter(column + 1)}{row_index + 1}" + value = cell.value + result = _blank_cell(reference) + if cell.ctype not in (xlrd.XL_CELL_EMPTY, xlrd.XL_CELL_BLANK): + value_type = {xlrd.XL_CELL_TEXT: "text", xlrd.XL_CELL_BOOLEAN: "boolean", xlrd.XL_CELL_DATE: "date", xlrd.XL_CELL_ERROR: "error"}.get(cell.ctype, "number") + if value_type == "boolean": + value = bool(value) + elif value_type == "date": + value = xlrd.xldate.xldate_as_datetime(value, self.legacy.datemode).isoformat() + result.update(value=value, raw_value=cell.value, value_type=value_type, value_status="saved") + cells[column + 1] = result + yield row_index + 1, cells, {} + self.legacy.unload_sheet(sheet["index"]) + return + metadata = metadata if metadata is not None else {} + column_styles, shared_formulas = [], {} + stack = [] + previous_row = 0 + with self._xml_events(sheet["part"], EXCEL_SHEET_MAX_BYTES) as events: + for event, element in events: + name = local_name(element.tag) + if event == "start": + stack.append(element) + if len(stack) > 64: + raise ValueError("Workbook XML nesting exceeds its supported depth.") + continue + if name == "row": + row = int(element.get("r")) + if not previous_row < row <= EXCEL_MAX_ROWS: + raise ValueError("A worksheet row is outside supported bounds.") + previous_row = row + cells = {} + for child in element: + if local_name(child.tag) == "c": + cell = self._cell(child, element.get("s"), column_styles, shared_formulas) + cell_row, column = cell_coordinates(cell["cell"]) + if cell_row != row or column in cells: + raise ValueError("Worksheet cell coordinates are inconsistent.") + cells[column] = cell + yield row, cells, dict(element.attrib) + if len(stack) > 1: + stack[-2].remove(element) + element.clear() + elif name == "col": + if element.get("style") is not None: + column_styles.append((int(element.get("min")), int(element.get("max")), element.get("style"))) + if name in _LAYOUT_ELEMENTS: + layout = metadata.setdefault("layout", []) + if len(layout) < 200: + layout.append({"type": name, **dict(element.attrib)}) + elif name == "headerFooter": + metadata["header_footer"] = { + "flags": dict(element.attrib), + "expressions": {local_name(child.tag): child.text or "" for child in element}, + } + elif name == "cfRule": + metadata["conditional_format_rules"] = metadata.get("conditional_format_rules", 0) + 1 + elif name == "hyperlink": + metadata.setdefault("hyperlinks", []).append(dict(element.attrib)) + elif name == "dataValidation": + metadata.setdefault("validations", []).append({ + **dict(element.attrib), + "formulas": {local_name(child.tag): child.text or "" for child in element}, + }) + elif name == "tablePart": + metadata.setdefault("table_relationship_ids", []).append(local_attribute(element, "id")) + elif name in ("oleObjects", "cellControl", "featurePropertyBag"): + metadata.setdefault("unsupported_controls", []).append(name) + stack.pop() + + def _named_tables(self, sheet, metadata): + if self.archive is None: + return [] + relationships = self.relationships(sheet["part"]) + tables = [] + for identifier in metadata.get("table_relationship_ids", []): + relation = relationships.get(identifier) + if not relation or relation["kind"] != "table" or relation["external"]: + raise ValueError("A worksheet table relationship is unavailable.") + root = self.read_xml(relation["part"]) + low_column, low_row, high_column, high_row = bounded_range(root.get("ref")) + header_count = int(root.get("headerRowCount", "1")) + totals_count = int(root.get("totalsRowCount", "0")) + if header_count not in (0, 1) or totals_count not in (0, 1) or low_row + header_count + totals_count > high_row + 1: + raise ValueError("A named Excel table has an invalid header or totals range.") + table_columns = first_element(root, "tableColumns") + labels = [item.get("name") or get_column_letter(low_column + index) for index, item in enumerate(table_columns if table_columns is not None else [])] + if len(labels) != high_column - low_column + 1: + raise ValueError("A named Excel table has inconsistent column definitions.") + names = _unique_column_names(labels, low_column) + identity = hashlib.sha256(f"{sheet['part']}\0{relation['part']}\0{root.get('id')}".encode()).hexdigest()[:20] + tables.append({ + "id": f"table-{identity}", "name": root.get("displayName") or root.get("name") or "Named table", + "sheet": sheet["name"], "origin": "named", "part": relation["part"], + "range": root.get("ref"), "min_row": low_row, "max_row": high_row, + "min_column": low_column, "max_column": high_column, + "header_row": low_row if header_count else None, "header_row_count": header_count, + "header_status": "declared" if header_count else "absent", + "data_start_row": low_row + header_count, "data_end_row": high_row - totals_count, + "totals_row_count": totals_count, "title_rows": [], + "row_count": high_row - low_row + 1 - header_count - totals_count, + "repeated_header_rows": [], "repeated_header_count": 0, + "header_signature": None, + "columns": [ + {"id": get_column_letter(column), "name": name, "column": column} + for column, name in zip(range(low_column, high_column + 1), names) + ], + }) + return tables + + def scan_sheet(self, sheet, row_callback=None, wanted_cells=None): + sheet = self.resolve_sheet(sheet) if isinstance(sheet, str) else sheet + if sheet["part"] in self._sheet_cache and row_callback is None and not wanted_cells: + return deepcopy(self._sheet_cache[sheet["part"]]), {} + metadata = {"layout": [], "header_footer": {}, "conditional_format_rules": 0} + regions = _Regions() + wanted = set(wanted_cells or []) + saved_cells = {reference: _blank_cell(reference) for reference in wanted} + scanned_cells = 0 + for row, cells, attributes in self.iter_sheet_rows(sheet, metadata): + scanned_cells += len(cells) + regions.add(row, cells) + for cell in cells.values(): + if cell["cell"] in wanted: + saved_cells[cell["cell"]] = cell + if row_callback: + row_callback(row, cells, attributes) + if any(key in attributes for key in ("ht", "hidden", "s")) and len(metadata["layout"]) < 200: + metadata["layout"].append({"type": "row", **attributes}) + named = self._named_tables(sheet, metadata) + inferred = [ + table for table in regions.finish(sheet) + if not any( + table["min_row"] <= declared["max_row"] and table["max_row"] >= declared["min_row"] + and table["min_column"] <= declared["max_column"] and table["max_column"] >= declared["min_column"] + for declared in named + ) + ] + tables = sorted(named + inferred, key=lambda item: (item["min_row"], item["min_column"], item["id"])) + if len(tables) > EXCEL_MAX_TABLES: + raise ValueError("Workbook table inventory exceeds its supported count.") + result = {**sheet, **metadata, "tables": tables, "scanned_cells": scanned_cells} + self._sheet_cache[sheet["part"]] = result + return deepcopy(result), saved_cells + + def build_manifest(self): + cache_key = None + if self._manifest is None and isinstance(self.source, (bytes, bytearray)): + cache_key = (hashlib.sha256(self.source).hexdigest(), self.extension, EXCEL_WORKBOOK_SCHEMA_VERSION) + with _MANIFEST_LOCK: + cached = _MANIFEST_CACHE.get(cache_key) + if cached is not None: + _MANIFEST_CACHE.move_to_end(cache_key) + self._manifest = deepcopy(cached[0]) + if self._manifest is None: + sheets = [self.scan_sheet(sheet)[0] for sheet in self.sheets] + self._manifest = { + "schema_version": EXCEL_WORKBOOK_SCHEMA_VERSION, + "format": self.extension.lstrip("."), "sheet_count": len(sheets), + "table_count": sum(len(sheet["tables"]) for sheet in sheets), + "coverage": "complete" if not self.coverage_notes else "partial", + "coverage_notes": list(self.coverage_notes), + "sheets": sheets, + } + if cache_key is not None: + self._manifest["source_sha256"] = cache_key[0] + size = len(json.dumps(self._manifest, ensure_ascii=True).encode("utf-8")) + if size <= _MANIFEST_CACHE_MAX_BYTES: + with _MANIFEST_LOCK: + while _MANIFEST_CACHE and ( + len(_MANIFEST_CACHE) >= 16 + or sum(item[1] for item in _MANIFEST_CACHE.values()) + size > _MANIFEST_CACHE_MAX_BYTES + ): + _MANIFEST_CACHE.popitem(last=False) + _MANIFEST_CACHE[cache_key] = deepcopy(self._manifest), size + return deepcopy(self._manifest) + + def use_manifest(self, manifest): + """Reuse only a structural scan bound to these exact source bytes.""" + if not isinstance(self.source, (bytes, bytearray)): + raise TypeError("Reusable workbook manifests require immutable source bytes.") + expected = hashlib.sha256(self.source).hexdigest() + if ( + not isinstance(manifest, dict) + or manifest.get("schema_version") != EXCEL_WORKBOOK_SCHEMA_VERSION + or manifest.get("source_sha256") != expected + or [(item.get("name"), item.get("part")) for item in manifest.get("sheets") or []] + != [(item["name"], item["part"]) for item in self.sheets] + ): + raise ValueError("The workbook manifest belongs to a different source.") + self._manifest = deepcopy(manifest) + + def resolve_table(self, table_id=None, sheet_name=None): + manifest = self.build_manifest() + sheets = [self.resolve_sheet(sheet_name)["name"]] if sheet_name else self.sheet_names + tables = [table for sheet in manifest["sheets"] if sheet["name"] in sheets for table in sheet["tables"]] + if table_id: + matches = [table for table in tables if table["id"] == table_id or table["name"] == table_id] + if len(matches) != 1: + raise ValueError("The requested table was not found or is ambiguous.") + return matches[0] + if len(tables) != 1: + raise ValueError("The worksheet has multiple tables or no data table; select a table.") + return tables[0] + + def select_table(self, table_id=None, sheet_name=None, cell_range=None, header_row=None): + """Resolve a declared/inferred table or an explicitly requested analytical range.""" + if header_row is not None: + if isinstance(header_row, bool) or not str(header_row).isascii() or not str(header_row).isdigit(): + raise ValueError("header_row must be an actual worksheet row number or zero.") + header_row = int(header_row) + if cell_range: + if not sheet_name: + if len(self.sheets) != 1: + raise ValueError("Select a worksheet for an explicit table range.") + sheet_name = self.sheets[0]["name"] + low_column, low_row, high_column, high_row = bounded_range(cell_range) + table = { + "id": "range-" + hashlib.sha256(f"{sheet_name}\0{cell_range}".encode()).hexdigest()[:20], + "name": f"Selected range {cell_range}", "sheet": self.resolve_sheet(sheet_name)["name"], + "origin": "range", "range": cell_range, "min_row": low_row, "max_row": high_row, + "min_column": low_column, "max_column": high_column, + "header_row": None, "header_row_count": 0, "header_status": "absent", + "title_rows": [], "totals_row_count": 0, "data_start_row": low_row, + "data_end_row": high_row, "row_count": high_row - low_row + 1, + "repeated_header_rows": [], "repeated_header_count": 0, "header_signature": None, + "columns": [ + {"id": get_column_letter(column), "name": get_column_letter(column), "column": column} + for column in range(low_column, high_column + 1) + ], + } + if header_row is None: + raise ValueError("Specify header_row for an explicit range; zero means no header.") + else: + table = deepcopy(self.resolve_table(table_id, sheet_name)) + if header_row is None: + return table + if header_row and not table["min_row"] <= header_row <= table["max_row"]: + raise ValueError("The selected header row is outside the table range.") + low_column, high_column = table["min_column"], table["max_column"] + labels = [get_column_letter(column) for column in range(low_column, high_column + 1)] + if header_row: + references = [f"{get_column_letter(column)}{header_row}" for column in range(low_column, high_column + 1)] + cells = self.read_cells(table["sheet"], references) + labels = [ + str(cells[reference]["value"]) if cells[reference]["value"] not in (None, "") else label + for reference, label in zip(references, labels) + ] + names = _unique_column_names(labels, low_column) + table.update({ + "header_row": header_row or None, "header_row_count": int(bool(header_row)), + "header_status": "explicit", "title_rows": [], + "data_start_row": header_row + 1 if header_row else table["min_row"], + "header_signature": labels if header_row else None, + "columns": [ + {"id": get_column_letter(column), "name": name, "column": column} + for column, name in zip(range(low_column, high_column + 1), names) + ], + }) + table["row_count"] = sum(1 for _ in self.iter_table_rows(table)) + return table + + def iter_table_rows(self, table): + sheet = self.resolve_sheet(table["sheet"]) + header = tuple(table["header_signature"]) if table.get("header_signature") is not None else None + low, high = table["min_column"], table["max_column"] + next_row = table["data_start_row"] + for row, cells, _ in self.iter_sheet_rows(sheet): + if row < table["data_start_row"]: + continue + if row > table["data_end_row"]: + break + if table["origin"] in ("named", "range"): + while next_row < row: + yield next_row, [_blank_cell(f"{get_column_letter(column)}{next_row}") for column in range(low, high + 1)] + next_row += 1 + values = [cells.get(column) or _blank_cell(f"{get_column_letter(column)}{row}") for column in range(low, high + 1)] + next_row = row + 1 + if table["origin"] == "inferred": + if not any(cell["value_status"] != "blank" for cell in values): + continue + if header is not None and tuple(cell["value"] for cell in values) == header: + continue + yield row, values + if table["origin"] in ("named", "range"): + while next_row <= table["data_end_row"]: + yield next_row, [_blank_cell(f"{get_column_letter(column)}{next_row}") for column in range(low, high + 1)] + next_row += 1 + + def read_table_page(self, table_id=None, sheet_name=None, start_row=0, max_rows=200, *, cell_range=None, header_row=None): + if type(start_row) is not int or start_row < 0: + raise ValueError("start_row must be a nonnegative integer.") + if type(max_rows) is not int or not 1 <= max_rows <= EXCEL_MAX_PREVIEW_ROWS: + raise ValueError("max_rows must be between 1 and 500.") + table = self.select_table(table_id, sheet_name, cell_range, header_row) + rows, row_numbers, text_truncated = [], [], False + size = 0 + for ordinal, (row, cells) in enumerate(self.iter_table_rows(table)): + if ordinal < start_row: + continue + if len(rows) >= max_rows: + break + values = [] + for cell in cells[:EXCEL_PREVIEW_MAX_COLUMNS]: + value = cell["value"] + if isinstance(value, str) and len(value) > 4000: + value = value[:4000] + " [preview shortened]" + text_truncated = True + values.append(value) + row_size = len(json.dumps(values, ensure_ascii=True, allow_nan=False).encode("utf-8")) + if rows and size + row_size > EXCEL_PREVIEW_MAX_BYTES: + break + if row_size > EXCEL_PREVIEW_MAX_BYTES: + raise ValueError("A worksheet row exceeds the supported preview byte budget; select a smaller range.") + size += row_size + rows.append(values) + row_numbers.append(row) + has_more = start_row + len(rows) < table["row_count"] + return { + "selected_sheet": table["sheet"], "sheet_names": self.sheet_names, + "sheet_count": len(self.sheets), "table_id": table["id"], "table_name": table["name"], + "table_range": table["range"], "header_row": table["header_row"], + "header_status": table["header_status"], "columns": [column["name"] for column in table["columns"][:EXCEL_PREVIEW_MAX_COLUMNS]], + "rows": rows, "row_numbers": row_numbers, "total_rows": table["row_count"], + "total_columns": len(table["columns"]), "start_row": start_row, "has_more": has_more, + "truncated": has_more, "next_start_row": start_row + len(rows) if has_more else None, + "columns_truncated": len(table["columns"]) > EXCEL_PREVIEW_MAX_COLUMNS, + "cell_text_truncated": text_truncated, + } + + def read_table_previews(self, tables, max_rows=3): + """Gather small previews of many tables in one sequential pass per sheet.""" + if type(max_rows) is not int or not 1 <= max_rows <= 20: + raise ValueError("The schema preview row limit is invalid.") + results = {table["id"]: [] for table in tables} + for sheet_name in dict.fromkeys(table["sheet"] for table in tables): + selected = [table for table in tables if table["sheet"] == sheet_name] + remaining = {table["id"] for table in selected if table["row_count"] > 0} + for row, cells, _ in self.iter_sheet_rows(self.resolve_sheet(sheet_name)): + for table in selected: + records = results[table["id"]] + if table["id"] not in remaining or not table["data_start_row"] <= row <= table["data_end_row"]: + continue + if table["origin"] in ("named", "range"): + next_row = table["data_start_row"] + len(records) + while next_row < row and len(records) < min(max_rows, table["row_count"]): + records.append({"row": next_row, "values": [None] * len(table["columns"])}) + next_row += 1 + values = [ + (cells.get(column) or {}).get("value") + for column in range(table["min_column"], table["max_column"] + 1) + ] + if table["origin"] == "inferred": + if all(value in (None, "") for value in values): + continue + if table.get("header_signature") is not None and values == table["header_signature"]: + continue + if len(records) < min(max_rows, table["row_count"]): + records.append({"row": row, "values": values}) + if len(records) >= min(max_rows, table["row_count"]): + remaining.discard(table["id"]) + if not remaining: + break + for table in selected: + if table["origin"] not in ("named", "range"): + continue + records = results[table["id"]] + while len(records) < min(max_rows, table["row_count"]): + records.append({ + "row": table["data_start_row"] + len(records), + "values": [None] * len(table["columns"]), + }) + return results + + def read_cells(self, sheet_name, references): + wanted = {str(reference).replace("$", "").upper() for reference in references} + if len(wanted) > 2000: + raise ValueError("A cell inspection request exceeds its supported page size.") + positions = {reference: cell_coordinates(reference)[0] for reference in wanted} + result = {reference: _blank_cell(reference) for reference in wanted} + if not wanted: + return result + for row, cells, _ in self.iter_sheet_rows(self.resolve_sheet(sheet_name)): + if row > max(positions.values()): + break + for cell in cells.values(): + if cell["cell"] in wanted: + result[cell["cell"]] = cell + return result + + +class _XmlEvents: + def __init__(self, reader, part, limit): + self.reader = reader + self.part = part + self.limit = limit + self.stream = None + + def __enter__(self): + info = self.reader.archive.getinfo(self.part) + if info.compress_type not in OFFICE_ZIP_ALLOWED_COMPRESSION or info.file_size > self.limit: + raise ValueError("Workbook XML exceeds its supported byte/compression policy.") + self.stream = self.reader.archive.open(self.part) + return iterparse( + _BoundedXmlStream(self.stream, self.reader, self.limit), + events=("start", "end"), forbid_dtd=True, forbid_entities=True, forbid_external=True, + ) + + def __exit__(self, exc_type, exc_value, traceback): + if self.stream is not None: + self.stream.close() + + +def build_excel_table_preview( + source_bytes, extension, *, sheet_name=None, sheet_index=None, table_id=None, + start_row=0, max_rows=200, cell_range=None, header_row=None, +): + """Choose a visible preview explicitly; analytical reads never default among tables.""" + with ExcelWorkbookReader(source_bytes, extension=extension) as reader: + manifest = reader.build_manifest() + names = reader.sheet_names + if not names: + raise ValueError("The workbook has no readable worksheets.") + if sheet_name: + selected = reader.resolve_sheet(sheet_name)["name"] + elif sheet_index is not None: + if isinstance(sheet_index, bool) or not str(sheet_index).isdigit() or int(sheet_index) >= len(names): + raise ValueError("The worksheet index is invalid.") + selected = names[int(sheet_index)] + else: + selected = names[0] + sheet = next(item for item in manifest["sheets"] if item["name"] == selected) + tables = sheet["tables"] + options = [ + {key: table[key] for key in ("id", "name", "range", "origin", "header_row", "header_status", "row_count")} + for table in tables + ] + if not tables and not cell_range: + if table_id: + raise ValueError("The requested table was not found.") + return { + "selected_sheet": selected, "sheet_names": names, "sheet_count": len(names), + "tables": [], "table_count": 0, "rows": [], "columns": [], "row_numbers": [], + "total_rows": 0, "total_columns": 0, "start_row": 0, "has_more": False, + "truncated": False, "next_start_row": None, + } + selected_table = table_id or (tables[0]["id"] if tables and not cell_range else None) + page = reader.read_table_page( + table_id=selected_table, sheet_name=selected, start_row=start_row, max_rows=max_rows, + cell_range=cell_range, header_row=header_row, + ) + return {**page, "tables": options, "table_count": len(tables), "coverage": manifest["coverage"]} diff --git a/application/single_app/functions_accessibility.py b/application/single_app/functions_accessibility.py index 8b5389205..5653fb2a9 100644 --- a/application/single_app/functions_accessibility.py +++ b/application/single_app/functions_accessibility.py @@ -30,7 +30,11 @@ from pypdf import PdfReader from functions_appinsights import log_event -from functions_excel_accessibility import extract_excel_accessibility_metadata +from functions_excel_accessibility import ( + extract_excel_accessibility_metadata, + format_excel_comment_for_chat, + normalize_excel_comments, +) from functions_document_style import ( build_legacy_doc_style_inventory, build_pptx_style_inventory, @@ -2191,11 +2195,11 @@ def _legacy_doc_style(): return cosmos_meta, formatting_events -def extract_office_accessibility_metadata(file_path, file_ext=None): +def extract_office_accessibility_metadata(file_path, file_ext=None, *, record_sink=None): """Dispatch native accessibility extraction for supported Word, PowerPoint and Excel files.""" ext = (file_ext or os.path.splitext(str(file_path or ''))[1]).lower().strip() if ext in ('.xlsx', '.xlsm', '.xls'): - return extract_excel_accessibility_metadata(file_path, ext) + return extract_excel_accessibility_metadata(file_path, ext, record_sink=record_sink) try: if ext in ('.docx', '.docm', '.dotx'): return _extract_word_ooxml_accessibility(file_path, ext) @@ -2266,10 +2270,26 @@ def format_accessibility_metadata_for_chat(accessibility_metadata): if fmt in ('XLSX', 'XLSM', 'XLS'): lines.append(f"- Saved workbook properties: {accessibility_metadata.get('properties') or {}}") + comments, normalized_counts = normalize_excel_comments(accessibility_metadata.get('comments') or []) + counts = accessibility_metadata.get('comment_summary') or normalized_counts lines.append( f"- Sheets: {accessibility_metadata.get('sheet_count', 'unknown')}; " f"observed native records: {accessibility_metadata.get('observed_counts') or {}}" ) + lines.append(f"- Canonical comment counts (compatibility copies are not extra notes): {counts}") + if comments: + lines.append("- Reviewer feedback is distinct from the workbook's saved data and must not overwrite it.") + lines.extend(format_excel_comment_for_chat(record) for record in comments) + inventory = accessibility_metadata.get('inventory_coverage') or {} + if inventory.get('comments', {}).get('complete') is False: + lines.append("- The parent comment inventory is a preview; retrieve the paged native inventory for all records/full text.") + for table in accessibility_metadata.get('tables') or []: + lines.append( + f"- Table {table.get('name')} on {table.get('sheet')}: " + f"range={table.get('range')}; header_row={table.get('header_row')}; " + f"header_status={table.get('header_status')}; data_rows={table.get('row_count')}; " + f"table_id={table.get('id')}" + ) for sheet in (accessibility_metadata.get('sheets') or [])[:10]: lines.append( f"- Sheet {sheet.get('name')}: state={sheet.get('state')}; " @@ -2278,7 +2298,7 @@ def format_accessibility_metadata_for_chat(accessibility_metadata): lines.append(f"- Inspection coverage: {accessibility_metadata.get('coverage', 'unknown')}") lines.extend(f" * {note}" for note in accessibility_metadata.get('coverage_notes', [])) lines.extend(format_style_inventory_for_chat(accessibility_metadata.get('style_inventory'))) - lines.append("- Location-specific comments, objects and formatting are indexed as Excel native inspection evidence.") + lines.append("- Further location-specific comments, objects and formatting are available as Excel native inspection evidence.") lines.append("- Native inspection is not an accessibility conformance result; unavailable evidence is not proof of absence.") return '\n'.join(lines) diff --git a/application/single_app/functions_agent_document_citations.py b/application/single_app/functions_agent_document_citations.py index d00cae378..514494419 100644 --- a/application/single_app/functions_agent_document_citations.py +++ b/application/single_app/functions_agent_document_citations.py @@ -270,6 +270,7 @@ def _build_citation_from_document_payload( document_id=document_id, citation_id=citation_id, page_number=_resolve_location_number(citation_chunk.get('page_number'), chunk_sequence), + chunk_text=citation_chunk.get('chunk_text'), chunk_id=citation_chunk.get('chunk_id'), chunk_sequence=chunk_sequence, group_id=document_item.get('group_id'), diff --git a/application/single_app/functions_document_citations.py b/application/single_app/functions_document_citations.py index 8217d457f..7f82d12e8 100644 --- a/application/single_app/functions_document_citations.py +++ b/application/single_app/functions_document_citations.py @@ -36,6 +36,8 @@ def resolve_citation_location( if sheet_name not in (None, ''): return 'Sheet', str(sheet_name) normalized_chunk_text = str(chunk_text or '').strip() + if is_tabular and normalized_chunk_text.startswith('### Excel native inspection'): + return 'Location', f"Native evidence segment {page_number}" if page_number not in (None, '') else 'Workbook native inspection' if is_tabular and ( normalized_chunk_text.startswith('Tabular workbook:') or normalized_chunk_text.startswith('Tabular data file:') diff --git a/application/single_app/functions_documents.py b/application/single_app/functions_documents.py index d7ef08815..914c87e34 100644 --- a/application/single_app/functions_documents.py +++ b/application/single_app/functions_documents.py @@ -39,6 +39,7 @@ current_extraction, is_publication, ) +from content_screening.storage import ScreeningStorage from content_screening.service import ( document_requires_screening, initial_document_marker, @@ -122,6 +123,12 @@ format_pptx_comment_block, ) from functions_excel_accessibility import build_excel_evidence_chunks +from excel_workbook_reader import ExcelWorkbookReader +from functions_excel_inventory import ( + EXCEL_INVENTORY_FIELD, + clear_excel_inventory_cache, + persist_excel_inventory, +) from functions_document_transform_sources import ( OFFICE_REFERENCE_MIME_TYPES, TEMPLATE_EXTENSIONS, @@ -683,6 +690,7 @@ def _build_office_embedded_image_chunks( file_path, settings, update_callback, + native_media_metadata=None, ): """Analyze images embedded in an Office file and return placeable content blocks. @@ -717,11 +725,13 @@ def _build_office_embedded_image_chunks( try: temp_image_dir = tempfile.mkdtemp(prefix='office_images_') + extra_arguments = {"native_media_metadata": native_media_metadata} if native_media_metadata is not None else {} embedded_images, image_diagnostics = extract_office_embedded_images_with_diagnostics( file_path, temp_image_dir, min_pixels=min_pixels, max_images=max_images, + **extra_arguments, ) candidate_count = image_diagnostics.get('candidates', 0) @@ -819,6 +829,10 @@ def _build_office_embedded_image_chunks( slide_number = embedded_image.get('slide_number') if slide_number: location_label = f" on slide {slide_number}" + elif embedded_image.get('sheet_name'): + location_label = f" on worksheet {embedded_image['sheet_name']}" + if embedded_image.get('cell'): + location_label += f" at {embedded_image['cell']}" heading = ( f"### Embedded image {image_index} of {total_images}: " @@ -830,6 +844,11 @@ def _build_office_embedded_image_chunks( 'word_offset': embedded_image.get('word_offset'), 'position_known': bool(embedded_image.get('position_known')), 'name': embedded_image.get('name'), + **({ + 'sheet_name': embedded_image.get('sheet_name'), 'cell': embedded_image.get('cell'), + 'object_id': embedded_image.get('object_id'), 'media_part': embedded_image.get('media_part'), + 'placements': embedded_image.get('placements') or [], + } if native_media_metadata is not None else {}), }) analyzed_count += 1 @@ -5940,7 +5959,7 @@ def get_document_record(user_id, document_id, group_id=None, public_workspace_id return _normalize_document_enhanced_citations(document_item) -def get_ordered_document_chunks(document_id, user_id, group_id=None, public_workspace_id=None, max_chunks=None): +def get_ordered_document_chunks(document_id, user_id, group_id=None, public_workspace_id=None, max_chunks=None, *, native_only=False): """Return ordered chunk records for a document after access has been verified.""" document_item = get_document_record( user_id=user_id, @@ -5977,18 +5996,24 @@ def get_ordered_document_chunks(document_id, user_id, group_id=None, public_work 'title', 'chunk_summary', ] + escaped_document_id = str(document_id).replace("'", "''") search_kwargs = { 'search_text': '*', - 'filter': f"document_id eq '{document_id}'", + 'filter': f"document_id eq '{escaped_document_id}'", 'select': ','.join(select_fields), } if max_chunks is not None: search_kwargs['top'] = max(1, int(max_chunks)) + if native_only: + search_kwargs.update(search_text='"Excel native inspection"', search_fields=['chunk_text']) try: results = list(search_client.search(**search_kwargs)) - except Exception as e: - print(f"Error retrieving chunks for document {document_id}: {e}") + except Exception as error: + log_event( + "[DOCUMENT_METADATA] Document evidence retrieval failed.", + level=logging.WARNING, extra={"document_id": document_id, "error_type": type(error).__name__}, + ) raise ordered_chunks = [] @@ -6023,7 +6048,7 @@ def get_ordered_document_chunks(document_id, user_id, group_id=None, public_work ) return assert_document_chunks_available( ordered_chunks, document_item, user_id, group_id, public_workspace_id, - expected_chunk_count=document_item.get("num_chunks") if max_chunks is None else None, + expected_chunk_count=document_item.get("num_chunks") if max_chunks is None and not native_only else None, ) def get_documents(user_id, group_id=None, public_workspace_id=None): @@ -6359,8 +6384,12 @@ def delete_document( raise PermissionError("Document access denied.") if strict and (not expected_etag or document_item.get("_etag") != expected_etag): raise ScreeningConflictError() - if SCREENING_FIELD in document_item: + if ( + SCREENING_FIELD in document_item or EXCEL_INVENTORY_FIELD in document_item + or str(document_item.get("file_name") or "").lower().endswith((".xlsx", ".xlsm", ".xls")) + ): prepare_document_deletion(document_item, user_id) + clear_excel_inventory_cache(subject_from_document(document_item)) document_item = cosmos_container.read_item(item=document_id, partition_key=document_id) # Log document deletion transaction before deletion @@ -10509,40 +10538,39 @@ def _build_tabular_schema_summary(temp_file_path, original_filename, file_ext): ) if file_ext in ('.xlsx', '.xls', '.xlsm'): - engine = 'openpyxl' if file_ext in ('.xlsx', '.xlsm') else 'xlrd' - excel_file = pandas.ExcelFile(temp_file_path, engine=engine) - visible_sheet_names = excel_file.sheet_names[:TABULAR_SCHEMA_SUMMARY_MAX_SHEETS] - omitted_sheet_count = max(len(excel_file.sheet_names) - TABULAR_SCHEMA_SUMMARY_MAX_SHEETS, 0) - workbook_sections = [] - - for sheet_name in visible_sheet_names: - df_preview = excel_file.parse( - sheet_name, - keep_default_na=False, - dtype=str, - nrows=TABULAR_SCHEMA_SUMMARY_MAX_PREVIEW_ROWS, - ) - compact_columns = _compact_tabular_columns(df_preview.columns.tolist()) - preview_rows = _build_compact_tabular_preview(df_preview) - workbook_sections.append( - f"Sheet: {_compact_tabular_schema_value(sheet_name, max_chars=80)}\n" - f"Columns ({len(df_preview.columns)}): {', '.join(compact_columns) if compact_columns else 'None'}\n" - f"Preview (first {min(len(df_preview), TABULAR_SCHEMA_SUMMARY_MAX_PREVIEW_ROWS)} rows):\n{preview_rows}" - ) - - sheet_summary = ", ".join( - _compact_tabular_schema_value(sheet_name, max_chars=80) - for sheet_name in visible_sheet_names - ) - if omitted_sheet_count: - sheet_summary += f", ... +{omitted_sheet_count} more sheets" - - return ( - f"Tabular workbook: {original_filename}\n" - f"Sheets ({len(excel_file.sheet_names)}): {sheet_summary if sheet_summary else 'None'}\n\n" - + "\n\n".join(workbook_sections) - + f"\n\n{plugin_note}" - ) + with ExcelWorkbookReader(temp_file_path, extension=file_ext) as reader: + manifest = reader.build_manifest() + sheets = manifest["sheets"][:TABULAR_SCHEMA_SUMMARY_MAX_SHEETS] + tables = [table for sheet in sheets for table in sheet["tables"]][:20] + previews = reader.read_table_previews(tables, TABULAR_SCHEMA_SUMMARY_MAX_PREVIEW_ROWS) + workbook_sections = [] + for table in tables: + columns = [column["name"] for column in table["columns"]] + df_preview = pandas.DataFrame( + [record["values"] for record in previews[table["id"]]], columns=columns, + ) + compact_columns = _compact_tabular_columns(columns) + preview_rows = _build_compact_tabular_preview(df_preview) + workbook_sections.append( + f"Sheet: {_compact_tabular_schema_value(table['sheet'], max_chars=80)}\n" + f"Table: {_compact_tabular_schema_value(table['name'], max_chars=100)}; " + f"table_id={table['id']}; range={table['range']}; " + f"header_row={table['header_row']}; header_status={table['header_status']}\n" + f"Columns ({len(columns)}): {', '.join(compact_columns) if compact_columns else 'None'}\n" + f"Preview (first {len(df_preview)} data rows; not the complete dataset):\n{preview_rows}" + ) + sheet_summary = ", ".join( + _compact_tabular_schema_value(sheet["name"], max_chars=80) for sheet in sheets + ) + omitted = manifest["table_count"] - len(tables) + return ( + f"Tabular workbook: {original_filename}\n" + f"Sheets ({manifest['sheet_count']}): {sheet_summary or 'None'}\n" + f"Tables ({manifest['table_count']}): independent table/range headers; never assume one header per sheet.\n\n" + + "\n\n".join(workbook_sections) + + (f"\n\nAdditional tables not shown in this bounded schema preview: {omitted}." if omitted else "") + + f"\n\n{plugin_note}" + ) raise ValueError(f"Unsupported tabular file type: {file_ext}") @@ -10629,6 +10657,75 @@ def process_single_tabular_sheet(df, document_id, user_id, file_name, update_cal return total_chunks_saved, total_embedding_tokens, embedding_model_name +def _enrich_excel_image_inventory(file_path, settings, update_callback, metadata, evidence, record_sink): + if not settings.get("enable_office_embedded_image_analysis", True): + metadata["image_analysis_summary"] = {"status": "disabled", "analyzed": 0} + return + blocks, count, engine, _ = _build_office_embedded_image_chunks( + file_path, settings, update_callback, native_media_metadata=metadata.get("image_locations") or {}, + ) + metadata["image_analysis_summary"] = { + "status": "generated" if count else "none_analyzed", "analyzed": count, "engine": engine, + "limitation": "Missing analysis is not proof of absent images; configured size/format/count limits still apply.", + } + remaining = max(0, 1000000 - sum(len(item["content"]) for item in evidence)) + for block in blocks: + record = { + "type": "image_analysis", "sheet": block.get("sheet_name") or "(workbook)", + "cell": block.get("cell"), "object_id": block.get("object_id"), + "media_part": block.get("media_part"), "placements": block.get("placements") or [], + "text": block["content"], "analysis_engine": engine, + "source_kind": "configured_image_analysis_not_saved_alt_text", + } + record_sink("image_analyses", record) + content = f"### Excel native inspection\n{block['content']}" + if len(content) <= remaining: + evidence.append({ + "content": content, "sheet_name": record["sheet"], "kind": "image_analyses", + "location": record.get("cell") or record.get("object_id") or "", + }) + remaining -= len(content) + else: + metadata["coverage_notes"].append("Image-analysis search previews reached their budget; complete generated records remain in the native inventory.") + + +def _extract_excel_native_inventory(document_id, user_id, temp_file_path, file_ext, group_id=None, public_workspace_id=None, update_callback=None): + """Keep full native records in revision-private storage, not the parent preview.""" + capture = current_extraction(document_id) + settings = get_settings() + + def enrich(metadata, evidence, sink): + _enrich_excel_image_inventory(temp_file_path, settings, update_callback, metadata, evidence, sink) + + if capture is not None: + if capture.artifact_storage is None: + raise ScreeningError(code="screening_configuration_required") + return persist_excel_inventory( + temp_file_path, file_ext, subject=capture.subject, + storage=capture.artifact_storage, capture=capture, + enrich=enrich, + ) + document = get_document_record( + user_id, document_id, group_id=group_id, public_workspace_id=public_workspace_id, + ) + if document is None: + raise LookupError("Document not found or access denied.") + client = CLIENTS.get("storage_account_office_docs_client") + if client is None: + metadata, evidence = extract_office_accessibility_metadata(temp_file_path, file_ext) + metadata["inventory_storage"] = {"status": "unavailable", "reason": "native_storage_not_configured"} + log_event( + "[DOCUMENT_METADATA] Full Excel inventory storage is not configured.", + level=logging.WARNING, extra={"document_id": document_id}, + ) + return metadata, evidence, None + return persist_excel_inventory( + temp_file_path, file_ext, subject=subject_from_document(document), + storage=ScreeningStorage(client=client, container_name=storage_account_content_screening_container_name), + enrich=enrich, + ) + + def process_tabular(document_id, user_id, temp_file_path, original_filename, file_ext, enable_enhanced_citations, update_callback, group_id=None, public_workspace_id=None, auto_extract_metadata=True): """Processes CSV, XLSX, or XLS files using pandas.""" is_group = group_id is not None @@ -10641,8 +10738,14 @@ def process_tabular(document_id, user_id, temp_file_path, original_filename, fil native_chunks = [] if file_ext in ('.xlsx', '.xlsm', '.xls'): - native_metadata, native_evidence = extract_office_accessibility_metadata(temp_file_path, file_ext) + native_metadata, native_evidence, inventory_reference = _extract_excel_native_inventory( + document_id, user_id, temp_file_path, file_ext, + group_id=group_id, public_workspace_id=public_workspace_id, + update_callback=update_callback, + ) native_fields = {'accessibility_metadata': native_metadata} + if inventory_reference is not None: + native_fields[EXCEL_INVENTORY_FIELD] = inventory_reference for field in ('title', 'authors', 'keywords', 'language'): if native_metadata.get(field): native_fields[field] = native_metadata[field] diff --git a/application/single_app/functions_excel_accessibility.py b/application/single_app/functions_excel_accessibility.py index cb7f9a6f4..05b55b5a3 100644 --- a/application/single_app/functions_excel_accessibility.py +++ b/application/single_app/functions_excel_accessibility.py @@ -19,8 +19,13 @@ from openpyxl.styles.numbers import BUILTIN_FORMATS from openpyxl.utils.cell import get_column_letter +from excel_workbook_reader import ( + EXCEL_WORKBOOK_SCHEMA_VERSION, + ExcelWorkbookReader, + cell_coordinates, +) from functions_appinsights import log_event -from functions_document_style import StyleAccumulator +from functions_document_style import StyleAccumulator, format_style_inventory_for_chat from functions_office_media import OFFICE_ZIP_MAX_ENTRIES, _read_zip_entry_bounded @@ -64,12 +69,20 @@ def _on(value): class _Inspection: - def __init__(self, extension): + def __init__(self, extension, record_sink=None, progress_callback=None): self.meta = { - "format": extension.lstrip("."), "schema_version": "1.0", + "format": extension.lstrip("."), "schema_version": EXCEL_WORKBOOK_SCHEMA_VERSION, "coverage": "partial", "coverage_notes": list(EXCEL_COVERAGE_NOTES), "properties": {}, "sheets": [], "comments": [], "objects": [], "issues": [], + "tables": [], "defined_names": [], "hyperlinks": [], "validations": [], + "property_records": [], "custom_properties": [], "extended_properties": [], + "comment_summary": { + "legacy_notes": 0, "thread_roots": 0, "replies": 0, + "thread_messages": 0, "compatibility_copies": 0, "raw_records": 0, + }, } + self.record_sink = record_sink + self.progress_callback = progress_callback self.evidence = [] self.evidence_chars = 0 self.bytes_read = 0 @@ -77,6 +90,8 @@ def __init__(self, extension): self.cells = 0 self.cache = {} self.parent_record_bytes = 0 + self.image_placement_count = 0 + self.image_map_bytes = 0 self.styles = StyleAccumulator("sheet_cell") self.counts = Counter() @@ -88,7 +103,7 @@ def note(self, message): inventory["coverage_notes"].append(message) def clean(self, value): - text = str(value or "") + text = str(value) if value is not None else "" if len(text) > EXCEL_MAX_TEXT: self.note("Long native strings were truncated to the per-field limit.") return text[:EXCEL_MAX_TEXT] + " [truncated]" @@ -148,18 +163,62 @@ def emit(self, sheet, kind, value): def record(self, collection, sheet, record): self.counts[collection] += 1 + record = {"sheet": sheet, **record} + if collection == "objects" and record.get("media_part"): + if self.image_placement_count < 100: + images = self.meta.setdefault("image_locations", {}) + existing = images.get(record["media_part"]) + image = dict(existing) if existing else { + "alt_text": str(record.get("alt_text") or "")[:1000], + "title_text": str(record.get("title") or "")[:1000], + "is_decorative": record.get("is_decorative"), "sheet_name": sheet, + "cell": record.get("cell"), "object_id": record.get("id"), "placements": [], + } + image["placements"] = list(image["placements"]) + [{ + "sheet_name": sheet, "cell": record.get("cell"), "object_id": record.get("id"), + }] + size = len(json.dumps(image, ensure_ascii=True).encode()) + previous = len(json.dumps(existing, ensure_ascii=True).encode()) if existing else 0 + if self.image_map_bytes + size - previous <= 65536: + images[record["media_part"]] = image + self.image_map_bytes += size - previous + self.image_placement_count += 1 + else: + self.note("The embedded-image placement preview reached its byte limit; full native object records are separate.") + else: + self.note("The embedded-image analysis placement map is limited to 100 anchors; the full object inventory is separate.") + if self.record_sink is not None: + self.record_sink(collection, record) + self.emit(sheet, collection, record) if self.records >= EXCEL_MAX_RECORDS: - self.note("Native comment/object records were truncated at the record limit.") + self.note("Parent native records were truncated at the record limit; full inventory requires its paged source.") return self.records += 1 - record = {"sheet": sheet, **record} - record_bytes = len(json.dumps(record, ensure_ascii=True).encode("utf-8")) + preview = self.preview(record) + record_bytes = len(json.dumps(preview, ensure_ascii=True).encode("utf-8")) if self.parent_record_bytes + record_bytes <= EXCEL_MAX_PARENT_BYTES // 2: - self.meta[collection].append(record) + self.meta.setdefault(collection, []).append(preview) self.parent_record_bytes += record_bytes else: - self.note("Parent comment/object inventory was capped; location-specific search evidence is separate.") - self.emit(sheet, collection, record) + self.note("Parent native inventory was capped; location-specific search evidence and full inventory are separate.") + + def preview(self, value): + if isinstance(value, dict): + result = {key: self.preview(item) for key, item in value.items()} + for key, item in value.items(): + if ( + isinstance(item, str) and len(item) > EXCEL_MAX_TEXT + or isinstance(item, list) and len(item) > 100 + ): + result[f"{key}_truncated"] = True + return result + if isinstance(value, list): + if len(value) > 100: + self.note("Parent native collection previews show at most 100 entries; use the full inventory for the remainder.") + return [self.preview(item) for item in value[:100]] + if isinstance(value, str): + return self.clean(value) + return value def finish(self): self.meta["observed_counts"] = dict(self.counts) @@ -201,9 +260,15 @@ def finish(self): "coverage": "partial; unsupported control types are not accessibility failures", } # Search evidence keeps the location-specific records; Cosmos remains a bounded inventory. - while len(json.dumps(self.meta, ensure_ascii=True).encode("utf-8")) > EXCEL_MAX_PARENT_BYTES - 1024: + reserve = min(8192, EXCEL_MAX_PARENT_BYTES // 6) + while len(json.dumps(self.meta, ensure_ascii=True).encode("utf-8")) > EXCEL_MAX_PARENT_BYTES - reserve: style = self.meta["style_inventory"] - candidates = [self.meta[key] for key in ("comments", "objects", "sheets") if self.meta[key]] + candidates = [ + self.meta[key] for key in ( + "comments", "objects", "sheets", "tables", "defined_names", "hyperlinks", + "validations", "property_records", "custom_properties", "extended_properties", + ) if self.meta[key] + ] candidates.extend(style[key] for key in ("outliers", "colors") if style[key]) candidates.extend(value["sheets"] for value in (style["layout"], style["page_setup"]) if value["sheets"]) if not candidates: @@ -222,12 +287,24 @@ def finish(self): style["outliers_truncated"] = len(style["outliers"]) < style["outlier_run_count"] self.note("Parent inventory was truncated at its serialized byte limit; search evidence is separate.") + self.meta["inventory_coverage"] = { + key: { + "observed": count, "retained": len(self.meta.get(key) or []), + "complete": count == len(self.meta.get(key) or []) and not any( + any(name.endswith("_truncated") and value is True for name, value in item.items()) + for item in self.meta.get(key) or [] + ), + } + for key, count in self.counts.items() + } + def coverage_content(): return f"{EXCEL_EVIDENCE_MARKER}\nWorkbook properties and inspection coverage:\n" + json.dumps({ "properties": self.meta["properties"], "coverage": self.meta["coverage"], "coverage_notes": self.meta["coverage_notes"], "observed_counts": self.meta["observed_counts"], + "comment_summary": self.meta["comment_summary"], }, ensure_ascii=True) while self.evidence and self.evidence_chars + len(coverage_content()) > EXCEL_MAX_EVIDENCE_CHARS: @@ -242,13 +319,41 @@ def _core_properties(state, root): if root is None: return names = {"title", "creator", "subject", "keywords", "description", "language", - "category", "created", "modified", "lastModifiedBy"} + "category", "created", "modified", "lastModifiedBy", "identifier", + "version", "revision", "lastPrinted", "contentStatus"} properties = {_local(item.tag): state.clean(item.text) for item in root if _local(item.tag) in names} state.meta["properties"] = properties for key in ("title", "subject", "description", "language", "category"): state.meta[key] = properties.get(key, "") state.meta["authors"] = [part.strip() for part in re.split(r"[;,]", properties.get("creator", "")) if part.strip()] state.meta["keywords"] = [part.strip() for part in re.split(r"[;,]", properties.get("keywords", "")) if part.strip()] + for element in root: + if _local(element.tag) in names: + state.record("property_records", "(workbook)", { + "kind": "core", "name": _local(element.tag), "value": element.text or "", + }) + + +def _additional_properties(state, archive, relationships): + for kind, fallback, collection in ( + ("extended-properties", "docProps/app.xml", "extended_properties"), + ("custom-properties", "docProps/custom.xml", "custom_properties"), + ): + part = next((path for relation, path in relationships.values() if relation == kind), fallback) + root = state.xml(archive, part) + if root is None: + continue + for element in root: + name = element.get("name") or _local(element.tag) + children = list(element) + values = [ + {"type": _local(child.tag), "value": _text(child)} + for child in children + ] + state.record(collection, "(workbook)", { + "name": name, "value": values if children else element.text or "", + "property_id": element.get("pid"), + }) def _color(element, theme, state, palette=COLOR_INDEX): @@ -372,7 +477,240 @@ def _header_sections(expression): return {key: value for key, value in sections.items() if value} +def normalize_excel_comments(records): + """Correlate only identifiable same-cell compatibility copies of real threads.""" + threaded, notes = [], [] + for item in records: + if not isinstance(item, dict): + raise ValueError("A stored Excel comment record is invalid.") + record = dict(item) + (threaded if record.get("kind") == "threaded_comment" else notes).append(record) + roots = { + (record.get("sheet"), str(record["id"]).casefold()): record + for record in threaded if record.get("id") and not record.get("parent_id") + } + summary = { + "legacy_notes": 0, "thread_roots": sum(not record.get("parent_id") for record in threaded), + "replies": sum(bool(record.get("parent_id")) for record in threaded), + "thread_messages": len(threaded), "compatibility_copies": 0, + "raw_records": len(threaded) + len(notes), + } + genuine_notes = [] + for note in notes: + author = str(note.get("author") or "") + root = roots.get((note.get("sheet"), author[3:].strip().casefold())) if author.lower().startswith("tc=") else None + text = str(note.get("text") or "") + compatibility = ( + root is not None and root.get("cell") == note.get("cell") + and text.lstrip().casefold().startswith("[threaded comment]") + and bool(str(root.get("text") or "").strip()) + and str(root["text"]).strip() in text + ) + if compatibility: + summary["compatibility_copies"] += 1 + else: + genuine_notes.append(note) + summary["legacy_notes"] = len(genuine_notes) + return threaded + genuine_notes, summary + + +def format_excel_comment_for_chat(record): + """Keep feedback, saved values, and unavailable fields separate in model evidence.""" + if record.get("record_fragment"): + return ( + f"### Partial native record at {record.get('sheet')}!{record.get('cell')}\n" + "This is an explicitly continued JSON record, not a complete comment. " + "Use the supplied continuation cursor to read the remainder.\n" + f"{record.get('record_json_fragment') or ''}" + ) + location = f"{record.get('sheet', '?')}!{record.get('cell', '?')}" + kind = "thread reply" if record.get("parent_id") else "thread root" if record.get("kind") == "threaded_comment" else "legacy note" + saved = { + "value": record.get("cell_value"), "value_type": record.get("cell_value_type"), + "status": record.get("cell_value_status", "not inspected"), + "formula": record.get("formula"), "cached_value_available": record.get("cached_value_available"), + } + details = { + key: record.get(key) for key in ("author", "date", "id", "parent_id", "resolved") + } + text = ( + f"### Reviewer feedback: {kind} at {location}\n" + f"Saved cell evidence (not the requested change): {json.dumps(saved, ensure_ascii=False)}\n" + f"Saved comment fields (null means unknown): {json.dumps(details, ensure_ascii=False)}\n" + f"Reviewer feedback text:\n{record.get('text') or ''}" + ) + if record.get("text_truncated"): + text += "\n[Parent text preview is shortened; retrieve the full native inventory text.]" + return text + + +def excel_native_question_sections(question): + text = str(question or "").lower() + sections = [] + for section, expression in ( + ("comments", r"\b(comments?|notes?|reviewer|feedback|replies|threaded)\b"), + ("custom_properties", r"\bcustom propert"), + ("extended_properties", r"\b(extended propert|application propert|company|manager)\b"), + ("property_records", r"\b(propert|metadata|authors?|keywords?|document title)"), + ("tables", r"\b(tables?|columns?|schema|named ranges?)\b"), + ("objects", r"\b(objects?|charts?|images?|pictures?|alt[- ]?text|decorative|shapes?)\b"), + ("image_analyses", r"\b(images?|pictures?|figures?)\b"), + ("hyperlinks", r"\b(hyperlinks?|links?)\b"), + ("validations", r"\bvalidations?\b"), + ("defined_names", r"\b(defined names?|named ranges?|print areas?|print titles?)\b"), + ): + if re.search(expression, text): + sections.append(section) + return sections or ["comments"] + + +def build_excel_native_chat_evidence(report, question, *, max_bytes=15000): + """Include whole requested records before optional layout/style summaries.""" + metadata = report.get("accessibility_metadata") or {} + inspection = report.get("excel_inspection") or {} + page = inspection.get("page") or {} + pages = inspection.get("pages") or ([page] if page else []) + comments, counts = normalize_excel_comments(metadata.get("comments") or []) + counts = metadata.get("comment_summary") or counts + header = ( + f"{EXCEL_EVIDENCE_MARKER}\n" + f"Workbook: {(report.get('document') or {}).get('file_name') or 'Selected workbook'}\n" + f"Canonical comment counts: {json.dumps(counts, ensure_ascii=True)}\n" + f"Native coverage: {metadata.get('coverage', 'unknown')}. " + "Saved native state is not rendered appearance or a conformance certificate. " + "Reviewer feedback is not the workbook's saved data. " + "No formulas, macros, or external links were executed.\n" + ) + parts, used, included, omitted = [header], len(header.encode("utf-8")), 0, 0 + + def append(value, record=False): + nonlocal used, included, omitted + size = len(value.encode("utf-8")) + 2 + if used + size > max_bytes - 1024: + if record: + omitted += 1 + return False + parts.append(value) + used += size + included += int(record) + return True + + requested = excel_native_question_sections(question) + for section in requested: + section_page = next((item for item in pages if item.get("section") == section), {}) + records = section_page.get("records") if section_page else metadata.get(section) + if section == "comments": + records = section_page.get("records") if section_page else comments + for record in records or []: + content = format_excel_comment_for_chat(record) if section == "comments" else ( + f"### Saved native {section}\n{json.dumps(record, ensure_ascii=False)}" + ) + append(content, record=True) + for cell in inspection.get("cells") or []: + append( + f"### Saved cell {cell.get('sheet')}!{cell.get('cell')}\n{json.dumps(cell, ensure_ascii=True)}", + record=True, + ) + append(f"Saved workbook properties: {json.dumps(metadata.get('properties') or {}, ensure_ascii=True)}") + if "image_analyses" in requested: + append( + "Image-analysis coverage (not saved alt text): " + + json.dumps(metadata.get("image_analysis_summary") or { + "status": "not_generated", "guidance": "Configured image analysis may require document reprocessing; saved native object metadata is separate.", + }, ensure_ascii=True) + ) + for sheet in metadata.get("sheets") or []: + append( + f"Sheet {sheet.get('name')}: state={sheet.get('state')}; " + f"headers/footers={json.dumps(sheet.get('header_footer') or {}, ensure_ascii=True)}" + ) + for note in metadata.get("coverage_notes") or []: + append(f"Coverage limitation: {note}") + if re.search(r"\b(font|format|style|size|colou?r)", str(question or ""), re.IGNORECASE): + for line in format_style_inventory_for_chat(report.get("style_inventory") or metadata.get("style_inventory")): + append(line) + incomplete = bool(any(item.get("has_more") for item in pages) or omitted) + if incomplete: + parts.append( + f"Returned {included} complete records/fragments in this bounded handoff; " + f"{omitted} additional selected records did not fit. Do not call this an exhaustive list. " + f"Native page continuations: {json.dumps({item['section']: item.get('next_cursor') for item in pages if item.get('has_more')}, ensure_ascii=True)}." + ) + return { + "summary": "\n\n".join(parts), "returned_records": included, + "records_omitted": omitted, "partial": incomplete, + "next_cursor": page.get("next_cursor"), "total_records": page.get("total_records"), + "worksheet_data_read": bool(inspection.get("cells")) or any("cell_value_status" in record for record in comments), + } + + +def has_excel_native_inspection_intent(question, file_names=None): + """Recognize native requirements independently from a simultaneous calculation.""" + text = re.sub( + r"\b(sum|average|median|aggregate|calculate|compute)\b|\btotal\s+(sales|revenue|tax|amount|cost)", + "", str(question or ""), flags=re.IGNORECASE, + ) + return is_excel_native_inspection_question(text, file_names=file_names) + + +def merge_excel_native_evidence(result, native_result, question): + """Keep both evidence kinds within the existing per-source summary budget.""" + if not native_result: + return result + result = dict(result) + native_by_source = { + envelope["document_id"]: envelope for envelope in native_result.get("evidence_envelopes") or [] + } + reports = { + citation.get("function_arguments", {}).get("document_id"): citation.get("function_result") + for citation in native_result.get("agent_citations") or [] + if citation.get("function_name") == "get_document_accessibility_report" + } + envelopes = [] + for existing in result.get("evidence_envelopes") or []: + envelope = dict(existing) + native = native_by_source.get(envelope.get("document_id")) + if native is None: + envelopes.append(envelope) + continue + summary = str(envelope.get("summary") or "") + computed_lines, computed_size = [], 0 + for line in summary.splitlines(keepends=True): + size = len(line.encode("utf-8")) + if computed_size + size > 10000: + break + computed_lines.append(line) + computed_size += size + computed = "".join(computed_lines) + computed_shortened = computed != summary + report = reports.get(envelope["document_id"]) + if isinstance(report, dict): + evidence = build_excel_native_chat_evidence( + report, question, max_bytes=max(2500, 15000 - computed_size), + ) + native_summary = evidence["summary"] + native_partial = evidence["partial"] + else: + native_summary = str(native.get("summary") or "Native inspection was unavailable.") + native_partial = True + envelope["summary"] = ( + f"{native_summary}\n\nComputed tabular evidence:\n{computed}" + + ("\n[Computed summary is shortened; the full tool result remains available.]" if computed_shortened else "") + ) + envelope["coverage"] = { + **dict(envelope.get("coverage") or {}), + "native_inspection_included": True, "native_records_partial": native_partial, + "native_status": native.get("status"), "computed_summary_shortened": computed_shortened, + } + envelope["citations"] = list(envelope.get("citations") or []) + list(native.get("citations") or []) + envelopes.append(envelope) + result["evidence_envelopes"] = envelopes + result["agent_citations"] = list(result.get("agent_citations") or []) + list(native_result.get("agent_citations") or []) + return result + + def _comments(state, archive, sheet, relationships, persons): + threaded, notes = [], [] for kind, path in relationships.values(): if kind not in ("comments", "threadedComment", "threadedComments"): continue @@ -388,14 +726,49 @@ def _comments(state, archive, sheet, relationships, persons): else: author = persons.get(item.get("personId")) text = "".join(_text(child) for child in item if _local(child.tag) == "text") - state.record("comments", sheet, { + record = { + "sheet": sheet, "kind": "note" if name == "comment" else "threaded_comment", - "cell": state.clean(item.get("ref")), "text": state.clean(text), + "cell": state.clean(item.get("ref")), "text": text, "author": author, "date": state.clean(item.get("dT")) or None, "id": state.clean(item.get("id")) or None, "parent_id": state.clean(item.get("parentId")) or None, "resolved": _on(item.get("done")) if "done" in item.attrib else None, - }) + "source_part": path, + } + (notes if name == "comment" else threaded).append(record) + records, summary = normalize_excel_comments(threaded + notes) + for key, count in summary.items(): + state.meta["comment_summary"][key] += count + return records + + +def _chart_content(state, archive, chart_part): + root = state.xml(archive, chart_part, required=True) + series = [] + for element in root.iter(): + if _local(element.tag) != "ser": + continue + values = [] + references = [] + for item in element.iter(): + if _local(item.tag) == "f": + references.append(item.text or "") + elif _local(item.tag) == "pt": + value = _first(item, "v") + values.append({"index": item.get("idx"), "value": _text(value)}) + series.append({ + "references": references, "cached_points": values, + "cached_point_count": len(values), + }) + return { + "chart_part": chart_part, + "chart_text": "\n".join( + item.text for item in root.iter() if _local(item.tag) == "t" and item.text + ), + "series": series, + "coverage": "Saved chart text, references and caches only; chart formulas are not evaluated.", + } def _objects(state, archive, sheet, relationships): @@ -425,12 +798,16 @@ def _objects(state, archive, sheet, relationships): state.record("objects", sheet, { "type": control_type or "vml_shape", "id": state.clean(shape.get("id")), "cell": f"{get_column_letter(int(column.text) + 1)}{int(row.text) + 1}" if row is not None and column is not None else None, - "alt_text": state.clean(shape.get("alt")), "title": state.clean(_attr(shape, "title")), + "alt_text": shape.get("alt") or "", "title": _attr(shape, "title") or "", + "saved_control_properties": { + _local(item.tag): _text(item) for item in client + } if client is not None else {}, "is_decorative": None, "alt_inspected": True, }) state.note("VML decorative status is unavailable; absent marking remains unknown.") continue parents = {child: parent for parent in root.iter() for child in parent} + drawing_relationships = state.rels(archive, path) for anchor in root: start = _first(anchor, "from") row = _first(start, "row") if start is not None else None @@ -447,103 +824,110 @@ def _objects(state, archive, sheet, relationships): "chart" if owner is not None and owner_type == "graphicFrame" and _first(owner, "chart") is not None else "group" if owner_type == "grpSp" else "shape" ) - state.record("objects", sheet, { + record = { "type": object_type, "id": state.clean(properties.get("id")), "name": state.clean(properties.get("name")), "cell": cell, - "alt_text": state.clean(properties.get("descr")), "title": state.clean(properties.get("title")), + "alt_text": properties.get("descr") or "", "title": properties.get("title") or "", "is_decorative": _on(decorative.get("val")) if decorative is not None else None, "alt_inspected": True, - }) + "text": "\n".join( + item.text for item in owner.iter() + if _local(item.tag) == "t" and item.text + ) if owner is not None else "", + "drawing_part": path, + } + chart = _first(owner, "chart") if owner is not None else None + if chart is not None: + relationship = drawing_relationships.get(_attr(chart, "id")) + if relationship and relationship[0] == "chart": + record.update(_chart_content(state, archive, relationship[1])) + else: + record["chart_coverage"] = "The saved chart part was unavailable." + state.note("A drawing referenced a chart without an available internal chart relationship.") + image = _first(owner, "blip") if owner is not None else None + if image is not None: + relationship = drawing_relationships.get(_attr(image, "embed")) + if relationship and relationship[0] == "image": + record["media_part"] = relationship[1] + state.record("objects", sheet, record) -def _sheet(state, archive, entry, path, kind, definitions, shared_strings, persons): +def _sheet(state, archive, entry, path, kind, definitions, reader, persons): name = state.clean(entry.get("name"))[:128] - root = state.xml(archive, path, required=True) - sheet = {"name": name, "state": entry.get("state", "visible"), "type": kind, "part": path} - state.meta["sheets"].append(sheet) - layout_names = {"mergeCell", "col", "pane", "pageMargins", "pageSetup", "printOptions", - "sheetFormatPr", "sheetView", "autoFilter", "sheetPr"} - layout = [] - for element in root.iter(): - local = _local(element.tag) - if local in layout_names or local == "row" and any(key in element.attrib for key in ("ht", "hidden", "s")): - if len(layout) < 200: - record = {"type": local, **{key: state.clean(value) for key, value in element.attrib.items()}} - style_id = element.get("style") if local == "col" else element.get("s") if local == "row" else None - if style_id is not None and 0 <= int(style_id) < len(definitions): - record["saved_style"] = definitions[int(style_id)] - layout.append(record) + relationships = state.rels(archive, path) + comments = _comments(state, archive, name, relationships, persons) + saved_styles = {} + + def inspect_styles(row, cells, attributes): + if state.progress_callback is not None and row % 1024 == 0: + state.progress_callback() + for cell in cells.values(): + if state.cells >= EXCEL_MAX_CELLS: + state.note(f"Cell formatting inspection sampled the first {EXCEL_MAX_CELLS} saved cells.") + return + state.cells += 1 + style_index = cell["style_id"] + spec = definitions[style_index] if 0 <= style_index < len(definitions) else {} + if not spec: + state.note("Some cell style references could not be resolved.") + reference = cell["cell"] + state.styles.add( + f"{name}!{reference}", state.clean(cell["value"])[:60], + **{key: spec.get(key) for key in ("font", "size_pt", "color", "bold", "italic", "underline")}, + ) + if style_index not in saved_styles: + if len(saved_styles) >= 100: + state.note("Per-sheet formatting evidence was capped at 100 distinct cell styles.") + continue + saved_styles[style_index] = {"style_id": style_index, "cells": [], "observed_cell_count": 0, **spec} + group = saved_styles[style_index] + group["observed_cell_count"] += 1 + if len(group["cells"]) < 30: + group["cells"].append(reference) else: - state.note("Sheet layout ranges were truncated to 200 records per sheet.") - sheet["layout"] = layout - sheet["conditional_format_rules"] = sum(_local(element.tag) == "cfRule" for element in root.iter()) - header_footer = _first(root, "headerFooter") - sheet["header_footer"] = {} - if header_footer is not None: - sheet["header_footer"] = { - "flags": dict(header_footer.attrib), - "expressions": {_local(child.tag): state.clean(child.text) for child in header_footer}, - "sections": {_local(child.tag): _header_sections(state.clean(child.text)) for child in header_footer}, + state.note("Style location lists show the first 30 cells per saved style per sheet.") + + sheet, cells = reader.scan_sheet( + name, row_callback=inspect_styles, wanted_cells={record["cell"] for record in comments}, + ) + expressions = sheet.get("header_footer", {}).get("expressions") or {} + if expressions: + sheet["header_footer"]["sections"] = { + key: _header_sections(value) for key, value in expressions.items() } + for record in sheet["layout"]: + style_id = record.get("style") if record["type"] == "col" else record.get("s") + if style_id is not None and 0 <= int(style_id) < len(definitions): + record["saved_style"] = definitions[int(style_id)] + state.meta["sheets"].append(state.preview(sheet)) + state.meta["scanned_sheet_count"] = state.meta.get("scanned_sheet_count", 0) + 1 + state.meta["scanned_cells"] = state.meta.get("scanned_cells", 0) + sheet["scanned_cells"] state.emit(name, "Sheet layout, headers and footers (raw Excel control codes; not evaluated)", sheet) - relationships = state.rels(archive, path) - _comments(state, archive, name, relationships, persons) + for table in sheet["tables"]: + state.record("tables", name, table) + for key in ("hyperlinks", "validations"): + for record in sheet.get(key) or []: + state.record(key, name, record) + for record in comments: + cell = cells[record["cell"]] + row, column = cell_coordinates(record["cell"]) + record.update({ + "cell_value": cell["value"], "cell_value_raw": cell["raw_value"], + "cell_value_type": cell["value_type"], "cell_value_status": cell["value_status"], + "formula": cell["formula"], "formula_type": cell["formula_type"], + "formula_reference": cell["formula_reference"], + "cached_value_available": cell["cached_value_available"], + "number_format": cell.get("number_format"), + "table_ids": [ + table["id"] for table in sheet["tables"] + if table["min_row"] <= row <= table["max_row"] + and table["min_column"] <= column <= table["max_column"] + ], + }) + state.record("comments", name, record) _objects(state, archive, name, relationships) - if _first(root, "oleObjects") is not None or any(kind in ("oleObject", "activeXControl", "control") for kind, _ in relationships.values()): + if sheet.get("unsupported_controls") or any(kind in ("oleObject", "activeXControl", "control") for kind, _ in relationships.values()): state.note("This workbook contains unsupported OLE/ActiveX controls; their alt text was not inspected.") - if any(_local(element.tag) in ("cellControl", "featurePropertyBag") for element in root.iter()): - state.note("Modern in-cell controls were detected; their accessibility metadata is unsupported.") - column_styles = [(int(column.get("min")), int(column.get("max")), column.get("style")) - for column in root.iter() if _local(column.tag) == "col" and column.get("style") is not None] - row_styles = {row.get("r"): row.get("s") for row in root.iter() - if _local(row.tag) == "row" and row.get("s") is not None} - saved_styles = {} - for element in root.iter(): - if _local(element.tag) != "c": - continue - if state.cells >= EXCEL_MAX_CELLS: - state.note(f"Cell formatting inspection sampled the first {EXCEL_MAX_CELLS} saved cells.") - break - state.cells += 1 - ref = state.clean(element.get("r"))[:32] - column_match = re.match(r"([A-Z]+)(\d+)$", ref) - inherited_style = None - if column_match: - column_index = 0 - for letter in column_match[1]: - column_index = column_index * 26 + ord(letter) - ord("A") + 1 - inherited_style = next((style for low, high, style in column_styles if low <= column_index <= high), None) - inherited_style = row_styles.get(column_match[2], inherited_style) - style_index = int(element.get("s", inherited_style or 0)) - spec = definitions[style_index] if 0 <= style_index < len(definitions) else {} - if not spec: - state.note("Some cell style references could not be resolved.") - value = _first(element, "v") - raw = _text(value) - if element.get("t") == "s": - index = int(raw) if raw else -1 - raw = shared_strings[index] if 0 <= index < len(shared_strings) else "[unresolved shared string]" - elif element.get("t") == "inlineStr": - raw = _text(_first(element, "is")) - # Text is used only for the bounded style accumulator, not copied to search evidence. - snippet = state.clean(raw)[:60] - if raw == "[unresolved shared string]": - state.note("Some shared-string references were outside the inspected string range.") - location = f"{name}!{ref}" - state.styles.add(location, snippet, **{key: spec.get(key) for key in ( - "font", "size_pt", "color", "bold", "italic", "underline" - )}) - if style_index not in saved_styles: - if len(saved_styles) >= 100: - state.note("Per-sheet formatting evidence was capped at 100 distinct cell styles.") - continue - saved_styles[style_index] = {"style_id": style_index, "cells": [], "observed_cell_count": 0, **spec} - group = saved_styles[style_index] - group["observed_cell_count"] += 1 - if len(group["cells"]) < 30: - group["cells"].append(ref) - else: - state.note("Style location lists show the first 30 cells per saved style per sheet.") for group in saved_styles.values(): state.emit(name, "Saved cell formatting (not worksheet data)", group) @@ -559,18 +943,14 @@ def _extract_ooxml(state, file_path): workbook_path = next((path for kind, path in relationships.values() if kind == "officeDocument"), "xl/workbook.xml") core_path = next((path for kind, path in relationships.values() if kind == "core-properties"), "docProps/core.xml") _core_properties(state, state.xml(archive, core_path)) + _additional_properties(state, archive, relationships) workbook = state.xml(archive, workbook_path, required=True) workbook_rels = state.rels(archive, workbook_path) definitions = _style_definitions(state, archive, workbook_rels) state.emit("(workbook)", "Saved default cell style", definitions[0]) - shared_strings, persons = [], {} + persons = {} for kind, path in workbook_rels.values(): - if kind == "sharedStrings": - root = state.xml(archive, path, required=True) - shared_strings = [state.clean(_text(item)) for item in islice(root, EXCEL_MAX_CELLS)] - if len(root) > EXCEL_MAX_CELLS: - state.note("Shared strings were truncated at the cell inspection limit.") - elif kind in ("person", "persons"): + if kind in ("person", "persons"): root = state.xml(archive, path, required=True) persons = {element.get("id"): state.clean(element.get("displayName")) for element in root.iter() if _local(element.tag) == "person"} @@ -579,26 +959,35 @@ def _extract_ooxml(state, file_path): state.meta["sheet_count"] = len(entries) if len(entries) > EXCEL_MAX_SHEETS: state.note(f"Only the first {EXCEL_MAX_SHEETS} sheets were inspected.") - for entry in entries[:EXCEL_MAX_SHEETS]: - relationship = workbook_rels.get(_attr(entry, "id")) - if not relationship or relationship[0] not in ("worksheet", "chartsheet"): - state.note("A sheet relationship is unsupported or unavailable.") - continue - try: - _sheet(state, archive, entry, relationship[1], relationship[0], definitions, shared_strings, persons) - except (ValueError, KeyError, OSError, ParseError, DefusedXmlException, zipfile.BadZipFile) as exc: - state.note(f"A sheet could not be completely inspected ({type(exc).__name__}).") - log_event("[DOCUMENT_METADATA] Excel sheet inspection incomplete.", level=30, - extra={"error_type": type(exc).__name__}) + with ExcelWorkbookReader(archive, extension="." + state.meta["format"]) as reader: + for entry in entries[:EXCEL_MAX_SHEETS]: + relationship = workbook_rels.get(_attr(entry, "id")) + if not relationship or relationship[0] not in ("worksheet", "chartsheet"): + state.note("A sheet relationship is unsupported or unavailable.") + continue + try: + _sheet(state, archive, entry, relationship[1], relationship[0], definitions, reader, persons) + except (ValueError, KeyError, OSError, ParseError, DefusedXmlException, zipfile.BadZipFile) as exc: + state.note(f"A sheet could not be completely inspected ({type(exc).__name__}).") + state.meta.setdefault("incomplete_sheets", []).append(state.clean(entry.get("name"))) + log_event("[DOCUMENT_METADATA] Excel sheet inspection incomplete.", level=30, + extra={"error_type": type(exc).__name__}) + state.meta["xml_scan_bytes"] = reader.scanned_xml_bytes + for note in reader.coverage_notes: + state.note(note) defined_names = [ {"name": state.clean(item.get("name")), "sheet_index": item.get("localSheetId"), - "expression": state.clean(item.text)} + "expression": item.text or "", "hidden": item.get("hidden") in ("1", "true")} for item in workbook.iter() if _local(item.tag) == "definedName" - and item.get("name") in ("_xlnm.Print_Titles", "_xlnm.Print_Area") + ] + for record in defined_names: + state.record("defined_names", "(workbook)", record) + state.meta["print_defined_names"] = [ + record for record in defined_names if record["name"] in ("_xlnm.Print_Titles", "_xlnm.Print_Area") ][:EXCEL_MAX_SHEETS * 2] - state.meta["print_defined_names"] = defined_names - if defined_names: - state.emit("(workbook)", "Print titles and print areas (not header/footer text)", defined_names) + if state.meta["print_defined_names"]: + state.emit("(workbook)", "Print titles and print areas (not header/footer text)", state.meta["print_defined_names"]) + state.meta["table_count"] = state.counts["tables"] def _extract_xls(state, file_path): @@ -642,10 +1031,15 @@ def _extract_xls(state, file_path): state.meta["sheets"].append(info) state.emit(name, "Legacy sheet layout", info) for (row, column), note in sheet.cell_note_map.items(): + value = sheet.cell_value(row, column) if row < sheet.nrows and column < sheet.row_len(row) else None + state.meta["comment_summary"]["raw_records"] += 1 + state.meta["comment_summary"]["legacy_notes"] += 1 state.record("comments", name, { "kind": "note", "cell": f"{get_column_letter(column + 1)}{row + 1}", - "text": state.clean(note.text), "author": state.clean(note.author), + "text": note.text, "author": state.clean(note.author), "date": None, "resolved": None, + "cell_value": value, "cell_value_status": "blank" if value is None or value == "" else "saved", + "formula": None, "cached_value_available": None, }) for row in range(sheet.nrows): if state.cells >= EXCEL_MAX_CELLS: @@ -671,9 +1065,9 @@ def _extract_xls(state, file_path): workbook.release_resources() -def extract_excel_accessibility_metadata(file_path, extension): +def extract_excel_accessibility_metadata(file_path, extension, *, record_sink=None, progress_callback=None): """Return bounded parent metadata and location-specific native evidence.""" - state = _Inspection(extension) + state = _Inspection(extension, record_sink=record_sink, progress_callback=progress_callback) try: if extension == ".xls": _extract_xls(state, file_path) @@ -735,5 +1129,7 @@ def is_excel_native_inspection_question(question, file_names=None): r"hidden (?:rows?|columns?|sheets?)|freeze panes?|conditional formatting|" r"document (?:title|properties)|workbook properties|keywords|" r"(?:cell |threaded )?(?:comments|notes)|author(?:s|ship)?|" - r"checkbox(?:es)?|check boxes|fill colo[u]?r|number formats?)\b", text, - )) + r"checkbox(?:es)?|check boxes|fill colo[u]?r|number formats?|" + r"custom properties|metadata|named ranges?|defined names?|hyperlinks?|data validation|" + r"cell values?|cell formulas?|saved formulas?|cached values?)\b", text, + ) or re.search(r"\bcells?\s+[a-z]{1,3}[1-9]\d*|!\$?[a-z]{1,3}\$?[1-9]\d*", text)) diff --git a/application/single_app/functions_excel_inventory.py b/application/single_app/functions_excel_inventory.py new file mode 100644 index 000000000..882920fef --- /dev/null +++ b/application/single_app/functions_excel_inventory.py @@ -0,0 +1,379 @@ +# functions_excel_inventory.py +"""Version-bound, paged Excel inventories in the existing private artifact store.""" + +import base64 +from collections import OrderedDict +from copy import deepcopy +import hashlib +import json +import logging +import os +import tempfile +from threading import RLock +import uuid + +from azure.core.exceptions import AzureError, ResourceNotFoundError + +from content_screening.contracts import ScreeningError, Subject, subject_from_document +from functions_appinsights import log_event +from functions_excel_accessibility import extract_excel_accessibility_metadata +from excel_workbook_reader import EXCEL_WORKBOOK_SCHEMA_VERSION + + +EXCEL_INVENTORY_FIELD = "excel_native_inventory" +EXCEL_INVENTORY_SECTIONS = frozenset({ + "comments", "objects", "tables", "defined_names", "hyperlinks", "validations", + "property_records", "custom_properties", "extended_properties", + "image_analyses", +}) +EXCEL_INVENTORY_PART_BYTES = 256 * 1024 +EXCEL_INVENTORY_PART_RECORDS = 100 +EXCEL_INVENTORY_PAGE_BYTES = 14000 +EXCEL_INVENTORY_CACHE_BYTES = 16 * 1024 * 1024 +_CACHE = OrderedDict() +_CACHE_LOCK = RLock() + + +class ExcelInventoryPersistenceError(ScreeningError): + code = "excel_inventory_unavailable" + public_message = "The workbook inspection could not be stored. Retry the operation." + + +def _encoded(value): + return json.dumps(value, ensure_ascii=False, allow_nan=False, separators=(",", ":"), sort_keys=True).encode("utf-8") + + +def _source_digest(path): + digest = hashlib.sha256() + with open(path, "rb") as source: + for data in iter(lambda: source.read(65536), b""): + digest.update(data) + return digest.hexdigest() + + +def _cache_key(subject, source_digest, storage, cache_namespace=None): + namespace = cache_namespace if cache_namespace is not None else id(storage) + return subject.key, source_digest, EXCEL_WORKBOOK_SCHEMA_VERSION, namespace + + +def _remember(key, manifest, reference): + size = len(_encoded(manifest)) + if size > EXCEL_INVENTORY_CACHE_BYTES: + return + with _CACHE_LOCK: + _CACHE.pop(key, None) + while _CACHE and ( + len(_CACHE) >= 16 + or sum(entry[2] for entry in _CACHE.values()) + size > EXCEL_INVENTORY_CACHE_BYTES + ): + _CACHE.popitem(last=False) + _CACHE[key] = (deepcopy(manifest), deepcopy(reference), size) + + +def clear_excel_inventory_cache(subject=None): + with _CACHE_LOCK: + for key in list(_CACHE): + if subject is None or key[0] == subject.key: + del _CACHE[key] + + +class ExcelInventoryWriter: + """Write bounded immutable pages, then atomically publish their manifest.""" + + def __init__(self, storage, subject, source_digest, capture=None): + if not isinstance(subject, Subject): + raise TypeError("An authorized workbook subject is required.") + self.storage = storage + self.subject = subject + self.source_digest = source_digest + self.capture = capture + self.scan_id = f"excel-native:{EXCEL_WORKBOOK_SCHEMA_VERSION}:{source_digest}:{uuid.uuid4().hex}" + self.pages = [] + self.buffers = {} + self.sizes = {} + self.counts = {} + + def _write(self, name, value): + try: + return self.storage.write_json(self.subject, self.scan_id, name, value) + except (AzureError, ScreeningError, OSError, RuntimeError, ValueError, TypeError) as error: + log_event( + "[DOCUMENT_METADATA] Excel inventory persistence failed.", + level=logging.ERROR, + extra={"document_id": self.subject.document_id, "error_type": type(error).__name__}, + ) + raise ExcelInventoryPersistenceError() from error + + def add(self, collection, record): + if collection not in EXCEL_INVENTORY_SECTIONS or not isinstance(record, dict): + raise ValueError("An Excel inventory record is invalid.") + payload = _encoded(record) + if self.capture is not None: + self.capture.add_supplement(payload.decode("utf-8"), kind="excel_native") + records = self.buffers.setdefault(collection, []) + if records and ( + self.sizes.get(collection, 0) + len(payload) > EXCEL_INVENTORY_PART_BYTES + or len(records) >= EXCEL_INVENTORY_PART_RECORDS + ): + self._flush(collection) + records = self.buffers[collection] + records.append(record) + self.sizes[collection] = self.sizes.get(collection, 0) + len(payload) + self.counts[collection] = self.counts.get(collection, 0) + 1 + + def _flush(self, collection): + records = self.buffers.get(collection) or [] + if not records: + return + first = self.counts[collection] - len(records) + reference = self._write(f"excel-{collection}-{first}", records) + self.pages.append({ + "section": collection, "first": first, "count": len(records), "reference": reference, + }) + self.buffers[collection] = [] + self.sizes[collection] = 0 + + def finish(self, metadata): + metadata.pop("image_locations", None) + for collection in list(self.buffers): + self._flush(collection) + complete = ( + metadata.get("coverage") != "failed" + and not metadata.get("incomplete_sheets") + and metadata.get("sheet_count") == metadata.get("scanned_sheet_count", len(metadata.get("sheets") or [])) + ) + metadata["inventory_storage"] = { + "schema_version": EXCEL_WORKBOOK_SCHEMA_VERSION, "source_sha256": self.source_digest, + "status": "ready" if complete else "partial", + "counts": dict(self.counts), "page_count": len(self.pages), + } + manifest = { + "schema_version": EXCEL_WORKBOOK_SCHEMA_VERSION, "subject": self.subject.to_dict(), + "source_sha256": self.source_digest, "metadata": metadata, + "complete": complete, "counts": dict(self.counts), "pages": self.pages, + } + manifest_reference = self._write("excel-manifest", manifest) + reference = { + "schema_version": EXCEL_WORKBOOK_SCHEMA_VERSION, + "source_sha256": self.source_digest, "manifest": manifest_reference, + } + _remember(_cache_key(self.subject, self.source_digest, self.storage), manifest, reference) + return reference + + +def persist_excel_inventory(file_path, extension, *, subject, storage, capture=None, enrich=None): + digest = _source_digest(file_path) + writer = ExcelInventoryWriter(storage, subject, digest, capture=capture) + metadata, evidence = extract_excel_accessibility_metadata( + file_path, extension, record_sink=writer.add, + progress_callback=capture.heartbeat if capture is not None else None, + ) + if enrich is not None: + enrich(metadata, evidence, writer.add) + reference = writer.finish(metadata) + return metadata, evidence, reference + + +def _validate_manifest(manifest, subject, digest): + if ( + not isinstance(manifest, dict) + or manifest.get("schema_version") != EXCEL_WORKBOOK_SCHEMA_VERSION + or manifest.get("subject") != subject.to_dict() + or manifest.get("source_sha256") != digest + or not isinstance(manifest.get("metadata"), dict) + or not isinstance(manifest.get("counts"), dict) + or not isinstance(manifest.get("pages"), list) + or type(manifest.get("complete")) is not bool + ): + raise ValueError("The Excel inventory does not match the authorized source.") + counts = {} + for page in manifest["pages"]: + section = page.get("section") + if ( + section not in EXCEL_INVENTORY_SECTIONS + or type(page.get("first")) is not int or page["first"] < 0 + or type(page.get("count")) is not int or not 1 <= page["count"] <= EXCEL_INVENTORY_PART_RECORDS + or page["first"] != counts.get(section, 0) + or not isinstance(page.get("reference"), dict) + ): + raise ValueError("The Excel inventory page mapping is invalid.") + counts[section] = counts.get(section, 0) + page["count"] + if counts != manifest["counts"]: + raise ValueError("The Excel inventory counts are invalid.") + + +def open_excel_inventory(document, source_bytes, extension, *, storage, authorize, cache_namespace=None): + """The caller supplies freshly authorized, active-representation bytes.""" + if not callable(authorize) or not isinstance(source_bytes, bytes): + raise TypeError("Authorized source bytes and a source check are required.") + authorize() + subject = subject_from_document(document) + digest = hashlib.sha256(source_bytes).hexdigest() + key = _cache_key(subject, digest, storage, cache_namespace) + with _CACHE_LOCK: + cached = _CACHE.get(key) + if cached is not None: + _CACHE.move_to_end(key) + manifest, reference = deepcopy(cached[:2]) + else: + manifest = reference = None + if manifest is None: + stored = document.get(EXCEL_INVENTORY_FIELD) + if ( + isinstance(stored, dict) + and stored.get("schema_version") == EXCEL_WORKBOOK_SCHEMA_VERSION + and stored.get("source_sha256") == digest + and isinstance(stored.get("manifest"), dict) + and stored["manifest"].get("subject_key") == subject.key + ): + try: + manifest = storage.read_json(stored["manifest"], subject) + reference = stored + except ResourceNotFoundError: + log_event( + "[DOCUMENT_METADATA] Rebuilding an unavailable derived Excel inventory.", + level=logging.INFO, extra={"document_id": subject.document_id}, + ) + if manifest is None: + with tempfile.TemporaryDirectory(prefix="simplechat_excel_inventory_") as folder: + path = os.path.join(folder, "source" + extension) + with open(path, "wb") as source: + source.write(source_bytes) + _, _, reference = persist_excel_inventory(path, extension, subject=subject, storage=storage) + manifest = storage.read_json(reference["manifest"], subject) + _validate_manifest(manifest, subject, digest) + _remember(key, manifest, reference) + _validate_manifest(manifest, subject, digest) + authorize() + return ExcelInventoryReader(storage, subject, manifest, reference, authorize) + + +def open_stored_excel_inventory(document, *, storage, authorize): + """Read an immutable revision inventory without downloading its workbook again.""" + authorize() + reference = document.get(EXCEL_INVENTORY_FIELD) + if not isinstance(reference, dict) or reference.get("schema_version") != EXCEL_WORKBOOK_SCHEMA_VERSION: + return None + subject = subject_from_document(document) + digest = reference.get("source_sha256") + stored = reference.get("manifest") + if ( + not isinstance(digest, str) or len(digest) != 64 + or not isinstance(stored, dict) or stored.get("subject_key") != subject.key + ): + return None + active = (document.get("content_screening") or {}).get("active_blob") or {} + if active.get("content_hash") and active["content_hash"] != digest: + return None + manifest = storage.read_json(stored, subject) + _validate_manifest(manifest, subject, digest) + authorize() + return ExcelInventoryReader(storage, subject, manifest, reference, authorize) + + +class ExcelInventoryReader: + def __init__(self, storage, subject, manifest, reference, authorize): + self.storage = storage + self.subject = subject + self.manifest = manifest + self.reference = reference + self.authorize = authorize + + @property + def metadata(self): + self.authorize() + return deepcopy(self.manifest["metadata"]) + + def _cursor(self, section, offset, fragment=0): + return base64.urlsafe_b64encode(_encoded({ + "subject": self.subject.key, "source": self.manifest["source_sha256"], + "section": section, "offset": offset, "fragment": fragment, + })).decode("ascii").rstrip("=") + + def _parse_cursor(self, token, section): + if not isinstance(token, str) or not token or len(token) > 1024: + raise ValueError("The Excel inspection cursor is invalid.") + try: + value = json.loads(base64.b64decode(token + "=" * (-len(token) % 4), altchars=b"-_", validate=True)) + except (ValueError, UnicodeError) as error: + raise ValueError("The Excel inspection cursor is invalid.") from error + if ( + not isinstance(value, dict) or set(value) != {"subject", "source", "section", "offset", "fragment"} + or value["subject"] != self.subject.key or value["source"] != self.manifest["source_sha256"] + or value["section"] != section + or any(type(value[key]) is not int or value[key] < 0 for key in ("offset", "fragment")) + ): + raise ValueError("The Excel inspection cursor belongs to a different source or section.") + return value["offset"], value["fragment"] + + def page(self, section="comments", *, cursor=None, page_size=100, max_bytes=EXCEL_INVENTORY_PAGE_BYTES): + if section not in EXCEL_INVENTORY_SECTIONS: + raise ValueError("The requested Excel inventory section is invalid.") + if type(page_size) is not int or not 1 <= page_size <= 200: + raise ValueError("The Excel inventory page size must be between 1 and 200.") + if type(max_bytes) is not int or not 2048 <= max_bytes <= 65536: + raise ValueError("The Excel inventory response budget is invalid.") + self.authorize() + offset, fragment = self._parse_cursor(cursor, section) if cursor else (0, 0) + total = self.manifest["counts"].get(section, 0) + if offset > total or offset == total and fragment: + raise ValueError("The Excel inspection cursor is outside the inventory.") + records, used, next_offset, next_fragment = [], 0, offset, 0 + record_budget = max_bytes - 1024 + for page in self.manifest["pages"]: + if page["section"] != section or page["first"] + page["count"] <= offset: + continue + self.authorize() + values = self.storage.read_json(page["reference"], self.subject) + if not isinstance(values, list) or len(values) != page["count"] or any(not isinstance(value, dict) for value in values): + raise ValueError("The Excel inventory page failed its record check.") + self.authorize() + for index in range(max(offset - page["first"], 0), len(values)): + record = values[index] + encoded = _encoded(record) + if records and (len(records) >= page_size or used + len(encoded) > record_budget): + break + if not records and (len(encoded) > record_budget or fragment): + serialized = encoded.decode("utf-8") + if fragment >= len(serialized): + raise ValueError("The Excel record continuation is invalid.") + low, high = 1, min(len(serialized) - fragment, record_budget) + result = None + while low <= high: + middle = (low + high) // 2 + candidate = { + "sheet": record.get("sheet"), "cell": record.get("cell"), "id": record.get("id"), + "record_json_fragment": serialized[fragment:fragment + middle], + "fragment_offset": fragment, "record_characters": len(serialized), + "record_fragment": True, + } + if len(_encoded(candidate)) <= record_budget: + result = candidate + low = middle + 1 + else: + high = middle - 1 + if result is None: + raise ValueError("The Excel record cannot fit the requested response budget.") + piece = result["record_json_fragment"] + end = fragment + len(piece) + records.append(result) + if end < len(serialized): + next_offset, next_fragment = page["first"] + index, end + else: + next_offset = page["first"] + index + 1 + break + records.append(record) + used += len(encoded) + next_offset = page["first"] + index + 1 + if next_fragment or len(records) >= page_size or next_offset < page["first"] + page["count"]: + break + self.authorize() + has_more = next_offset < total or bool(next_fragment) + return { + "section": section, "records": records, "total_records": total, + "returned_records": len(records), "start_record": offset, + "complete": bool(self.manifest["complete"] and not has_more and offset == 0), + "inventory_complete": self.manifest["complete"], "has_more": has_more, + "next_cursor": self._cursor(section, next_offset, next_fragment) if has_more else None, + "source_sha256": self.manifest["source_sha256"], + } diff --git a/application/single_app/functions_native_tabular_compute.py b/application/single_app/functions_native_tabular_compute.py index 587469785..99d4b5b40 100644 --- a/application/single_app/functions_native_tabular_compute.py +++ b/application/single_app/functions_native_tabular_compute.py @@ -213,14 +213,51 @@ def _compute_request(plan, user_question): if operation == "transform" and task_type not in {"structured_export", "combined"}: raise NativeTabularComputeError("native_compute_operation_unsupported") query = validate_tabular_csv_query_expression(hints.get("query_expression") or "index == index") - return { + selected_table = hints.get("selected_table") if hints.get("selected_table") is not None else hints.get("table_id") + cell_range = hints.get("cell_range") if hints.get("cell_range") is not None else hints.get("selected_range") + header_row = hints.get("header_row") if hints.get("header_row") is not None else hints.get("selected_header_row") + selected_sheet = hints.get("selected_sheet") + if ( + (selected_sheet is not None and (not isinstance(selected_sheet, str) or len(selected_sheet) > 512)) + or any( + value is not None and (not isinstance(value, str) or not value.strip() or len(value) > 512) + for value in (selected_table, cell_range) + ) + or ( + header_row is not None + and (isinstance(header_row, bool) or not str(header_row).isascii() or not str(header_row).isdigit()) + ) + or (selected_table is not None and cell_range is not None) + or ( + hints.get("selected_table") is not None and hints.get("table_id") is not None + and hints["selected_table"] != hints["table_id"] + ) + or ( + hints.get("cell_range") is not None and hints.get("selected_range") is not None + and hints["cell_range"] != hints["selected_range"] + ) + or ( + hints.get("header_row") is not None and hints.get("selected_header_row") is not None + and str(hints["header_row"]) != str(hints["selected_header_row"]) + ) + ): + raise NativeTabularComputeError("native_compute_table_selection_invalid") + request = { "task_type": task_type, "operation": operation, "query_expression": query, - "selected_sheet": hints.get("selected_sheet"), + "selected_sheet": selected_sheet, "deliverable_contract": deepcopy(contract), "row_analysis_mode": plan.get("row_analysis_mode"), "row_analysis_questions": deepcopy(plan.get("row_analysis_questions") or []), "question_sha256": native_compute_digest(user_question), } + # Omitted selectors must not change fingerprints of existing CSV jobs. + request.update({ + key: value for key, value in { + "selected_table": selected_table, "cell_range": cell_range, + "header_row": int(header_row) if header_row is not None else None, + }.items() if value is not None + }) + return request def _prepare_native_source(engine, source, request, user_id): @@ -235,7 +272,12 @@ def _prepare_native_source(engine, source, request, user_id): plugin = engine.TabularProcessingPlugin(authorized_user_id=user_id) container, blob_path = locator["container"], locator["blob_path"] query = request["query_expression"] + selectors = plugin._table_selector_kwargs( + request.get("selected_table"), request.get("cell_range"), request.get("header_row"), + ) if source_format == "csv": + if selectors: + raise NativeTabularComputeError("native_compute_table_selection_invalid") result = plugin._query_csv_data_in_bounded_chunks( container, blob_path, filename, query, return_columns=None, start_row=0, max_rows=5, ) @@ -246,9 +288,10 @@ def _prepare_native_source(engine, source, request, user_id): else: selected_sheet = request["selected_sheet"] metadata = plugin._get_workbook_metadata(container, blob_path) - if selected_sheet: + if selected_sheet or selectors.get("table_id") not in (None, "all") or selectors.get("cell_range"): selected_sheet, _ = plugin._resolve_sheet_selection( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **selectors, ) sheets = [selected_sheet] else: @@ -259,6 +302,7 @@ def _prepare_native_source(engine, source, request, user_id): descriptor = plugin._build_generated_export_query_descriptor_from_location( container_name=container, blob_path=blob_path, filename=filename, query_expression=query, blob_version=version, selected_sheet=selected_sheet, sheet_names=sheets, + **selectors, ) count, samples = 0, [] for _, row in engine._iter_versioned_tabular_source_rows( @@ -279,6 +323,9 @@ def _prepare_native_source(engine, source, request, user_id): descriptor["document_id"] = source["document_id"] candidate = { "filename": filename, "selected_sheet": descriptor.get("selected_sheet"), + "selected_table": descriptor.get("selected_table"), + "cell_range": descriptor.get("cell_range"), "header_row": descriptor.get("header_row"), + "table_selections": deepcopy(descriptor.get("table_selections") or []), "rows": samples, "row_count": len(samples), "total_matches": count, "full_result_available": False, "source_authorization": descriptor, } diff --git a/application/single_app/functions_office_media.py b/application/single_app/functions_office_media.py index 25b820b4d..13713b355 100644 --- a/application/single_app/functions_office_media.py +++ b/application/single_app/functions_office_media.py @@ -548,7 +548,7 @@ def _inspect_containers(root_elem, rel_targets): return media_a11y_map -def extract_office_embedded_images_with_diagnostics(file_path, output_dir, min_pixels=150, max_images=25): +def extract_office_embedded_images_with_diagnostics(file_path, output_dir, min_pixels=150, max_images=25, native_media_metadata=None): """Extract embedded images and report what was skipped and why. Without the diagnostics a document containing only unsupported figures is indistinguishable @@ -586,6 +586,9 @@ def extract_office_embedded_images_with_diagnostics(file_path, output_dir, min_p media_slide_map = _build_pptx_media_slide_map(archive) media_word_offsets, total_body_words = build_docx_image_word_offsets(archive) media_a11y_map = _build_office_media_accessibility_map(archive) + if native_media_metadata is not None: + media_a11y_map.update(native_media_metadata) + native_seen_images = {} diagnostics['total_body_words'] = total_body_words candidate_names = [ @@ -626,6 +629,9 @@ def extract_office_embedded_images_with_diagnostics(file_path, output_dir, min_p digest = hashlib.sha256(image_bytes).hexdigest() if digest in seen_digests: + if native_media_metadata is not None and digest in native_seen_images: + placements = (media_a11y_map.get(media_name) or {}).get('placements') or [] + native_seen_images[digest]['placements'].extend(placements) _record_skip(diagnostics, 'duplicate_image') continue @@ -678,17 +684,24 @@ def extract_office_embedded_images_with_diagnostics(file_path, output_dir, min_p 'height': height, 'slide_number': media_slide_map.get(media_name), 'word_offset': media_word_offsets.get(media_name), - 'position_known': media_name in media_word_offsets or media_name in media_slide_map, + 'position_known': media_name in media_word_offsets or media_name in media_slide_map or bool(a11y_info.get('sheet_name')), 'source_format': source_extension.lstrip('.'), 'rasterized': is_vector, 'embedded_text': embedded_text, 'alt_text': a11y_info.get('alt_text', ''), 'title_text': a11y_info.get('title_text', ''), - 'is_decorative': bool(a11y_info.get('is_decorative', False)), + 'is_decorative': a11y_info.get('is_decorative') if a11y_info.get('sheet_name') else bool(a11y_info.get('is_decorative', False)), 'placement': a11y_info.get('placement', 'inline'), 'allow_overlap': bool(a11y_info.get('allow_overlap', False)), 'behind_doc': bool(a11y_info.get('behind_doc', False)), + **({ + 'sheet_name': a11y_info.get('sheet_name'), 'cell': a11y_info.get('cell'), + 'object_id': a11y_info.get('object_id'), 'media_part': media_name, + 'placements': list(a11y_info.get('placements') or []), + } if native_media_metadata is not None else {}), }) + if native_media_metadata is not None: + native_seen_images[digest] = extracted_images[-1] except (zipfile.BadZipFile, FileNotFoundError, OSError): return [], diagnostics @@ -1079,4 +1092,3 @@ def strip_appended_word_comments(text): if text.startswith(f"{WORD_COMMENTS_SECTION_HEADING}\n\n"): return '' return text - diff --git a/application/single_app/functions_search_service.py b/application/single_app/functions_search_service.py index 1ba12becb..4dc812229 100644 --- a/application/single_app/functions_search_service.py +++ b/application/single_app/functions_search_service.py @@ -11,6 +11,8 @@ from azure.identity import DefaultAzureCredential, get_bearer_token_provider from azure.cosmos.exceptions import CosmosResourceNotFoundError from openai import AzureOpenAI +from openpyxl.utils.cell import get_column_letter +from azure.core.exceptions import ResourceNotFoundError from content_screening import access as screening_access from content_screening.access import ( @@ -25,15 +27,23 @@ strict_source_authority_enabled, ) from content_screening.contracts import SourceAuthorityUnverifiedError +from content_screening.storage import ScreeningStorage from config import ( CLIENTS, cognitive_services_scope, cosmos_conversations_container, cosmos_messages_container, + storage_account_content_screening_container_name, ) +from excel_workbook_reader import ExcelWorkbookReader, bounded_range from functions_appinsights import log_event from functions_debug import debug_print from functions_documents import get_document_record, get_ordered_document_chunks +from functions_excel_inventory import ( + EXCEL_INVENTORY_SECTIONS, + open_excel_inventory, + open_stored_excel_inventory, +) from functions_group import get_user_groups from functions_model_endpoint_identity_header import build_model_endpoint_identity_headers from model_endpoint_clients import build_openai_client_timeout_options @@ -1112,6 +1122,74 @@ def _normalize_accessibility_sections(sections): return requested or list(ACCESSIBILITY_REPORT_SECTIONS) +def _read_excel_inspection( + document_context, user_id, *, native_section="comments", native_cursor=None, + native_page_size=100, sheet_name=None, cell_range=None, + max_bytes=14000, +): + document = document_context["document"] + source_evidence = {PROVENANCE_FIELD: document_provenance(document)} + + def authorize(): + assert_evidence_available(source_evidence, user_id, cached=True) + + if native_section not in EXCEL_INVENTORY_SECTIONS: + raise ValueError("The Excel inspection section is invalid.") + if type(native_page_size) is not int or not 1 <= native_page_size <= 200: + raise ValueError("The Excel inspection page size must be between 1 and 200.") + storage = ScreeningStorage( + client=CLIENTS.get("storage_account_office_docs_client"), + container_name=storage_account_content_screening_container_name, + ) + try: + inventory = open_stored_excel_inventory(document, storage=storage, authorize=authorize) + except ResourceNotFoundError: + inventory = None + log_event( + "[DOCUMENT_METADATA] Rebuilding an unavailable derived Excel inventory.", + level=logging.INFO, extra={"document_id": document["id"]}, + ) + source_bytes = None + extension = "." + str(document.get("file_name") or "").rsplit(".", 1)[-1].lower() + if inventory is None or cell_range: + fresh_document, source_bytes = screening_access.read_available_document_bytes( + document, user_id=user_id, group_id=document_context.get("group_id"), + public_workspace_id=document_context.get("public_workspace_id"), purpose="accessibility", + ) + document_context["document"] = fresh_document + if inventory is None: + inventory = open_excel_inventory( + fresh_document, source_bytes, extension, storage=storage, authorize=authorize, + cache_namespace=( + storage_account_content_screening_container_name, + id(CLIENTS.get("storage_account_office_docs_client")), + ), + ) + metadata = inventory.metadata + page = inventory.page(native_section, cursor=native_cursor, page_size=native_page_size, max_bytes=max_bytes) + result = {"metadata": metadata, "page": page} + if cell_range: + low_column, low_row, high_column, high_row = bounded_range(cell_range) + if (high_column - low_column + 1) * (high_row - low_row + 1) > 2000: + raise ValueError("The Excel cell range exceeds its 2000-cell inspection limit.") + with ExcelWorkbookReader(source_bytes, extension=extension) as reader: + if not sheet_name: + if len(reader.sheet_names) != 1: + raise ValueError("Select a worksheet for cell inspection.") + sheet_name = reader.sheet_names[0] + references = [ + f"{get_column_letter(column)}{row}" + for row in range(low_row, high_row + 1) + for column in range(low_column, high_column + 1) + ] + cells = reader.read_cells(sheet_name, references) + result["cells"] = [ + {"sheet": sheet_name, **cells[reference]} for reference in references + ] + authorize() + return result + + def get_document_accessibility_payload( document_id, user_id, @@ -1121,6 +1199,12 @@ def get_document_accessibility_payload( conversation_id=None, sections=None, page_number=None, + native_section="comments", + native_cursor=None, + native_page_size=100, + sheet_name=None, + cell_range=None, + _native_max_bytes=14000, ): """Return the complete stored accessibility, style, and issue metadata for one document. @@ -1156,6 +1240,13 @@ def get_document_accessibility_payload( source_evidence = {PROVENANCE_FIELD: document_provenance(current_document)} stored_metadata = current_document.get("accessibility_metadata") + file_name = str(current_document.get("file_name") or "") + extension = "." + file_name.rsplit(".", 1)[-1].lower() if "." in file_name else "" + if not stored_metadata and extension in (".xlsx", ".xlsm", ".xls") and ( + current_document.get("source_file_available") or current_document.get("enhanced_citations") + or current_document.get("blob_path") or current_document.get("archived_blob_path") + ): + stored_metadata = {"format": extension.lstrip(".")} if not isinstance(stored_metadata, dict) or not stored_metadata: raise LookupError( "No accessibility metadata is stored for this document. It may have been uploaded before " @@ -1163,6 +1254,22 @@ def get_document_accessibility_payload( "re-upload the file to extract it." ) + excel_inspection = None + if stored_metadata.get("format") in ("xlsx", "xlsm", "xls") and ( + current_document.get("source_file_available") or current_document.get("enhanced_citations") + or current_document.get("blob_path") or current_document.get("archived_blob_path") + or current_document.get("excel_native_inventory") + ): + excel_inspection = _read_excel_inspection( + document_context, user_id, native_section=native_section, + native_cursor=native_cursor, native_page_size=native_page_size, + sheet_name=sheet_name, cell_range=cell_range, + max_bytes=_native_max_bytes, + ) + stored_metadata = excel_inspection["metadata"] + elif native_cursor or cell_range: + raise LookupError("The original workbook or full native inventory is unavailable for this inspection.") + requested_sections = _normalize_accessibility_sections(sections) report = {} if "accessibility" in requested_sections: @@ -1177,14 +1284,22 @@ def get_document_accessibility_payload( report["issues"] = stored_metadata.get(ACCESSIBILITY_REPORT_ISSUES_KEY) or [] page_chunks = None + chunks = [] if page_number not in (None, ""): - resolved_page = _coerce_positive_int(page_number, default_value=1) chunks = get_ordered_document_chunks( - document_id=document_id, - user_id=user_id, + document_id=document_id, user_id=user_id, group_id=document_context.get("group_id"), public_workspace_id=document_context.get("public_workspace_id"), ) + elif stored_metadata.get("format") in ("xlsx", "xlsm", "xls"): + chunks = get_ordered_document_chunks( + document_id=document_id, user_id=user_id, + group_id=document_context.get("group_id"), + public_workspace_id=document_context.get("public_workspace_id"), + max_chunks=1, native_only=True, + ) + if page_number not in (None, ""): + resolved_page = _coerce_positive_int(page_number, default_value=1) page_chunks = [ chunk for chunk in (chunks or []) if chunk.get("page_number") == resolved_page @@ -1202,6 +1317,23 @@ def get_document_accessibility_payload( if page_chunks is not None: payload["page_number"] = _coerce_positive_int(page_number, default_value=1) payload["page_chunks"] = page_chunks + if stored_metadata.get("format") in ("xlsx", "xlsm", "xls"): + native_chunk = next( + (chunk for chunk in chunks or [] if str(chunk.get("chunk_text") or "").startswith("### Excel native inspection")), + None, + ) + if native_chunk is not None: + payload["citation_chunk"] = native_chunk + if excel_inspection is not None: + payload["excel_inspection"] = { + key: value for key, value in excel_inspection.items() if key != "metadata" + } + page = excel_inspection["page"] + if native_section == "comments" and "accessibility_metadata" in payload: + payload["accessibility_metadata"]["comments"] = page["records"] + payload["accessibility_metadata"]["comment_page"] = { + key: value for key, value in page.items() if key != "records" + } return payload diff --git a/application/single_app/functions_tabular_generated_exports.py b/application/single_app/functions_tabular_generated_exports.py index 1f26415b6..3329a56bc 100644 --- a/application/single_app/functions_tabular_generated_exports.py +++ b/application/single_app/functions_tabular_generated_exports.py @@ -21,6 +21,7 @@ from datetime import datetime, timedelta, timezone from xml.sax.saxutils import escape as escape_xml_text +import pandas from azure.core import MatchConditions from azure.core.exceptions import ResourceExistsError from azure.cosmos.exceptions import CosmosResourceExistsError, CosmosResourceNotFoundError @@ -28,6 +29,7 @@ from semantic_kernel.connectors.ai.open_ai.prompt_execution_settings.azure_chat_prompt_execution_settings import AzureChatPromptExecutionSettings from semantic_kernel.contents.chat_history import ChatHistory as SKChatHistory from semantic_kernel_plugins.tabular_processing_plugin import TabularProcessingPlugin +from excel_workbook_reader import EXCEL_WORKBOOK_SCHEMA_VERSION, ExcelWorkbookReader from blob_container_readiness import ( BlobContainerUnavailableError, @@ -3165,7 +3167,7 @@ def _get_versioned_source_blob_client(source_descriptor): if isinstance(blob_properties, dict): current_etag = current_etag or str(blob_properties.get('etag') or '').strip() if current_etag != expected_etag: - raise ValueError('Source CSV changed after the export was queued') + raise ValueError('The tabular source changed after the computation was queued.') return blob_client @@ -3581,6 +3583,41 @@ def _checkpoint_source_input_batch(run, batch_rows, source_scan_row_count): return _replace_claimed_run(run) +def _iter_excel_table_source_chunks(reader, table, source_chunk_rows, source_row_offset=0): + """Keep only a bounded table batch, with physical worksheet provenance.""" + columns = [column['name'] for column in table['columns']] + rows, physical_rows, missing = [], [], {} + batch_start = source_row_offset + + def build_chunk(): + frame = pandas.DataFrame( + rows, columns=columns, index=range(batch_start, batch_start + len(rows)), + ) + frame.attrs.update({ + 'excel_table': deepcopy(table), 'excel_tables': [deepcopy(table)], + 'excel_row_numbers': tuple(physical_rows), + 'excel_row_table_ids': (table['id'],) * len(rows), + 'excel_table_ranges': {table['id']: table['range']}, + 'excel_missing_formula_caches': deepcopy(missing), + 'excel_index_offset': batch_start, + }) + return frame + + for physical_row, cells in reader.iter_table_rows(table): + ordinal = len(rows) + rows.append(['' if cell['value'] is None else str(cell['value']) for cell in cells]) + physical_rows.append(physical_row) + for column, cell in zip(columns, cells): + if cell['value_status'] == 'cache_missing': + missing.setdefault(column, set()).add(ordinal) + if len(rows) >= source_chunk_rows: + yield build_chunk() + batch_start += len(rows) + rows, physical_rows, missing = [], [], {} + if rows: + yield build_chunk() + + def _iter_versioned_tabular_source_rows( source_descriptor, source_format, @@ -3588,8 +3625,14 @@ def _iter_versioned_tabular_source_rows( resume_source_row, user_id=None, ): + if type(resume_source_row) is not int or resume_source_row < 0: + raise ValueError('The source replay cursor is invalid.') + source_chunk_rows = max(1, min(10000, int(source_chunk_rows or 1))) blob_path = str(source_descriptor.get('blob_path') or '').strip() + container_name = source_descriptor.get('container') tabular_plugin = TabularProcessingPlugin(authorized_user_id=user_id) + tabular_plugin._assert_blob_screening_access(container_name, blob_path) + assert_evidence_available(source_descriptor, user_id=user_id) if source_format == 'csv': source_blob_client = _get_versioned_source_blob_client(source_descriptor) @@ -3610,52 +3653,124 @@ def _iter_versioned_tabular_source_rows( tabular_plugin=tabular_plugin, start_source_row=resume_source_row, ) - yield from source_rows + for row_number, row in source_rows: + yield row_number, row + tabular_plugin._assert_blob_screening_access(container_name, blob_path) + _get_versioned_source_blob_client(source_descriptor) return - _get_versioned_source_blob_client(source_descriptor) - sheet_names = [ - str(sheet_name or '').strip() - for sheet_name in source_descriptor.get('sheet_names') or [] - if str(sheet_name or '').strip() - ] - if not sheet_names: - raise ValueError('Source-backed workbook replay requires an explicit worksheet scope') + if ( + type(source_descriptor.get('version')) is not int or source_descriptor.get('version') != 2 + or source_descriptor.get('selection_semantics') != 'excel-tables-v2' + or source_descriptor.get('workbook_schema_version') != EXCEL_WORKBOOK_SCHEMA_VERSION + ): + # A v1 job meant the entire worksheet with row 1 as its header. Table + # discovery is not an equivalent resume of that historical operation. + raise ValueError( + 'This queued workbook uses legacy worksheet-header semantics. Start a new computation to select its tables explicitly.' + ) + selections = source_descriptor.get('table_selections') + source_row_count = source_descriptor.get('source_row_count') + sheet_names = source_descriptor.get('sheet_names') + numeric_scope = source_descriptor.get('numeric_conversion_scope') + if ( + not isinstance(selections, list) or not isinstance(sheet_names, list) or not sheet_names + or any(not isinstance(name, str) or not name for name in sheet_names) + or len(set(sheet_names)) != len(sheet_names) + or ( + source_descriptor.get('selected_sheet') is not None + and source_descriptor.get('selected_sheet') not in sheet_names + ) + or type(source_row_count) is not int or source_row_count < 0 + or resume_source_row > source_row_count + or any(not isinstance(table, dict) for table in selections) + or numeric_scope not in ('table', 'sheet') + ): + raise ValueError('The saved workbook table selection or replay cursor is invalid.') + source_blob_client = _get_versioned_source_blob_client(source_descriptor) + source_bytes = source_blob_client.download_blob( + etag=source_descriptor.get('blob_etag'), match_condition=MatchConditions.IfNotModified, + ).readall() + if hashlib.sha256(source_bytes).hexdigest() != source_descriptor.get('source_sha256'): + raise ValueError('The saved workbook source identity no longer matches.') parsed_return_columns = tabular_plugin._parse_optional_column_list_argument( source_descriptor.get('return_columns') ) - source_row_offset = 0 - for sheet_name in sheet_names: - source_dataframe = tabular_plugin._read_tabular_blob_to_dataframe( - source_descriptor.get('container'), - blob_path, - sheet_name=sheet_name, - require_explicit_sheet=True, - ) - source_dataframe = tabular_plugin._try_numeric_conversion(source_dataframe) - source_dataframe.index = range( - source_row_offset, - source_row_offset + len(source_dataframe), - ) - source_row_offset += len(source_dataframe) - filtered_dataframe, _ = tabular_plugin._apply_query_expression_with_fallback( - source_dataframe, - query_expression=source_descriptor.get('query_expression'), - normalize_match=False, - ) - selected_columns = [ - column_name - for column_name in (parsed_return_columns or list(filtered_dataframe.columns)) - if column_name in filtered_dataframe.columns - ] - output_records = tabular_plugin._build_row_output_records( - filtered_dataframe, - selected_columns, - ) - for source_row_index, output_record in zip(filtered_dataframe.index, output_records): - source_row_number = int(source_row_index) + 1 - if source_row_number > resume_source_row: - yield source_row_number, output_record + query = validate_tabular_csv_query_expression(source_descriptor.get('query_expression')) + with ExcelWorkbookReader(source_bytes, extension=f'.{source_format}') as reader: + if any(name not in reader.sheet_names for name in sheet_names): + raise ValueError('The saved workbook worksheet selection is invalid.') + manifest = reader.build_manifest() + metadata = { + 'tables': [table for sheet in manifest['sheets'] for table in sheet['tables']], + 'tables_by_sheet': {sheet['name']: sheet['tables'] for sheet in manifest['sheets']}, + } + resolved_tables = [] + for sheet_name in sheet_names: + resolved_tables.extend(tabular_plugin._select_excel_tables( + reader, metadata, sheet_name, source_descriptor.get('table_id'), + source_descriptor.get('cell_range'), source_descriptor.get('header_row'), + allow_heterogeneous=True, + )) + selected_table = ( + resolved_tables[0]['id'] if len(resolved_tables) == 1 else source_descriptor.get('table_id') + ) + if ( + resolved_tables != selections or selected_table != source_descriptor.get('selected_table') + or sum(table['row_count'] for table in resolved_tables) != source_row_count + ): + raise ValueError('The saved workbook table, range, or header selection no longer matches.') + numeric_columns_by_scope = {} + for table in resolved_tables: + scope_key = table['sheet'] if numeric_scope == 'sheet' else table['id'] + columns = {column['name'] for column in table['columns']} + numeric_columns = numeric_columns_by_scope.setdefault(scope_key, set(columns)) + numeric_columns.intersection_update(columns) + actual_rows = 0 + for source_chunk in _iter_excel_table_source_chunks(reader, table, source_chunk_rows): + actual_rows += len(source_chunk) + for column in list(numeric_columns): + try: + pandas.to_numeric(source_chunk[column]) + except (ValueError, TypeError): + numeric_columns.discard(column) + if actual_rows != table['row_count']: + raise ValueError('The saved workbook table row count no longer matches.') + tabular_plugin._assert_blob_screening_access(container_name, blob_path) + _get_versioned_source_blob_client(source_descriptor) + source_row_offset = 0 + for table in resolved_tables: + scope_key = table['sheet'] if numeric_scope == 'sheet' else table['id'] + numeric_columns = numeric_columns_by_scope[scope_key] + actual_rows = table['row_count'] + if source_row_offset + actual_rows <= resume_source_row: + source_row_offset += actual_rows + continue + for source_chunk in _iter_excel_table_source_chunks( + reader, table, source_chunk_rows, source_row_offset, + ): + if source_chunk.index[-1] < resume_source_row: + continue + for column in numeric_columns: + source_chunk[column] = pandas.to_numeric(source_chunk[column]) + source_chunk = source_chunk.loc[source_chunk.index >= resume_source_row] + filtered_chunk, _ = tabular_plugin._apply_query_expression_with_fallback( + source_chunk, query_expression=query, normalize_match=False, + ) + selected_columns = [ + column for column in (parsed_return_columns or list(filtered_chunk.columns)) + if column in filtered_chunk.columns + ] + records = tabular_plugin._build_row_output_records(filtered_chunk, selected_columns) + tabular_plugin._assert_blob_screening_access(container_name, blob_path) + assert_evidence_available(source_descriptor, user_id=user_id) + _get_versioned_source_blob_client(source_descriptor) + for source_row_index, record in zip(filtered_chunk.index, records): + if source_descriptor.get('include_sheet_column') is True: + record['_sheet'] = table['sheet'] + yield int(source_row_index) + 1, record + source_row_offset += actual_rows + tabular_plugin._assert_blob_screening_access(container_name, blob_path) _get_versioned_source_blob_client(source_descriptor) @@ -3692,7 +3807,14 @@ def _stage_tabular_generated_output_source(run, settings): minimum=1, maximum=TABULAR_EXPORT_MAX_SOURCE_BATCH_CHARS, ) - resume_source_row = _safe_int(run.get('source_scan_row_count')) + resume_source_row = run.get('source_scan_row_count', 0) + if ( + type(resume_source_row) is not int or resume_source_row < 0 + or resume_source_row < _safe_int(run.get('source_staged_rows')) + ): + raise ValueError('The saved source staging cursor is invalid.') + if _safe_int(run.get('source_staged_rows')) > expected_row_count: + raise ValueError('The saved source staging row count is invalid.') pending_rows = [] pending_chars = 0 last_source_row_number = resume_source_row @@ -3705,6 +3827,11 @@ def _stage_tabular_generated_output_source(run, settings): ) for source_row_number, source_row in source_rows: + if ( + type(source_row_number) is not int or source_row_number <= last_source_row_number + or not isinstance(source_row, dict) + ): + raise ValueError('The source replay returned an invalid or repeated cursor.') source_row_text = _dump_generated_output_json(source_row) current_batch_row_limit = _get_tabular_source_batch_row_limit( source_descriptor, @@ -3760,7 +3887,21 @@ def _stage_tabular_generated_output_source(run, settings): )) if not isinstance(batch_rows, list): raise ValueError(f'Source input checkpoint {batch_number}/{staged_batch_count} was not a JSON array') + expected_rows = _prepare_tabular_source_rows( + batch_rows, start_row=sum(staged_chunk_row_counts), token_namespace=run.get('id'), + ) + for row, expected in zip(batch_rows, expected_rows): + if not isinstance(row, dict) or any( + row.get(field) != expected[field] for field in ( + TABULAR_EXPORT_INPUT_ROW_NUMBER_FIELD, + TABULAR_EXPORT_INPUT_ROW_IDENTITY_FIELD, + TABULAR_EXPORT_INPUT_ROW_TOKEN_FIELD, + ) + ): + raise ValueError('A source input checkpoint has invalid row identity or order.') staged_chunk_row_counts.append(len(batch_rows)) + if sum(staged_chunk_row_counts) != staged_row_count: + raise ValueError('The source input checkpoints do not match the staged row count.') chunk_manifest = _write_chunk_manifest_for_run( run.get('user_id'), diff --git a/application/single_app/route_backend_chats.py b/application/single_app/route_backend_chats.py index 97551a1f3..efdac5e0f 100644 --- a/application/single_app/route_backend_chats.py +++ b/application/single_app/route_backend_chats.py @@ -169,7 +169,14 @@ from functions_authentication import * from functions_search import * from functions_search_service import get_document_accessibility_payload, search_documents, search_relevant_tabular_candidates -from functions_excel_accessibility import EXCEL_EVIDENCE_MARKER, is_excel_native_inspection_question +from functions_excel_accessibility import ( + EXCEL_EVIDENCE_MARKER, + build_excel_native_chat_evidence, + excel_native_question_sections, + has_excel_native_inspection_intent, + is_excel_native_inspection_question, + merge_excel_native_evidence, +) from functions_accessibility import format_accessibility_metadata_for_chat from functions_public_workspaces import resolve_public_chat_workspace_ids from public_chat_scope_state import aggregate_public_workspace_ids @@ -14003,41 +14010,52 @@ def execute_source(source): 'active_group_ids': [source['group_id']] if source.get('group_id') else None, 'active_public_workspace_id': source.get('public_workspace_id'), } + sections = excel_native_question_sections(question) report = get_document_accessibility_payload( - source['document_id'], user_id, conversation_id=conversation_id, **scope, + source['document_id'], user_id, conversation_id=conversation_id, + native_section=sections[0], _native_max_bytes=10000, **scope, ) metadata = report.get('accessibility_metadata') or {} if metadata.get('format') not in ('xlsx', 'xlsm', 'xls'): raise ValueError('This source has no native Excel inspection metadata') - summary = format_accessibility_metadata_for_chat({ - **metadata, 'style_inventory': report.get('style_inventory') or {}, - }) - reference = annotate_document_search_payload( - {'document': report['document']}, 'get_document_accessibility_report', - ) - excerpts = search_documents( - query=f"Excel native inspection {question}", user_id=user_id, - document_ids=[source['document_id']], top_n=5, **scope, - ) - native_results = [ - item for item in excerpts.get('results', []) - if EXCEL_EVIDENCE_MARKER in str(item.get('chunk_text') or '') - ] - excerpts = annotate_document_search_payload({'results': native_results}, 'search_documents') - text = f"{summary[:6000]}\n{reference.get('citation', '')}" - if len(summary) > 6000: - text += "\n[Parent summary shortened; request the stored report for remaining details.]" - for item in native_results[:3]: - content = str(item.get('chunk_text') or '') - text += f"\n\n{content[:2500]}\n{item.get('citation', '')}" - if len(content) > 2500: - text += "\n[Search excerpt shortened; request this evidence segment for remaining details.]" - if not native_results: - text += "\nNo native evidence excerpts matched this query; only the stored parent summary is available." + pages = [] + if (report.get('excel_inspection') or {}).get('page'): + pages.append(report['excel_inspection']['page']) + for section in sections[1:]: + section_report = get_document_accessibility_payload( + source['document_id'], user_id, conversation_id=conversation_id, + native_section=section, _native_max_bytes=10000, **scope, + ) + section_page = (section_report.get('excel_inspection') or {}).get('page') + if section_page: + pages.append(section_page) + if pages: + report.setdefault('excel_inspection', {})['pages'] = pages + reference = annotate_document_search_payload(report, 'get_document_accessibility_report') + native_evidence = build_excel_native_chat_evidence(reference, question) + text = f"{native_evidence['summary']}\n{reference.get('citation', '')}" + native_results = [] + if not native_evidence['returned_records']: + excerpts = search_documents( + query=f"Excel native inspection {question}", user_id=user_id, + document_ids=[source['document_id']], top_n=5, **scope, + ) + native_results = [ + item for item in excerpts.get('results', []) + if EXCEL_EVIDENCE_MARKER in str(item.get('chunk_text') or '') + ] + excerpts = annotate_document_search_payload({'results': native_results}, 'search_documents') + for item in excerpts['results']: + content = str(item.get('chunk_text') or '') + addition = f"\n\n{content}\n{item.get('citation', '')}" + if len((text + addition).encode('utf-8')) > 16000: + native_evidence['partial'] = True + continue + text += addition source_citations = [{ 'tool_name': 'document_search.get_document_accessibility_report', 'plugin_name': 'document_search', 'function_name': 'get_document_accessibility_report', - 'function_arguments': {'document_id': source['document_id']}, + 'function_arguments': {'document_id': source['document_id'], 'native_section': sections[0]}, 'function_result': reference, 'success': True, }] if native_results: @@ -14055,7 +14073,11 @@ def execute_source(source): 'summary': text, 'citations': source_citations, 'coverage': { 'execution_mode': 'native_inspection', 'worksheet_data_computed': False, + 'worksheet_data_read': native_evidence['worksheet_data_read'], 'native_coverage': metadata.get('coverage'), + 'native_records_returned': native_evidence['returned_records'], + 'native_records_partial': native_evidence['partial'], + 'native_next_cursor': native_evidence['next_cursor'], 'matched_evidence_segments': len(native_results), }, } @@ -14098,6 +14120,18 @@ def _execute_mixed_source_tabular_evidence( cancel_requested=cancel_requested, request_correlation_id=request_correlation_id, ) + excel_native_sources = [ + source for source in tabular_sources + if str(source.get('file_name') or '').lower().endswith(('.xlsx', '.xlsm', '.xls')) + ] + native_result = None + if excel_native_sources and has_excel_native_inspection_intent( + user_question, file_names=[source.get('file_name') for source in excel_native_sources], + ): + native_result = _execute_excel_native_inspection_evidence( + excel_native_sources, user_question, user_id, conversation_id, selection_mode, + cancel_requested=cancel_requested, request_correlation_id=request_correlation_id, + ) source_contexts = build_tabular_file_contexts_from_manifest(tabular_sources) if has_request_context(): authorized_context = dict(getattr(g, 'authorized_chat_context', {}) or {}) @@ -14140,7 +14174,7 @@ def fail_unavailable_tabular_source(source): del source raise RuntimeError('Tabular processing is unavailable') - return { + return merge_excel_native_evidence({ 'evidence_envelopes': execute_tabular_evidence_sources( tabular_sources, fail_unavailable_tabular_source, @@ -14155,7 +14189,7 @@ def fail_unavailable_tabular_source(source): 'invocations': [], 'executed': False, 'token_usage': None, - } + }, native_result, user_question) execute_tabular = should_run_tabular_evidence( user_question, @@ -14369,7 +14403,7 @@ def execute_source(source): request_correlation_id=request_correlation_id, user_id=user_id, ) - return { + return merge_excel_native_evidence({ 'evidence_envelopes': evidence_envelopes, 'system_messages': system_messages, 'agent_citations': agent_citations, @@ -14377,7 +14411,7 @@ def execute_source(source): 'invocations': all_invocations, 'executed': execute_tabular, 'token_usage': token_usage if token_usage['request_count'] else None, - } + }, native_result, user_question) def _exclude_xsd_contract_sources_from_evidence(manifest, xsd_generation_contract): diff --git a/application/single_app/route_enhanced_citations.py b/application/single_app/route_enhanced_citations.py index e3d36cb82..8f5aad3c6 100644 --- a/application/single_app/route_enhanced_citations.py +++ b/application/single_app/route_enhanced_citations.py @@ -12,6 +12,7 @@ import mimetypes import io import uuid +import zipfile from urllib.parse import quote import pandas import fitz @@ -28,6 +29,7 @@ read_available_document_bytes, ) from content_screening.contracts import ScreeningError +from excel_workbook_reader import build_excel_table_preview from functions_authentication import login_required, user_required, get_current_user_id, get_current_user_info from functions_appinsights import log_event from functions_artifact_publication import publish_generated_chat_artifact_for_user @@ -144,6 +146,17 @@ def _serialize_tabular_preview_table(df_preview): return columns, rows +def _preview_integer(value, name, default, minimum=0, maximum=None): + if value is None: + return default + if not isinstance(value, str) or not value.isascii() or not value.isdigit(): + raise ValueError(f"{name} must be an integer.") + parsed = int(value) + if parsed < minimum or maximum is not None and parsed > maximum: + raise ValueError(f"{name} is outside the supported preview range.") + return parsed + + def _resolve_document_blob_reference(raw_doc): """Resolve the persisted blob container and path for the cited document.""" _, container_name, blob_name = get_available_blob_reference(raw_doc, purpose="citation") @@ -920,7 +933,7 @@ def get_enhanced_citation_tabular_preview(): doc_id = request.args.get("doc_id") sheet_name = request.args.get("sheet_name") sheet_index = request.args.get("sheet_index") - max_rows = min(request.args.get("max_rows", 200, type=int), 500) + table_id = request.args.get("table_id") if not doc_id: return jsonify({"error": "doc_id is required"}), 400 @@ -929,6 +942,9 @@ def get_enhanced_citation_tabular_preview(): return jsonify({"error": "User not authenticated"}), 401 try: + max_rows = _preview_integer(request.args.get("max_rows"), "max_rows", 200, 1, 500) + start_row = _preview_integer(request.args.get("start_row"), "start_row", 0) + header_row = _preview_integer(request.args.get("header_row"), "header_row", None, 0, 1048576) doc_response, status_code = get_document(user_id, doc_id) if status_code != 200: return doc_response, status_code @@ -952,99 +968,54 @@ def get_enhanced_citation_tabular_preview(): return jsonify({"error": "File is too large to preview"}), 400 raw_doc, data = read_available_document_bytes(raw_doc, user_id=user_id, purpose="preview") - # Read into DataFrame, limiting rows for preview efficiency - # Read max_rows + 1 so we can detect truncation without loading the full file - nrows_limit = max_rows + 1 - selected_sheet = None - sheet_names = [] if ext == 'csv': + # Keep the optional CSV decoder out of Excel-only preview requests. from functions_tabular_csv_query import read_tabular_csv - df = read_tabular_csv(io.BytesIO(data), keep_default_na=False, dtype=str, nrows=nrows_limit) - elif ext in ('xlsx', 'xlsm'): - excel_file = pandas.ExcelFile(io.BytesIO(data), engine='openpyxl') - sheet_names = list(excel_file.sheet_names) - if not sheet_names: - return jsonify({"error": "Workbook does not contain any readable sheets"}), 400 - - if sheet_name: - requested_sheet_name = sheet_name.strip() - matching_sheet_name = next( - (candidate for candidate in sheet_names if candidate.lower() == requested_sheet_name.lower()), - None, - ) - if not matching_sheet_name: - return jsonify({ - "error": f"Sheet '{requested_sheet_name}' was not found. Available sheets: {sheet_names}" - }), 400 - selected_sheet = matching_sheet_name - elif sheet_index not in (None, ''): - try: - resolved_sheet_index = int(sheet_index) - except ValueError: - return jsonify({"error": "sheet_index must be an integer"}), 400 - if resolved_sheet_index < 0 or resolved_sheet_index >= len(sheet_names): - return jsonify({ - "error": f"sheet_index {resolved_sheet_index} is out of range. Available sheets: {sheet_names}" - }), 400 - selected_sheet = sheet_names[resolved_sheet_index] - else: - selected_sheet = sheet_names[0] - - df = excel_file.parse(selected_sheet, keep_default_na=False, dtype=str, nrows=nrows_limit) - elif ext == 'xls': - excel_file = pandas.ExcelFile(io.BytesIO(data), engine='xlrd') - sheet_names = list(excel_file.sheet_names) - if not sheet_names: - return jsonify({"error": "Workbook does not contain any readable sheets"}), 400 - - if sheet_name: - requested_sheet_name = sheet_name.strip() - matching_sheet_name = next( - (candidate for candidate in sheet_names if candidate.lower() == requested_sheet_name.lower()), - None, - ) - if not matching_sheet_name: - return jsonify({ - "error": f"Sheet '{requested_sheet_name}' was not found. Available sheets: {sheet_names}" - }), 400 - selected_sheet = matching_sheet_name - elif sheet_index not in (None, ''): - try: - resolved_sheet_index = int(sheet_index) - except ValueError: - return jsonify({"error": "sheet_index must be an integer"}), 400 - if resolved_sheet_index < 0 or resolved_sheet_index >= len(sheet_names): - return jsonify({ - "error": f"sheet_index {resolved_sheet_index} is out of range. Available sheets: {sheet_names}" - }), 400 - selected_sheet = sheet_names[resolved_sheet_index] - else: - selected_sheet = sheet_names[0] - - df = excel_file.parse(selected_sheet, keep_default_na=False, dtype=str, nrows=nrows_limit) + frames, seen, selected = [], 0, 0 + columns = [] + with read_tabular_csv( + io.BytesIO(data), keep_default_na=False, dtype=str, chunksize=10000, + ) as chunks: + for frame in chunks: + columns = frame.columns.tolist() + if seen + len(frame) > start_row: + window = frame.iloc[max(0, start_row - seen):] + window = window.head(max_rows + 1 - selected) + frames.append(window) + selected += len(window) + seen += len(frame) + if selected > max_rows: + break + frame = pandas.concat(frames, ignore_index=True) if frames else pandas.DataFrame(columns=columns) + has_more = len(frame) > max_rows + frame = frame.head(max_rows) + names, rows = _serialize_tabular_preview_table(frame) + result = { + "selected_sheet": None, "sheet_names": [], "sheet_count": 0, + "tables": [], "table_count": 0, "total_rows": None if has_more else seen, + "total_columns": len(names), "columns": names, "rows": rows, + "row_numbers": list(range(start_row + 2, start_row + 2 + len(rows))), + "start_row": start_row, "has_more": has_more, "truncated": has_more, + "next_start_row": start_row + len(rows) if has_more else None, + } else: - return jsonify({"error": f"Unsupported file type: {ext}"}), 400 - - total_rows = len(df) - truncated = total_rows > max_rows - preview = df.head(max_rows) - columns, rows = _serialize_tabular_preview_table(preview) - - return jsonify({ - "filename": file_name, - "selected_sheet": selected_sheet, - "sheet_names": sheet_names, - "sheet_count": len(sheet_names), - "total_rows": total_rows if not truncated else None, - "total_columns": len(df.columns), - "columns": columns, - "rows": rows, - "truncated": truncated - }) + result = build_excel_table_preview( + data, "." + ext, sheet_name=sheet_name, sheet_index=sheet_index, + table_id=table_id, start_row=start_row, max_rows=max_rows, + cell_range=request.args.get("cell_range"), header_row=header_row, + ) + frame = pandas.DataFrame(result["rows"], columns=result["columns"]) + result["columns"], result["rows"] = _serialize_tabular_preview_table(frame) + return jsonify({"filename": file_name, **result}) - except Exception as e: - debug_print(f"Error generating tabular preview: {e}") - return jsonify({"error": str(e)}), 500 + except ScreeningError as error: + return jsonify({"error": error.public_message, "error_code": error.code}), error.status_code + except (ValueError, zipfile.BadZipFile, pandas.errors.EmptyDataError) as error: + _log_enhanced_citations_error("Spreadsheet preview selection failed.", error, document_id=doc_id) + return jsonify({"error": "The spreadsheet selection is invalid or unavailable. Choose a valid worksheet, table, and row window."}), 400 + except Exception as error: + _log_enhanced_citations_error("Spreadsheet preview failed.", error, document_id=doc_id) + return jsonify({"error": "Unable to load the spreadsheet preview."}), 500 @bp.route("/api/enhanced_citations/visio", methods=["GET"]) @swagger_route(security=get_auth_security()) diff --git a/application/single_app/semantic_kernel_plugins/document_search_plugin.py b/application/single_app/semantic_kernel_plugins/document_search_plugin.py index d7b1f9c40..0a19ca864 100644 --- a/application/single_app/semantic_kernel_plugins/document_search_plugin.py +++ b/application/single_app/semantic_kernel_plugins/document_search_plugin.py @@ -1,11 +1,13 @@ # document_search_plugin.py +import logging from typing import Annotated, Any, Dict, List, Optional, Union from semantic_kernel.functions import kernel_function from content_screening.contracts import ScreeningError from functions_authentication import get_current_user_id +from functions_appinsights import log_event from public_chat_scope_state import current_public_chat_scope from functions_agent_document_citations import annotate_document_search_payload from functions_search import ( @@ -155,6 +157,11 @@ def metadata(self) -> Dict[str, Any]: {'name': 'doc_scope', 'type': 'str', 'description': 'all, personal, group, or public.', 'required': False}, {'name': 'sections', 'type': 'str', 'description': 'Optional comma-separated sections: accessibility, style, issues.', 'required': False}, {'name': 'page_number', 'type': 'int', 'description': 'Optional page or slide number whose chunk text is also returned.', 'required': False}, + {'name': 'native_section', 'type': 'str', 'description': 'Excel inventory section: comments, tables, objects, image_analyses, property_records, custom_properties, extended_properties, defined_names, hyperlinks, validations.', 'required': False}, + {'name': 'native_cursor', 'type': 'str', 'description': 'Excel next_cursor returned by the previous inventory page.', 'required': False}, + {'name': 'native_page_size', 'type': 'int', 'description': 'Excel records per response, between 1 and 200.', 'required': False}, + {'name': 'sheet_name', 'type': 'str', 'description': 'Worksheet for an optional saved-cell range read.', 'required': False}, + {'name': 'cell_range', 'type': 'str', 'description': 'Optional Excel A1 range, at most 2000 cells, without executing formulas.', 'required': False}, ], 'returns': {'type': 'dict', 'description': 'Stored accessibility metadata, style inventory, and issues.'}, }, @@ -441,6 +448,10 @@ def retrieve_document_chunks( 'Use it to build custom style-guide or accessibility checks. This is extracted metadata, not a ' 'WCAG or PDF/UA conformance result. Use sections to limit the output and page_number to also ' 'return that page\'s stored chunk text. ' + 'For Excel, inspect native_section and follow excel_inspection.page.next_cursor until has_more ' + 'is false when the question requires every record. Compatibility notes are not extra comments. ' + 'Use sheet_name and cell_range for actual saved values and formula caches; do not infer them ' + 'from a schema preview. Existing stored originals are inspected without requiring re-upload. ' 'The payload carries a "citation" value; copy it verbatim into your answer when you use it.' ), ) @@ -452,6 +463,11 @@ def get_document_accessibility_report( page_number: Annotated[int, 'Optional 1-based stored page/slide or Excel evidence segment number, not an Excel printed page.'] = 0, active_group_ids: Annotated[str, 'Optional comma-separated group ids when resolving group content.'] = '', active_public_workspace_id: Annotated[str, 'Optional public workspace id when resolving public content.'] = '', + native_section: Annotated[str, 'Excel section: comments, tables, objects, image_analyses, property_records, custom_properties, extended_properties, defined_names, hyperlinks, validations.'] = 'comments', + native_cursor: Annotated[str, 'Excel inventory next_cursor from the previous page, including continued long records.'] = '', + native_page_size: Annotated[int, 'Excel inventory page size from 1 through 200; responses also have a byte budget.'] = 100, + sheet_name: Annotated[str, 'Worksheet name for optional direct saved-cell inspection.'] = '', + cell_range: Annotated[str, 'Optional A1 range with at most 2000 cells; reads saved values/formulas, never recalculates.'] = '', ) -> Annotated[dict, 'Stored accessibility, style inventory, and issue metadata for one document.']: try: return annotate_document_search_payload( @@ -464,6 +480,9 @@ def get_document_accessibility_report( active_public_workspace_id=self._resolve_allowed_public_workspace_ids(active_public_workspace_id), sections=sections, page_number=page_number if int(page_number or 0) > 0 else None, + native_section=native_section, native_cursor=native_cursor or None, + native_page_size=native_page_size, sheet_name=sheet_name or None, + cell_range=cell_range or None, ), 'get_document_accessibility_report', ) @@ -471,8 +490,12 @@ def get_document_accessibility_report( return {"error": error.public_message, "error_code": error.code, "status_code": error.status_code} except DocumentSearchScopeError as error: return {'error': str(error)} - except Exception as e: - return {'error': str(e)} + except Exception as error: + log_event( + "[DOCUMENT_METADATA] Document inspection action failed.", + level=logging.WARNING, extra={"error_type": type(error).__name__}, + ) + return {'error': 'Unable to inspect the requested document or workbook range.'} # bac-check: ignore - summarize_document_content delegates to get_document_chunks_payload's current-user scope check. @plugin_function_logger('DocumentSearchPlugin') diff --git a/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py b/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py index 878f70c9c..4eb859f1e 100644 --- a/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py +++ b/application/single_app/semantic_kernel_plugins/tabular_processing_plugin.py @@ -8,6 +8,7 @@ """ import asyncio import copy +import hashlib from datetime import date, datetime import io import json @@ -15,6 +16,7 @@ import math import re import tempfile +import tokenize import warnings import pandas from azure.core import MatchConditions @@ -22,6 +24,12 @@ from typing import Annotated, Dict, List, Optional, Set from urllib.parse import urlsplit, urlunsplit from semantic_kernel.functions import kernel_function +from excel_workbook_reader import ( + EXCEL_PREVIEW_MAX_BYTES, + EXCEL_PREVIEW_MAX_COLUMNS, + EXCEL_WORKBOOK_SCHEMA_VERSION, + ExcelWorkbookReader, +) from semantic_kernel_plugins.plugin_invocation_logger import PluginInvocationResult, plugin_function_logger from content_screening.access import ( PRIVATE_CONTAINER, @@ -51,6 +59,27 @@ ) +class TabularSelectionError(ValueError): + """A user-actionable selection failure, containing no storage error text.""" + + def __init__(self, message, *, code='table_selection_required', choices=None): + super().__init__(message) + self.public_message = message + self.code = code + self.choices = copy.deepcopy(choices or []) + + +class TabularSavedValueError(ValueError): + """The selected operation depends on formulas without saved results.""" + + def __init__(self): + self.public_message = ( + "Selected formula cells have no saved cached values. Recalculate and save " + "the workbook in Excel before computing these values." + ) + super().__init__(self.public_message) + + class TabularProcessingPlugin: """Provides data analysis functions on tabular files stored in blob storage.""" @@ -130,6 +159,7 @@ class TabularProcessingPlugin: ROW_OUTPUT_SAFE_CHAR_LIMIT = 50000 ROW_OUTPUT_PROTECTED_COLUMNS = ( '_sheet', + '_excel_source', '_matched_columns', '_matched_values', '_matched_on', @@ -138,14 +168,15 @@ class TabularProcessingPlugin: ) def __init__(self, *, authorized_user_id=None): - self._df_cache = {} # Per-instance cache: (container, blob_name, sheet_name) -> DataFrame - self._blob_data_cache = {} # Per-instance cache: (container, blob_name) -> raw bytes - self._workbook_metadata_cache = {} # Per-instance cache: (container, blob_name) -> workbook metadata + self._df_cache = {} # Source version and explicit selection -> DataFrame + self._blob_data_cache = {} # (container, blob_name, ETag) -> raw bytes + self._workbook_metadata_cache = {} # (container, blob_name, ETag) -> workbook metadata self._blob_version_cache = {} # Per-instance cache: (container, blob_name) -> immutable blob version metadata self._default_sheet_overrides = {} # (container, blob_name) -> default sheet name self._resolved_blob_location_overrides = {} # (source, filename) -> (container, blob_name) self._screening_source_versions = {} self._screening_user_id = authorized_user_id + self._last_table_reads = {} @classmethod def get_discovery_function_names(cls): @@ -419,11 +450,12 @@ def _is_authorized_blob_location(self, container_name: str, blob_path: str, auth def _evict_screened_blob_cache(self, container_name, blob_name): cache_key = (container_name, blob_name) - for cache_name in ("_blob_data_cache", "_workbook_metadata_cache", "_blob_version_cache"): - getattr(self, cache_name).pop(cache_key, None) - for key in list(self._df_cache): - if key[:2] == cache_key: - self._df_cache.pop(key, None) + for cache_name in ("_blob_data_cache", "_workbook_metadata_cache", "_df_cache", "_last_table_reads"): + cache = getattr(self, cache_name) + for key in list(cache): + if key[:2] == cache_key: + cache.pop(key, None) + self._blob_version_cache.pop(cache_key, None) self._screening_source_versions.pop(cache_key, None) def _assert_blob_screening_access(self, container_name, blob_name, *, purpose="native"): @@ -472,7 +504,8 @@ def _list_tabular_blobs(self, container_name: str, prefix: str) -> List[str]: def _download_tabular_blob_bytes(self, container_name: str, blob_name: str) -> bytes: """Download a blob once and reuse the raw bytes across sheet-aware operations.""" document, user_id = self._assert_blob_screening_access(container_name, blob_name) - cache_key = (container_name, blob_name) + blob_version = self._get_tabular_blob_version(container_name, blob_name, refresh=True) + cache_key = (container_name, blob_name, blob_version['blob_etag']) if cache_key in self._blob_data_cache: return self._blob_data_cache[cache_key] @@ -483,11 +516,6 @@ def _download_tabular_blob_bytes(self, container_name: str, blob_name: str) -> b client = self._get_blob_service_client() blob_client = client.get_blob_client(container=container_name, blob=blob_name) - blob_version = self._get_tabular_blob_version( - container_name, - blob_name, - refresh=True, - ) stream = blob_client.download_blob( etag=blob_version['blob_etag'], match_condition=MatchConditions.IfNotModified, @@ -508,7 +536,11 @@ def _get_tabular_blob_version(self, container_name: str, blob_name: str, refresh container=container_name, blob=blob_name, ) - blob_properties = blob_client.get_blob_properties() + try: + blob_properties = blob_client.get_blob_properties() + except Exception: + self._evict_screened_blob_cache(container_name, blob_name) + raise blob_etag = getattr(blob_properties, 'etag', None) blob_size = getattr(blob_properties, 'size', None) if isinstance(blob_properties, dict): @@ -527,6 +559,11 @@ def _get_tabular_blob_version(self, container_name: str, blob_name: str, refresh } if document is not None: blob_version[PROVENANCE_FIELD] = document_provenance(document) + previous = self._blob_version_cache.get(cache_key) + if previous is not None and previous != blob_version: + self._evict_screened_blob_cache(container_name, blob_name) + if document is not None: + self._screening_source_versions[cache_key] = document_provenance(document) self._blob_version_cache[cache_key] = blob_version return dict(blob_version) @@ -541,8 +578,8 @@ def _get_excel_engine(self, blob_name: str) -> Optional[str]: def _get_workbook_metadata(self, container_name: str, blob_name: str) -> dict: """Return workbook metadata including available sheet names for Excel files.""" - self._assert_blob_screening_access(container_name, blob_name) - cache_key = (container_name, blob_name) + blob_version = self._get_tabular_blob_version(container_name, blob_name, refresh=True) + cache_key = (container_name, blob_name, blob_version['blob_etag']) if cache_key in self._workbook_metadata_cache: return copy.deepcopy(self._workbook_metadata_cache[cache_key]) @@ -552,16 +589,26 @@ def _get_workbook_metadata(self, container_name: str, blob_name: str) -> dict: 'sheet_names': [], 'sheet_count': 0, 'default_sheet': None, + 'blob_etag': blob_version['blob_etag'], } if engine: data = self._download_tabular_blob_bytes(container_name, blob_name) - excel_file = pandas.ExcelFile(io.BytesIO(data), engine=engine) - sheet_names = list(excel_file.sheet_names) + extension = '.xls' if engine == 'xlrd' else '.xlsm' if blob_name.lower().endswith('.xlsm') else '.xlsx' + with ExcelWorkbookReader(data, extension=extension) as reader: + manifest = reader.build_manifest() + manifest['source_sha256'] = hashlib.sha256(data).hexdigest() + sheet_names = [sheet['name'] for sheet in manifest['sheets']] metadata.update({ 'sheet_names': sheet_names, 'sheet_count': len(sheet_names), 'default_sheet': sheet_names[0] if sheet_names else None, + 'inspection_schema_version': EXCEL_WORKBOOK_SCHEMA_VERSION, + 'table_count': manifest['table_count'], + 'tables': [table for sheet in manifest['sheets'] for table in sheet['tables']], + 'tables_by_sheet': {sheet['name']: sheet['tables'] for sheet in manifest['sheets']}, + 'coverage': manifest['coverage'], + 'workbook_manifest': manifest, }) self._assert_blob_screening_access(container_name, blob_name) @@ -575,8 +622,12 @@ def _resolve_sheet_selection( sheet_name: Optional[str] = None, sheet_index: Optional[str] = None, require_explicit_sheet: bool = False, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> tuple: """Resolve a workbook sheet selection and enforce explicit choice when required.""" + table_id, cell_range, header_row = self._normalize_table_selectors(table_id, cell_range, header_row) workbook_metadata = self._get_workbook_metadata(container_name, blob_name) if not workbook_metadata.get('is_workbook'): return None, workbook_metadata @@ -584,6 +635,18 @@ def _resolve_sheet_selection( available_sheets = workbook_metadata.get('sheet_names', []) if not available_sheets: raise ValueError(f"Workbook '{blob_name}' does not contain any readable sheets.") + if table_id and table_id != 'all' and not sheet_name and sheet_index in (None, ''): + matches = [ + table for table in workbook_metadata.get('tables') or [] + if table['id'] == table_id or table['name'] == table_id + ] + if len(matches) != 1: + raise TabularSelectionError( + "The requested workbook table was not found or is ambiguous.", + code='table_selection_invalid', + choices=self._table_choices(workbook_metadata), + ) + sheet_name = matches[0]['sheet'] matched_sheet_name = self._match_workbook_sheet_name(sheet_name, available_sheets) if matched_sheet_name: @@ -591,9 +654,11 @@ def _resolve_sheet_selection( normalized_sheet_name = (sheet_name or '').strip() if normalized_sheet_name: - raise ValueError( + raise TabularSelectionError( f"Sheet '{normalized_sheet_name}' was not found in workbook '{blob_name}'. " - f"Available sheets: {available_sheets}." + f"Available sheets: {available_sheets}.", + code='sheet_selection_invalid', + choices=self._table_choices(workbook_metadata), ) normalized_sheet_index = None if sheet_index is None else str(sheet_index).strip() @@ -617,20 +682,59 @@ def _resolve_sheet_selection( # Use pre-selected default sheet if one was set by the orchestration layer override_key = (container_name, blob_name) - if override_key in self._default_sheet_overrides: + if not cell_range and override_key in self._default_sheet_overrides: override_sheet = self._default_sheet_overrides[override_key] matched_override_sheet = self._match_workbook_sheet_name(override_sheet, available_sheets) if matched_override_sheet: return matched_override_sheet, workbook_metadata if require_explicit_sheet: - raise ValueError( + raise TabularSelectionError( f"Workbook '{blob_name}' has multiple sheets: {available_sheets}. " - "Specify sheet_name or sheet_index on analytical calls." + "Specify sheet_name or sheet_index on analytical calls.", + code='sheet_selection_required', + choices=self._table_choices(workbook_metadata), ) return workbook_metadata.get('default_sheet'), workbook_metadata + @staticmethod + def _table_choices(workbook_metadata, sheet_name=None): + """Return compact choices rather than a guessed first table.""" + return [ + { + key: copy.deepcopy(table.get(key)) + for key in ('id', 'name', 'sheet', 'range', 'header_row', 'header_status', 'row_count', 'columns') + } + for table in workbook_metadata.get('tables') or [] + if sheet_name is None or table.get('sheet') == sheet_name + ] + + @staticmethod + def _tabular_error_payload(error): + """Keep validation actionable without returning SDK or provider messages.""" + log_event( + '[TABULAR_PROCESSING_PLUGIN] Tabular operation could not complete.', + level=logging.WARNING, + extra={'exception_type': type(error).__name__}, + ) + if isinstance(error, TabularSelectionError): + return { + 'error': error.public_message, 'error_code': error.code, + 'selection_required': True, 'table_choices': error.choices, + } + if isinstance(error, TabularSavedValueError): + return {'error': error.public_message, 'error_code': 'formula_cache_missing'} + if isinstance(error, (PermissionError, ScreeningError)): + return { + 'error': 'This tabular source is unavailable or is no longer authorized.', + 'error_code': 'tabular_source_unavailable', + } + return { + 'error': 'Unable to analyze this tabular source. Check the selection, column names, and query, then try again.', + 'error_code': 'tabular_analysis_failed', + } + def _match_workbook_sheet_name(self, requested_sheet_name: Optional[str], available_sheets: List[str]) -> Optional[str]: """Match a workbook sheet name while tolerating trailing whitespace and case drift.""" raw_sheet_name = None if requested_sheet_name is None else str(requested_sheet_name) @@ -698,7 +802,18 @@ def _build_row_output_records(self, row_frame, selected_columns): ] output_records = [] - for _, row in row_frame.iterrows(): + table = row_frame.attrs.get('excel_table') + if table is not None and '_excel_source' in row_frame.columns: + raise TabularSelectionError( + "The selected source uses the reserved Excel provenance field _excel_source.", + code='reserved_excel_column', + ) + self._require_saved_values(row_frame, selected_column_names) + source_rows = row_frame.attrs.get('excel_row_numbers') or () + source_tables = row_frame.attrs.get('excel_row_table_ids') or () + source_ranges = row_frame.attrs.get('excel_table_ranges') or {} + source_offset = row_frame.attrs.get('excel_index_offset', 0) + for row_index, row in row_frame.iterrows(): row_payload = { str(column_name): row.get(column_name) for column_name in selected_column_names @@ -715,6 +830,14 @@ def _build_row_output_records(self, row_frame, selected_columns): row_payload['_related_document_reference_values'] = merged_reference_values else: row_payload['_related_document_reference_values'] = related_document_reference_values + if table is not None: + ordinal = int(row_index) - source_offset + table_id = source_tables[ordinal] if 0 <= ordinal < len(source_tables) else table['id'] + row_payload['_excel_source'] = { + 'sheet': table['sheet'], 'table_id': table_id, + 'range': source_ranges.get(table_id, table['range']), + 'row': source_rows[ordinal] if 0 <= ordinal < len(source_rows) else None, + } output_records.append(row_payload) return output_records @@ -778,7 +901,7 @@ def _build_tabular_row_page_payload( safe_max_chars = int(max_chars or self.ROW_OUTPUT_SAFE_CHAR_LIMIT) requested_return_columns = self._parse_optional_column_list_argument(return_columns) return_columns_requested = return_columns is not None and str(return_columns).strip().casefold() not in {'', '*', 'all', 'all_columns', 'all columns'} - row_frame = pandas.DataFrame(list(rows or [])) + row_frame = rows.copy() if isinstance(rows, pandas.DataFrame) else pandas.DataFrame(list(rows or [])) total_count = max(0, int(total_row_count or 0)) if row_frame.empty: @@ -872,6 +995,9 @@ def _filter_rows_across_sheets( max_rows: int = 100, start_row: int = 0, return_columns=None, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> Optional[str]: """Search for matching rows across all sheets that contain the requested column. @@ -887,6 +1013,7 @@ def _filter_rows_across_sheets( return None combined_results = [] + parsed_return_columns = self._parse_optional_column_list_argument(return_columns) sheets_searched = [] sheets_matched = [] total_matches = 0 @@ -899,6 +1026,8 @@ def _filter_rows_across_sheets( container_name, blob_name, sheet_name=sheet, + require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -916,6 +1045,8 @@ def _filter_rows_across_sheets( additional_filter_value=additional_filter_value, normalize_match=normalize_match, ) + except TabularSavedValueError: + raise except (KeyError, ValueError): continue @@ -936,7 +1067,7 @@ def _filter_rows_across_sheets( if remaining_capacity > 0: filtered = filtered_df.iloc[skip_remaining:skip_remaining + remaining_capacity] skip_remaining = 0 - for row in filtered.to_dict(orient='records'): + for row in self._build_row_output_records(filtered, parsed_return_columns or list(filtered.columns)): row['_sheet'] = sheet combined_results.append(row) else: @@ -992,6 +1123,9 @@ def _search_rows_across_sheets( normalize_match: bool = False, max_rows: int = 100, start_row: int = 0, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> Optional[str]: """Search rows across worksheets when the relevant text column is unknown or broad.""" workbook_metadata = self._get_workbook_metadata(container_name, blob_name) @@ -1021,6 +1155,8 @@ def _search_rows_across_sheets( container_name, blob_name, sheet_name=sheet, + require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -1040,7 +1176,7 @@ def _search_rows_across_sheets( continue except Exception as query_error: return json.dumps({ - 'error': f"Query/filter error: {query_error}", + **self._tabular_error_payload(query_error), 'filename': filename, 'selected_sheet': 'ALL (cross-sheet search)', }, indent=2, default=str) @@ -1061,7 +1197,7 @@ def _search_rows_across_sheets( continue except ValueError as search_error: return json.dumps({ - 'error': str(search_error), + **self._tabular_error_payload(search_error), 'filename': filename, 'selected_sheet': 'ALL (cross-sheet search)', }, indent=2, default=str) @@ -1152,6 +1288,9 @@ def _lookup_value_across_sheets( normalize_match: bool = False, max_rows: int = 25, start_row: int = 0, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> Optional[str]: """Look up matching rows across all sheets that contain the lookup column. @@ -1180,12 +1319,15 @@ def _lookup_value_across_sheets( container_name, blob_name, sheet_name=sheet, + require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) if lookup_column not in df.columns: continue + self._require_saved_values(df, [lookup_column]) sheets_searched.append(sheet) try: mask = self._build_series_match_mask( @@ -1206,6 +1348,8 @@ def _lookup_value_across_sheets( if sheet_matches == 0: continue + if target_column and target_column in df.columns: + self._require_saved_values(df[mask], [target_column]) sheets_matched.append(sheet) total_matches += sheet_matches if skip_remaining >= sheet_matches: @@ -1216,16 +1360,20 @@ def _lookup_value_across_sheets( if remaining_capacity > 0: matched_df = df[mask].iloc[skip_remaining:skip_remaining + remaining_capacity] skip_remaining = 0 + matched_records = self._build_row_output_records(matched_df, list(matched_df.columns)) if target_column and target_column in df.columns: - for _, row in matched_df.iterrows(): - combined_results.append({ + for row in matched_records: + result = { '_sheet': sheet, lookup_column: row[lookup_column], target_column: row[target_column], - '_full_row': {str(k): v for k, v in row.to_dict().items()}, - }) + '_full_row': row, + } + if '_excel_source' in row: + result['_excel_source'] = row['_excel_source'] + combined_results.append(result) else: - for row in matched_df.to_dict(orient='records'): + for row in matched_records: row['_sheet'] = sheet combined_results.append(row) else: @@ -1269,6 +1417,9 @@ def _query_tabular_data_across_sheets( max_rows: int = 100, start_row: int = 0, return_columns=None, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> Optional[str]: """Execute a pandas query expression across all sheets of a multi-sheet workbook. @@ -1284,20 +1435,26 @@ def _query_tabular_data_across_sheets( return None combined_results = [] + parsed_return_columns = self._parse_optional_column_list_argument(return_columns) sheets_searched = [] sheets_matched = [] total_matches = 0 query_errors = [] skip_remaining = max(0, int(start_row or 0)) requested_max_rows = max(1, int(max_rows or 100)) + source_row_offset = 0 for sheet in available_sheets: df = self._read_tabular_blob_to_dataframe( container_name, blob_name, sheet_name=sheet, + require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) + df.index = range(source_row_offset, source_row_offset + len(df)) + df.attrs['excel_index_offset'] = source_row_offset try: result_df, _ = self._apply_query_expression_with_fallback( @@ -1305,13 +1462,16 @@ def _query_tabular_data_across_sheets( query_expression=query_expression, normalize_match=False, ) + except TabularSavedValueError: + raise except Exception as query_error: query_errors.append({ 'sheet_name': sheet, - 'error': str(query_error), + 'error': self._tabular_error_payload(query_error)['error'], }) continue + source_row_offset += len(df) sheets_searched.append(sheet) sheet_matches = len(result_df) if sheet_matches == 0: @@ -1325,7 +1485,8 @@ def _query_tabular_data_across_sheets( remaining_capacity = max(0, requested_max_rows - len(combined_results)) if remaining_capacity > 0: - for row in result_df.iloc[skip_remaining:skip_remaining + remaining_capacity].to_dict(orient='records'): + page = result_df.iloc[skip_remaining:skip_remaining + remaining_capacity] + for row in self._build_row_output_records(page, parsed_return_columns or list(page.columns)): row['_sheet'] = sheet combined_results.append(row) skip_remaining = 0 @@ -1383,7 +1544,17 @@ def _query_tabular_data_across_sheets( "total_matches": total_matches, } response_payload.update(row_page_payload) - return json.dumps(response_payload, indent=2, default=str) + return PluginInvocationResult( + json.dumps(response_payload, indent=2, default=str), + internal_metadata=self._build_tabular_generated_export_internal_metadata( + container_name=container_name, blob_path=blob_name, filename=filename, + source_function='query_tabular_data', query_expression=query_expression, + return_columns=return_columns, expected_row_count=total_matches, + sheet_names=sheets_searched, + include_sheet_column=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), + ), + ) def _count_rows_across_sheets( self, @@ -1398,6 +1569,9 @@ def _count_rows_across_sheets( additional_filter_value=None, query_expression: Optional[str] = None, normalize_match: bool = False, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> Optional[str]: """Count rows across all worksheets that satisfy optional filters or queries.""" workbook_metadata = self._get_workbook_metadata(container_name, blob_name) @@ -1419,6 +1593,8 @@ def _count_rows_across_sheets( container_name, blob_name, sheet_name=sheet, + require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -1436,11 +1612,13 @@ def _count_rows_across_sheets( ) except KeyError: continue + except TabularSavedValueError: + raise except Exception as query_error: if query_expression: query_errors.append({ 'sheet_name': sheet, - 'error': str(query_error), + 'error': self._tabular_error_payload(query_error)['error'], }) continue @@ -1502,6 +1680,9 @@ def _get_distinct_values_across_sheets( url_path_segments: Optional[int] = None, normalize_match: bool = False, max_values: int = 100, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> Optional[str]: """Return distinct values for a column across all worksheets that contain it.""" workbook_metadata = self._get_workbook_metadata(container_name, blob_name) @@ -1525,6 +1706,8 @@ def _get_distinct_values_across_sheets( container_name, blob_name, sheet_name=sheet, + require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) if column not in df.columns: continue @@ -1543,16 +1726,19 @@ def _get_distinct_values_across_sheets( ) except KeyError: continue + except TabularSavedValueError: + raise except Exception as query_error: if query_expression: query_errors.append({ 'sheet_name': sheet, - 'error': str(query_error), + 'error': self._tabular_error_payload(query_error)['error'], }) continue sheets_searched.append(sheet) applied_filters = sheet_filters or applied_filters + self._require_saved_values(filtered_df, [column]) sheet_distinct_values, sheet_matched_cells, sheet_extracted_matches = self._collect_distinct_display_values( filtered_df[column], normalize_match=normalize_match, @@ -1641,34 +1827,49 @@ def _evaluate_related_value_membership( max_rows: int = 100, start_row: int = 0, return_columns=None, + source_table_id: Optional[str] = None, + source_cell_range: Optional[str] = None, + source_header_row: Optional[int] = None, + target_table_id: Optional[str] = None, + target_cell_range: Optional[str] = None, + target_header_row: Optional[int] = None, + source_location=None, + target_location=None, + include_rows: bool = True, ) -> dict: """Evaluate a semi-join between a source cohort and a target fact worksheet.""" - source_sheet, workbook_metadata = self._resolve_sheet_selection( - container_name, - blob_name, + source_container, source_blob = source_location or (container_name, blob_name) + target_container, target_blob = target_location or (container_name, blob_name) + source_sheet, source_workbook_metadata = self._resolve_sheet_selection( + source_container, + source_blob, sheet_name=source_sheet_name, sheet_index=source_sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(source_table_id, source_cell_range, source_header_row), ) target_sheet, workbook_metadata = self._resolve_sheet_selection( - container_name, - blob_name, + target_container, + target_blob, sheet_name=target_sheet_name, sheet_index=target_sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(target_table_id, target_cell_range, target_header_row), ) source_df = self._read_tabular_blob_to_dataframe( - container_name, - blob_name, + source_container, + source_blob, sheet_name=source_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(source_table_id, source_cell_range, source_header_row), ) target_df = self._read_tabular_blob_to_dataframe( - container_name, - blob_name, + target_container, + target_blob, sheet_name=target_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(target_table_id, target_cell_range, target_header_row), ) source_df = self._try_numeric_conversion(source_df) @@ -1689,10 +1890,10 @@ def _evaluate_related_value_membership( for required_column in source_required_columns: if required_column not in source_df.columns: return self._build_missing_column_error_payload( - container_name, - blob_name, + source_container, + source_blob, filename, - workbook_metadata, + source_workbook_metadata, source_sheet, required_column, related_columns=[source_value_column, source_alias_column, source_filter_column], @@ -1702,8 +1903,8 @@ def _evaluate_related_value_membership( for required_column in target_required_columns: if required_column not in target_df.columns: return self._build_missing_column_error_payload( - container_name, - blob_name, + target_container, + target_blob, filename, workbook_metadata, target_sheet, @@ -1724,10 +1925,10 @@ def _evaluate_related_value_membership( except KeyError as missing_source_column_error: missing_source_column = str(missing_source_column_error).strip("'") return self._build_missing_column_error_payload( - container_name, - blob_name, + source_container, + source_blob, filename, - workbook_metadata, + source_workbook_metadata, source_sheet, missing_source_column, related_columns=[source_value_column, source_alias_column], @@ -1735,9 +1936,9 @@ def _evaluate_related_value_membership( ) except Exception as source_filter_error: return { - 'error': f"Source filter/query error on sheet '{source_sheet}': {source_filter_error}", + **self._tabular_error_payload(source_filter_error), 'filename': filename, - 'selected_sheet': source_sheet if workbook_metadata.get('is_workbook') else None, + 'selected_sheet': source_sheet if source_workbook_metadata.get('is_workbook') else None, } try: @@ -1752,8 +1953,8 @@ def _evaluate_related_value_membership( except KeyError as missing_target_column_error: missing_target_column = str(missing_target_column_error).strip("'") return self._build_missing_column_error_payload( - container_name, - blob_name, + target_container, + target_blob, filename, workbook_metadata, target_sheet, @@ -1763,11 +1964,17 @@ def _evaluate_related_value_membership( ) except Exception as target_filter_error: return { - 'error': f"Target filter/query error on sheet '{target_sheet}': {target_filter_error}", + **self._tabular_error_payload(target_filter_error), 'filename': filename, 'selected_sheet': target_sheet if workbook_metadata.get('is_workbook') else None, } + self._require_saved_values( + filtered_source_df, [column for column in (source_value_column, source_alias_column) if column], + ) + self._require_saved_values( + filtered_target_df, [column for column in (target_match_column, target_alias_column) if column], + ) source_member_map = {} variant_to_source_keys = {} for _, source_row in filtered_source_df.iterrows(): @@ -1809,7 +2016,7 @@ def _evaluate_related_value_membership( matched_target_rows = [] matched_target_value_variants = set() - for _, target_row in filtered_target_df.iterrows(): + for target_index, target_row in filtered_target_df.iterrows(): target_value_variants = set() for column_name in [target_match_column, target_alias_column]: if not column_name: @@ -1837,12 +2044,16 @@ def _evaluate_related_value_membership( for source_key in matched_source_keys: source_member_map[source_key]['matched_target_row_count'] += 1 - matched_row_payload = target_row.to_dict() - matched_row_payload['_matched_on'] = matched_variants[:3] - matched_row_payload['_matched_source_values'] = [ - source_member_map[source_key]['display_value'] - for source_key in matched_source_keys[:3] - ] + matched_row_payload = None + if include_rows: + row_frame = filtered_target_df.loc[[target_index]] + selected_columns = self._parse_optional_column_list_argument(return_columns) or list(row_frame.columns) + matched_row_payload = self._build_row_output_records(row_frame, selected_columns)[0] + matched_row_payload['_matched_on'] = matched_variants[:3] + matched_row_payload['_matched_source_values'] = [ + source_member_map[source_key]['display_value'] + for source_key in matched_source_keys[:3] + ] matched_target_rows.append(matched_row_payload) matched_source_values = [] @@ -1867,7 +2078,7 @@ def _evaluate_related_value_membership( matched_target_row_count = len(matched_target_rows) start, limit = self._parse_row_page_arguments(start_row, max_rows) - paged_matched_target_rows = matched_target_rows[start:start + limit] + paged_matched_target_rows = matched_target_rows[start:start + limit] if include_rows else [] row_page_payload = self._build_tabular_row_page_payload( paged_matched_target_rows, matched_target_row_count, @@ -1879,6 +2090,11 @@ def _evaluate_related_value_membership( response_payload = { 'filename': filename, 'selected_sheet': target_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(target_df), + 'source_selection': self._table_result_metadata(source_df), + 'target_selection': self._table_result_metadata(target_df), + 'source_filename': source_blob.rsplit('/', 1)[-1], + 'target_filename': target_blob.rsplit('/', 1)[-1], 'relationship_type': 'set_membership', 'source_sheet': source_sheet, 'source_value_column': source_value_column, @@ -2347,6 +2563,7 @@ def _search_dataframe_rows( else: resolved_search_columns = list(df.columns) + self._require_saved_values(df, resolved_search_columns) resolved_return_columns = [ column_name for column_name in (requested_return_columns or []) if column_name in df.columns @@ -2377,7 +2594,10 @@ def _search_dataframe_rows( pass paged_matched_df = matched_df.iloc[normalized_start_row:normalized_start_row + normalized_max_rows] - for row_index, row in paged_matched_df.iterrows(): + output_records = self._build_row_output_records( + paged_matched_df, resolved_return_columns or list(paged_matched_df.columns), + ) + for (row_index, row), row_payload in zip(paged_matched_df.iterrows(), output_records): row_matched_columns = [] for column_name in resolved_search_columns: if not bool(column_masks[column_name].loc[row_index]): @@ -2388,22 +2608,6 @@ def _search_dataframe_rows( seen_matched_columns.add(lowered_column) matched_columns.append(column_name) - if resolved_return_columns: - row_payload = { - column_name: row.get(column_name) - for column_name in resolved_return_columns - } - related_document_reference_values = self._build_related_document_reference_values( - row, - excluded_columns=resolved_return_columns, - ) - if related_document_reference_values: - row_payload['_related_document_reference_values'] = related_document_reference_values - else: - row_payload = { - str(key): value for key, value in row.to_dict().items() - } - row_payload['_matched_columns'] = row_matched_columns row_payload['_matched_values'] = { column_name: row.get(column_name) @@ -2697,6 +2901,7 @@ def _apply_query_expression_with_fallback( if not query_expression: return df, False + self._require_saved_query_values(df, query_expression) try: return df.query(query_expression), False except Exception as query_error: @@ -2768,6 +2973,7 @@ def _apply_optional_dataframe_filters( ) current_filter_operator = filter_spec['operator'] or 'equals' + self._require_saved_values(filtered_df, [current_filter_column]) mask = self._build_series_match_mask( filtered_df[current_filter_column], current_filter_operator, @@ -3033,7 +3239,11 @@ def _build_sheet_schema_summary(self, df: pandas.DataFrame, sheet_name: Optional 'null_counts': df.isnull().sum().to_dict(), } - def _build_workbook_schema_summary(self, container_name: str, blob_name: str, filename: str, preview_rows: int = 3) -> dict: + def _build_workbook_schema_summary( + self, container_name: str, blob_name: str, filename: str, preview_rows: int = 3, + sheet_name: Optional[str] = None, table_id: Optional[str] = None, + cell_range: Optional[str] = None, header_row: Optional[int] = None, + ) -> dict: """Build a workbook-aware schema summary for prompt preload and file description.""" workbook_metadata = self._get_workbook_metadata(container_name, blob_name) if not workbook_metadata.get('is_workbook'): @@ -3046,6 +3256,85 @@ def _build_workbook_schema_summary(self, container_name: str, blob_name: str, fi 'sheet_count': 0, }) return summary + if workbook_metadata.get('workbook_manifest'): + data = self._download_tabular_blob_bytes(container_name, blob_name) + extension = '.xls' if blob_name.lower().endswith('.xls') else '.xlsm' if blob_name.lower().endswith('.xlsm') else '.xlsx' + per_sheet_schemas, samples = {}, {} + with ExcelWorkbookReader(data, extension=extension) as reader: + reader.use_manifest(workbook_metadata['workbook_manifest']) + for name in workbook_metadata['sheet_names']: + if sheet_name and name != sheet_name: + continue + table_schemas = [] + tables = workbook_metadata['tables_by_sheet'].get(name, []) + if table_id or cell_range or header_row is not None: + tables = self._select_excel_tables( + reader, workbook_metadata, name, table_id, cell_range, header_row, + require_header=False, allow_heterogeneous=True, + ) + previews = reader.read_table_previews(tables, max_rows=max(1, min(preview_rows, 20))) + for table in tables: + preview_records, preview_bytes, text_truncated = [], 0, False + for record in previews[table['id']]: + values = [] + for value in record['values'][:EXCEL_PREVIEW_MAX_COLUMNS]: + if isinstance(value, str) and len(value) > 4000: + value = value[:4000] + ' [preview shortened]' + text_truncated = True + values.append(value) + row_bytes = len(json.dumps(values, ensure_ascii=False, default=str).encode('utf-8')) + if preview_bytes + row_bytes > EXCEL_PREVIEW_MAX_BYTES: + break + preview_records.append({'row': record['row'], 'values': values}) + preview_bytes += row_bytes + columns = [column['name'] for column in table['columns'][:EXCEL_PREVIEW_MAX_COLUMNS]] + sample = pandas.DataFrame([record['values'] for record in preview_records], columns=columns) + schema = self._build_sheet_schema_summary(sample, name, preview_rows=preview_rows) + schema.update({ + 'row_count': table['row_count'], 'table_id': table['id'], + 'table_name': table['name'], 'table_range': table['range'], + 'header_row': table['header_row'], 'header_status': table['header_status'], + 'origin': table['origin'], 'null_counts_scope': 'preview', + 'selected_table': table['id'], + 'preview_row_numbers': [record['row'] for record in preview_records], + 'columns_truncated': len(table['columns']) > len(columns), + 'cell_text_truncated': text_truncated, + 'preview_limited': len(preview_records) < table['row_count'], + 'selection_required': table['header_status'] == 'ambiguous', + }) + table_schemas.append(schema) + if len(workbook_metadata['tables_by_sheet'].get(name, [])) == 1: + samples[name] = sample + per_sheet_schemas[name] = ( + {**table_schemas[0], 'table_count': 1, 'tables': table_schemas} + if len(table_schemas) == 1 else { + 'selected_sheet': name, 'table_count': len(table_schemas), + 'tables': table_schemas, 'columns': [], + 'selection_required': len(table_schemas) > 1 or any( + table['selection_required'] for table in table_schemas + ), + } + ) + relationship_metadata = self._build_workbook_relationship_metadata(samples) + summary = { + 'filename': filename, 'is_workbook': True, + 'sheet_names': workbook_metadata['sheet_names'], + 'sheet_count': workbook_metadata['sheet_count'], + 'table_count': workbook_metadata['table_count'], 'selected_sheet': sheet_name, + 'per_sheet_schemas': per_sheet_schemas, + 'sheet_role_hints': relationship_metadata.get('sheet_role_hints', {}), + 'relationship_hints': relationship_metadata.get('relationship_hints', []), + 'relationship_hints_scope': 'bounded table previews, not full-data validation', + 'table_choices': self._table_choices(workbook_metadata, sheet_name), + 'selection_required': any( + schema.get('selection_required') for schema in per_sheet_schemas.values() + ), + } + if len(per_sheet_schemas) == 1: + sheet_schema = next(iter(per_sheet_schemas.values())) + if sheet_schema.get('table_count') == 1: + summary.update(sheet_schema) + return summary per_sheet_schemas = {} sheet_dataframes = {} @@ -3105,12 +3394,17 @@ def _find_candidate_sheets_for_columns( if normalized_exclude_sheet and sheet_name.lower() == normalized_exclude_sheet: continue - dataframe = self._read_tabular_blob_to_dataframe( - container_name, - blob_name, - sheet_name=sheet_name, - ) - normalized_columns = {str(column).strip().lower() for column in dataframe.columns} + if workbook_metadata.get('workbook_manifest'): + normalized_columns = { + str(column['name']).strip().lower() + for table in workbook_metadata.get('tables_by_sheet', {}).get(sheet_name, []) + for column in table['columns'] + } + else: + dataframe = self._read_tabular_blob_to_dataframe( + container_name, blob_name, sheet_name=sheet_name, + ) + normalized_columns = {str(column).strip().lower() for column in dataframe.columns} matched_columns = [ target_column for target_column in normalized_targets if target_column in normalized_columns @@ -3142,6 +3436,11 @@ def _build_missing_column_error_payload( 'missing_column': missing_column, 'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None, } + if workbook_metadata.get('workbook_manifest'): + payload['candidate_tables'] = [ + table for table in self._table_choices(workbook_metadata) + if any(str(column['name']).casefold() == str(missing_column).casefold() for column in table['columns']) + ] if workbook_metadata.get('is_workbook') and workbook_metadata.get('sheet_count', 0) > 1: candidate_sheets = self._find_candidate_sheets_for_columns( @@ -3159,6 +3458,94 @@ def _build_missing_column_error_payload( return payload + @staticmethod + def _normalize_table_selectors(table_id=None, cell_range=None, header_row=None): + table_id = str(table_id or '').strip() or None + if table_id and table_id.casefold() == 'all': + table_id = 'all' + cell_range = str(cell_range or '').strip() or None + if table_id and cell_range: + raise TabularSelectionError( + "Specify table_id or cell_range, not both.", code='table_selection_invalid', + ) + if header_row is not None: + if isinstance(header_row, bool) or not str(header_row).isascii() or not str(header_row).isdigit(): + raise TabularSelectionError( + "header_row must be an actual worksheet row number or zero.", + code='header_selection_invalid', + ) + header_row = int(header_row) + if cell_range and header_row is None: + raise TabularSelectionError( + "Specify header_row for an explicit range; zero means no header.", + code='header_selection_required', + ) + return table_id, cell_range, header_row + + def _table_selector_kwargs(self, table_id=None, cell_range=None, header_row=None): + normalized = self._normalize_table_selectors(table_id, cell_range, header_row) + return { + key: value for key, value in zip(('table_id', 'cell_range', 'header_row'), normalized) + if value is not None + } + + def _select_excel_tables( + self, reader, workbook_metadata, sheet_name, table_id=None, cell_range=None, + header_row=None, *, allow_heterogeneous=False, require_header=True, + ): + """Resolve explicit choices identically for foreground analysis and replay.""" + table_id, cell_range, header_row = self._normalize_table_selectors(table_id, cell_range, header_row) + available = workbook_metadata.get('tables_by_sheet', {}).get(sheet_name, []) + choices = self._table_choices(workbook_metadata, sheet_name) + if not available and not cell_range and table_id is None: + return [] + if table_id == 'all': + if cell_range or header_row is not None: + raise TabularSelectionError( + "Select a single table or range for an explicit header override.", + code='table_selection_invalid', choices=choices, + ) + selected = [reader.select_table(table['id'], sheet_name) for table in available] + else: + if table_id is None and not cell_range and len(available) != 1: + raise TabularSelectionError( + "This worksheet contains multiple tables. Select table_id, or an explicit cell_range and header_row.", + choices=choices, + ) + try: + selected = [reader.select_table( + table_id=table_id, sheet_name=sheet_name, cell_range=cell_range, header_row=header_row, + )] + except ValueError as error: + raise TabularSelectionError( + "The table, worksheet, range, or header selection is invalid. Choose a discovered table or a valid range.", + code='table_selection_invalid', choices=choices, + ) from error + if require_header and any(table['header_status'] == 'ambiguous' for table in selected): + raise TabularSelectionError( + "The table header is ambiguous. Supply header_row using the actual worksheet row, or zero for no header.", + code='header_selection_required', choices=choices, + ) + if not allow_heterogeneous and selected: + columns = [column['name'] for column in selected[0]['columns']] + if any([column['name'] for column in table['columns']] != columns for table in selected): + raise TabularSelectionError( + "The selected tables have different schemas. Select one table for this analytical operation.", + code='table_schema_mismatch', choices=choices, + ) + return selected + + @staticmethod + def _table_result_metadata(dataframe): + table = dataframe.attrs.get('excel_table') + if table is None: + return {} + return { + 'selected_table': table['id'], 'table_id': table['id'], + 'table_name': table.get('name'), 'table_range': table['range'], + 'header_row': table.get('header_row'), 'header_status': table.get('header_status'), + } + def _read_tabular_blob_to_dataframe( self, container_name: str, @@ -3166,21 +3553,36 @@ def _read_tabular_blob_to_dataframe( sheet_name: Optional[str] = None, sheet_index: Optional[str] = None, require_explicit_sheet: bool = False, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> pandas.DataFrame: """Download a blob and read it into a pandas DataFrame. Uses per-instance cache.""" self._assert_blob_screening_access(container_name, blob_name) + table_id, cell_range, header_row = self._normalize_table_selectors(table_id, cell_range, header_row) resolved_sheet_name, workbook_metadata = self._resolve_sheet_selection( container_name, blob_name, sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=require_explicit_sheet, + table_id=table_id, ) sheet_cache_key = resolved_sheet_name or '__default__' - cache_key = (container_name, blob_name, sheet_cache_key) + if not workbook_metadata.get('is_workbook') and any( + value is not None for value in (table_id, cell_range, header_row) + ): + raise TabularSelectionError( + "Table, range, and header selectors apply only to Excel workbooks.", + code='table_selection_invalid', + ) + cache_key = ( + container_name, blob_name, workbook_metadata.get('blob_etag'), + sheet_cache_key, table_id, cell_range, header_row, + ) if cache_key in self._df_cache: log_event( - f"[TabularProcessingPlugin] Cache hit for {blob_name}" + f"[TABULAR_PROCESSING_PLUGIN] Cache hit for {blob_name}" + (f" [{resolved_sheet_name}]" if resolved_sheet_name else ''), level=logging.DEBUG, ) @@ -3191,22 +3593,42 @@ def _read_tabular_blob_to_dataframe( name_lower = blob_name.lower() if name_lower.endswith('.csv'): df = read_tabular_csv(io.BytesIO(data), keep_default_na=False, dtype=str) - elif name_lower.endswith('.xlsx') or name_lower.endswith('.xlsm'): - df = pandas.read_excel( - io.BytesIO(data), - engine='openpyxl', - keep_default_na=False, - dtype=str, - sheet_name=resolved_sheet_name, - ) - elif name_lower.endswith('.xls'): - df = pandas.read_excel( - io.BytesIO(data), - engine='xlrd', - keep_default_na=False, - dtype=str, - sheet_name=resolved_sheet_name, - ) + elif self._get_excel_engine(blob_name): + extension = '.xls' if name_lower.endswith('.xls') else '.xlsm' if name_lower.endswith('.xlsm') else '.xlsx' + with ExcelWorkbookReader(data, extension=extension) as reader: + reader.use_manifest(workbook_metadata['workbook_manifest']) + selected_tables = self._select_excel_tables( + reader, workbook_metadata, resolved_sheet_name, table_id, cell_range, header_row, + ) + if not selected_tables: + df = pandas.DataFrame() + else: + columns = [column['name'] for column in selected_tables[0]['columns']] + rows, source_rows, source_tables, missing = [], [], [], {} + for table in selected_tables: + for row_number, cells in reader.iter_table_rows(table): + ordinal = len(rows) + rows.append([ + '' if cell['value'] is None else str(cell['value']) + for cell in cells + ]) + source_rows.append(row_number) + source_tables.append(table['id']) + for column, cell in zip(columns, cells): + if cell['value_status'] == 'cache_missing': + missing.setdefault(column, set()).add(ordinal) + df = pandas.DataFrame(rows, columns=columns) + table_context = selected_tables[0] if len(selected_tables) == 1 else { + 'id': 'all', 'sheet': resolved_sheet_name, 'range': 'multiple selected tables', + } + df.attrs.update({ + 'excel_table': table_context, 'excel_row_numbers': tuple(source_rows), + 'excel_row_table_ids': tuple(source_tables), + 'excel_tables': copy.deepcopy(selected_tables), + 'excel_table_ranges': {table['id']: table['range'] for table in selected_tables}, + 'excel_missing_formula_caches': missing, + }) + self._last_table_reads[(container_name, blob_name, resolved_sheet_name)] = copy.deepcopy(selected_tables) else: raise ValueError(f"Unsupported tabular file type: {blob_name}") @@ -3214,13 +3636,42 @@ def _read_tabular_blob_to_dataframe( self._assert_blob_screening_access(container_name, blob_name) self._df_cache[cache_key] = df log_event( - f"[TabularProcessingPlugin] Cached DataFrame for {blob_name}" + f"[TABULAR_PROCESSING_PLUGIN] Cached DataFrame for {blob_name}" + (f" [{resolved_sheet_name}]" if resolved_sheet_name else '') + f" ({len(df)} rows)", level=logging.DEBUG, ) return df.copy() + @staticmethod + def _require_saved_values(dataframe, columns): + missing = dataframe.attrs.get('excel_missing_formula_caches') or {} + if not missing: + return + offset = dataframe.attrs.get('excel_index_offset', 0) + selected_indices = {int(index) - offset for index in dataframe.index} + for column in columns: + if selected_indices.intersection(missing.get(column, ())): + raise TabularSavedValueError() + + def _require_saved_query_values(self, dataframe, query_expression): + """Ignore quoted literals and check the columns actually read by the query.""" + if not query_expression or not dataframe.attrs.get('excel_missing_formula_caches'): + return + expression = str(query_expression) + referenced = set(re.findall(r'`([^`]+)`', expression)) + expression = re.sub(r'`[^`]+`', ' ', expression) + try: + referenced.update( + token.string for token in tokenize.generate_tokens(io.StringIO(expression).readline) + if token.type == tokenize.NAME + ) + except (tokenize.TokenError, IndentationError): + referenced.update(dataframe.columns) + self._require_saved_values( + dataframe, [column for column in dataframe.columns if str(column) in referenced], + ) + def _try_numeric_conversion(self, df: pandas.DataFrame) -> pandas.DataFrame: """Attempt to convert string columns to numeric where possible.""" for col in df.columns: @@ -3485,9 +3936,13 @@ def _resolve_blob_location_with_fallback(self, user_id: str, conversation_id: st override = self._get_resolved_blob_location_override(source, filename) if override and self._is_authorized_blob_location(override[0], override[1], authorized_context): - override = resolve_available_blob_location(*override, user_id=user_id) - self._assert_blob_screening_access(*override) - return override + try: + resolved_override = resolve_available_blob_location(*override, user_id=user_id) + self._assert_blob_screening_access(*resolved_override) + return resolved_override + except (ScreeningError, PermissionError): + self._evict_screened_blob_cache(*override) + raise attempts = [] @@ -3518,6 +3973,7 @@ def _resolve_blob_location_with_fallback(self, user_id: str, conversation_id: st log_event(f"[TABULAR_PROCESSING_PLUGIN] Found blob at {container}/{blob_path}", level=logging.DEBUG) return container, blob_path except (ScreeningError, PermissionError): + self._evict_screened_blob_cache(container, blob_path) raise except Exception: continue @@ -3538,8 +3994,13 @@ def build_generated_export_query_descriptor( group_id: Optional[str] = None, public_workspace_id: Optional[str] = None, expected_row_count: int = 0, + sheet_name: Optional[str] = None, + sheet_index: Optional[str] = None, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, ) -> dict: - """Resolve an authorized, version-pinned CSV query for durable export replay.""" + """Resolve an authorized, version-pinned table query for durable export replay.""" container_name, blob_path = self._resolve_blob_location_with_fallback( user_id, conversation_id, @@ -3548,6 +4009,11 @@ def build_generated_export_query_descriptor( group_id=group_id, public_workspace_id=public_workspace_id, ) + selected_sheet, _ = self._resolve_sheet_selection( + container_name, blob_path, sheet_name=sheet_name, sheet_index=sheet_index, + require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), + ) return self._build_generated_export_query_descriptor_from_location( container_name=container_name, blob_path=blob_path, @@ -3555,6 +4021,9 @@ def build_generated_export_query_descriptor( query_expression=query_expression, return_columns=return_columns, expected_row_count=expected_row_count, + selected_sheet=selected_sheet, + sheet_names=[selected_sheet] if selected_sheet else None, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) def _build_generated_export_query_descriptor_from_location( @@ -3569,6 +4038,11 @@ def _build_generated_export_query_descriptor_from_location( source_function: str = 'query_tabular_data', selected_sheet: Optional[str] = None, sheet_names: Optional[List[str]] = None, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, + include_sheet_column: bool = False, + numeric_conversion_scope: Optional[str] = None, ) -> dict: """Pin a durable query descriptor to an already-authorized blob location.""" document, _user_id = self._assert_blob_screening_access(container_name, blob_path) @@ -3582,7 +4056,11 @@ def _build_generated_export_query_descriptor_from_location( raise ValueError('Durable source-backed generated exports require a supported tabular source') normalized_query_expression = validate_tabular_csv_query_expression(query_expression) - blob_version = dict(blob_version or self._get_tabular_blob_version(container_name, blob_path)) + table_id, cell_range, header_row = self._normalize_table_selectors(table_id, cell_range, header_row) + current_version = self._get_tabular_blob_version(container_name, blob_path, refresh=True) + if blob_version and blob_version.get('blob_etag') != current_version.get('blob_etag'): + raise ScreeningConflictError() + blob_version = dict(blob_version or current_version) blob_etag = blob_version.get('blob_etag') blob_size = blob_version.get('blob_size') @@ -3617,10 +4095,71 @@ def _build_generated_export_query_descriptor_from_location( if document is not None: descriptor[PROVENANCE_FIELD] = document_provenance(document) if source_format != 'csv': + metadata = self._get_workbook_metadata(container_name, blob_path) + if metadata.get('blob_etag') != blob_etag: + raise ScreeningConflictError() if not normalized_sheet_names: - raise ValueError('Durable workbook replay requires an explicit worksheet scope') + resolved_sheet, _ = self._resolve_sheet_selection( + container_name, blob_path, sheet_name=selected_sheet, + require_explicit_sheet=True, table_id=table_id, + cell_range=cell_range, header_row=header_row, + ) + normalized_sheet_names = [resolved_sheet] + normalized_sheet_names = [ + self._resolve_sheet_selection( + container_name, blob_path, sheet_name=name, require_explicit_sheet=True, + )[0] for name in normalized_sheet_names + ] + if len(set(normalized_sheet_names)) != len(normalized_sheet_names): + raise TabularSelectionError( + "A worksheet may only appear once in a durable table selection.", + code='table_selection_invalid', + ) + data = self._download_tabular_blob_bytes(container_name, blob_path) + selections = [] + with ExcelWorkbookReader(data, extension=f'.{source_format}') as reader: + reader.use_manifest(metadata['workbook_manifest']) + for name in normalized_sheet_names: + selections.extend(self._select_excel_tables( + reader, metadata, name, table_id, cell_range, header_row, + allow_heterogeneous=True, + )) + if numeric_conversion_scope is None: + schemas_by_sheet = {} + for table in selections: + schemas_by_sheet.setdefault(table['sheet'], set()).add( + tuple(column['name'] for column in table['columns']) + ) + numeric_conversion_scope = ( + 'sheet' if table_id == 'all' and all(len(schemas) == 1 for schemas in schemas_by_sheet.values()) + else 'table' + ) + if numeric_conversion_scope not in ('table', 'sheet'): + raise ValueError('The durable numeric conversion scope is invalid.') + descriptor.update({ + 'version': 2, 'selection_semantics': 'excel-tables-v2', + 'workbook_schema_version': EXCEL_WORKBOOK_SCHEMA_VERSION, + 'source_sha256': hashlib.sha256(data).hexdigest(), + 'table_id': table_id, 'cell_range': cell_range, 'header_row': header_row, + 'selected_table': selections[0]['id'] if len(selections) == 1 else table_id, + 'table_selections': copy.deepcopy(selections), + 'source_row_count': sum(table['row_count'] for table in selections), + 'numeric_conversion_scope': numeric_conversion_scope, + }) descriptor['selected_sheet'] = normalized_selected_sheet descriptor['sheet_names'] = normalized_sheet_names + if normalized_selected_sheet is not None: + descriptor['selected_sheet'] = self._match_workbook_sheet_name( + normalized_selected_sheet, normalized_sheet_names, + ) + descriptor['include_sheet_column'] = bool(include_sheet_column) + if self._get_tabular_blob_version(container_name, blob_path, refresh=True)['blob_etag'] != blob_etag: + raise ScreeningConflictError() + elif any(value is not None for value in (table_id, cell_range, header_row)): + raise TabularSelectionError( + "Table, range, and header selectors apply only to Excel workbooks.", + code='table_selection_invalid', + ) return descriptor def _build_generated_export_column_reference(self, column_name: str) -> str: @@ -3788,6 +4327,12 @@ def _build_tabular_generated_export_internal_metadata( return_columns: Optional[str], expected_row_count: int, replay_error: Optional[str] = None, + selected_sheet: Optional[str] = None, + sheet_names: Optional[List[str]] = None, + table_id: Optional[str] = None, + cell_range: Optional[str] = None, + header_row: Optional[int] = None, + include_sheet_column: bool = False, ) -> dict: """Build source authorization plus either a replay descriptor or a safe error.""" blob_version = self._get_tabular_blob_version(container_name, blob_path) @@ -3799,11 +4344,13 @@ def _build_tabular_generated_export_internal_metadata( ), } if replay_error: - internal_metadata['tabular_generated_export_source_error'] = str(replay_error) + internal_metadata['tabular_generated_export_source_error'] = ( + 'This operation cannot be replayed as a bounded row-local query.' + ) return internal_metadata - internal_metadata['tabular_generated_export_source'] = ( - self._build_generated_export_query_descriptor_from_location( + try: + internal_metadata['tabular_generated_export_source'] = self._build_generated_export_query_descriptor_from_location( container_name=container_name, blob_path=blob_path, filename=filename, @@ -3812,8 +4359,22 @@ def _build_tabular_generated_export_internal_metadata( expected_row_count=expected_row_count, blob_version=blob_version, source_function=source_function, + selected_sheet=selected_sheet, sheet_names=sheet_names, + include_sheet_column=include_sheet_column, + numeric_conversion_scope='sheet' if table_id == 'all' else 'table', + **self._table_selector_kwargs(table_id, cell_range, header_row), + ) + except TabularSelectionError: + raise + except ValueError as error: + log_event( + '[TABULAR_PROCESSING_PLUGIN] Query is not available for bounded replay.', + level=logging.DEBUG, debug_only=True, + extra={'exception_type': type(error).__name__}, + ) + internal_metadata['tabular_generated_export_source_error'] = ( + 'This operation cannot be replayed as a bounded row-local query.' ) - ) return internal_metadata def _build_source_authorization_from_location( @@ -3963,7 +4524,7 @@ async def list_tabular_files( 'requested_public_workspace_id': public_workspace_id, }, ) - return json.dumps({"error": str(exc)}) + return json.dumps(self._tabular_error_payload(exc)) user_id = authorized_context['user_id'] conversation_id = authorized_context['conversation_id'] @@ -3990,6 +4551,8 @@ def _sync_work(): "container": storage_account_user_documents_container_name, "sheet_names": workbook_metadata.get('sheet_names', []), "sheet_count": workbook_metadata.get('sheet_count', 0), + "table_count": workbook_metadata.get('table_count', 0), + "table_choices": self._table_choices(workbook_metadata), }) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error listing workspace blobs: {e}", level=logging.WARNING) @@ -4012,6 +4575,8 @@ def _sync_work(): "container": storage_account_personal_chat_container_name, "sheet_names": workbook_metadata.get('sheet_names', []), "sheet_count": workbook_metadata.get('sheet_count', 0), + "table_count": workbook_metadata.get('table_count', 0), + "table_choices": self._table_choices(workbook_metadata), }) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error listing chat blobs: {e}", level=logging.WARNING) @@ -4035,6 +4600,8 @@ def _sync_work(): "container": storage_account_group_documents_container_name, "sheet_names": workbook_metadata.get('sheet_names', []), "sheet_count": workbook_metadata.get('sheet_count', 0), + "table_count": workbook_metadata.get('table_count', 0), + "table_choices": self._table_choices(workbook_metadata), }) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error listing group blobs: {e}", level=logging.WARNING) @@ -4058,6 +4625,8 @@ def _sync_work(): "container": storage_account_public_documents_container_name, "sheet_names": workbook_metadata.get('sheet_names', []), "sheet_count": workbook_metadata.get('sheet_count', 0), + "table_count": workbook_metadata.get('table_count', 0), + "table_choices": self._table_choices(workbook_metadata), }) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error listing public blobs: {e}", level=logging.WARNING) @@ -4083,6 +4652,9 @@ async def describe_tabular_file( source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name. Omit to discover all tables; 'all' explicitly selects same-schema tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON summary of the tabular file"]: """Get schema and preview of a tabular file.""" def _sync_work(): @@ -4093,7 +4665,19 @@ def _sync_work(): ) workbook_metadata = self._get_workbook_metadata(container, blob_path) - if workbook_metadata.get('is_workbook') and workbook_metadata.get('sheet_count', 0) > 1 and not (sheet_name or sheet_index): + if workbook_metadata.get('workbook_manifest'): + selected_sheet = None + if sheet_name or sheet_index not in (None, '') or table_id not in (None, '', 'all') or cell_range or header_row is not None: + selected_sheet, _ = self._resolve_sheet_selection( + container, blob_path, sheet_name=sheet_name, sheet_index=sheet_index, + require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), + ) + summary = self._build_workbook_schema_summary( + container, blob_path, filename, preview_rows=5, sheet_name=selected_sheet, + **self._table_selector_kwargs(table_id, cell_range, header_row), + ) + elif workbook_metadata.get('is_workbook') and workbook_metadata.get('sheet_count', 0) > 1 and not (sheet_name or sheet_index): summary = self._build_workbook_schema_summary( container, blob_path, @@ -4107,12 +4691,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=False, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=False, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) summary = self._build_sheet_schema_summary(df, selected_sheet, preview_rows=5) summary.update({ @@ -4125,7 +4711,7 @@ def _sync_work(): return json.dumps(summary, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error describing file: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @kernel_function( @@ -4153,6 +4739,9 @@ async def lookup_value( max_rows: Annotated[str, "Maximum matching rows to return"] = "25", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON result containing matching rows and target-column values"]: """Look up values from a target column for matching rows.""" def _sync_work(): @@ -4165,7 +4754,7 @@ def _sync_work(): # When no explicit sheet_name is given, try cross-sheet search first normalized_sheet = (sheet_name or '').strip() normalized_sheet_idx = None if sheet_index is None else str(sheet_index).strip() - if not normalized_sheet and normalized_sheet_idx in (None, ''): + if not normalized_sheet and normalized_sheet_idx in (None, '') and table_id in (None, '', 'all') and not cell_range and header_row is None: cross_sheet_result = self._lookup_value_across_sheets( container, blob_path, filename, lookup_column, lookup_value, target_column, @@ -4173,6 +4762,7 @@ def _sync_work(): normalize_match=normalize_match_flag, max_rows=int(max_rows), start_row=int(start_row), + **self._table_selector_kwargs(table_id, cell_range, header_row), ) if cross_sheet_result is not None: return cross_sheet_result @@ -4182,12 +4772,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -4221,6 +4813,7 @@ def _sync_work(): operator = (match_operator or 'equals').strip().lower() normalized_lookup_value = str(lookup_value) + self._require_saved_values(df, [lookup_column]) try: mask = self._build_series_match_mask( df[lookup_column], @@ -4233,10 +4826,12 @@ def _sync_work(): start, limit = self._parse_row_page_arguments(start_row, max_rows, default_max_rows=25) matched_df = df[mask] + self._require_saved_values(matched_df, [target_column]) matches = matched_df.iloc[start:start + limit] response = { "filename": filename, "selected_sheet": selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), "lookup_column": lookup_column, "lookup_value": lookup_value, "target_column": target_column, @@ -4245,7 +4840,7 @@ def _sync_work(): "total_matches": len(matched_df), } response.update(self._build_tabular_row_page_payload( - matches.to_dict(orient='records'), + matches, len(matched_df), start_row=start, max_rows=limit, @@ -4257,7 +4852,7 @@ def _sync_work(): return json.dumps(response, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error looking up value: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @kernel_function( @@ -4291,6 +4886,9 @@ async def get_distinct_values( max_values: Annotated[str, "Maximum distinct values to return"] = "100", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON result containing deterministic distinct values and counts"]: """Return deterministic distinct values from a worksheet or across worksheets.""" def _sync_work(): @@ -4308,7 +4906,7 @@ def _sync_work(): normalized_sheet = (sheet_name or '').strip() normalized_sheet_idx = None if sheet_index is None else str(sheet_index).strip() - if not normalized_sheet and normalized_sheet_idx in (None, ''): + if not normalized_sheet and normalized_sheet_idx in (None, '') and table_id in (None, '', 'all') and not cell_range and header_row is None: cross_sheet_result = self._get_distinct_values_across_sheets( container, blob_path, @@ -4326,6 +4924,7 @@ def _sync_work(): url_path_segments=parsed_url_path_segments, normalize_match=normalize_match_flag, max_values=int(max_values), + **self._table_selector_kwargs(table_id, cell_range, header_row), ) if cross_sheet_result is not None: return cross_sheet_result @@ -4336,12 +4935,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) if column not in df.columns: @@ -4392,11 +4993,12 @@ def _sync_work(): ) except Exception as query_error: return json.dumps({ - 'error': f"Query/filter error: {query_error}", + **self._tabular_error_payload(query_error), 'filename': filename, 'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None, }) + self._require_saved_values(filtered_df, [column]) distinct_display_values, matched_cell_count, extracted_match_count = self._collect_distinct_display_values( filtered_df[column], normalize_match=normalize_match_flag, @@ -4410,6 +5012,7 @@ def _sync_work(): response_payload = { 'filename': filename, 'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), 'column': column, 'filter_applied': applied_filters, 'normalize_match': normalize_match_flag, @@ -4429,7 +5032,7 @@ def _sync_work(): return json.dumps(response_payload, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error getting distinct values: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @@ -4459,6 +5062,9 @@ async def count_rows( source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON result containing a deterministic row count"]: """Count rows deterministically after optional filters or queries.""" def _sync_work(): @@ -4471,7 +5077,7 @@ def _sync_work(): normalized_sheet = (sheet_name or '').strip() normalized_sheet_idx = None if sheet_index is None else str(sheet_index).strip() - if not normalized_sheet and normalized_sheet_idx in (None, ''): + if not normalized_sheet and normalized_sheet_idx in (None, '') and table_id in (None, '', 'all') and not cell_range and header_row is None: cross_sheet_result = self._count_rows_across_sheets( container, blob_path, @@ -4484,6 +5090,7 @@ def _sync_work(): additional_filter_value=additional_filter_value, query_expression=query_expression, normalize_match=normalize_match_flag, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) if cross_sheet_result is not None: return cross_sheet_result @@ -4494,12 +5101,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -4534,14 +5143,16 @@ def _sync_work(): ) except Exception as query_error: return json.dumps({ - 'error': f"Query/filter error: {query_error}", + **self._tabular_error_payload(query_error), 'filename': filename, 'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), }) return json.dumps({ 'filename': filename, 'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), 'rows_scanned': len(df), 'row_count': len(filtered_df), 'filter_applied': applied_filters, @@ -4549,7 +5160,7 @@ def _sync_work(): }, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error counting rows: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @@ -4573,6 +5184,9 @@ async def aggregate_column( source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON result of the aggregation"]: """Execute an aggregation operation on a column.""" def _sync_work(): @@ -4587,12 +5201,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -4609,6 +5225,7 @@ def _sync_work(): ) ) + self._require_saved_values(df, [column]) series = df[column] op = operation.lower().strip() @@ -4636,13 +5253,14 @@ def _sync_work(): return json.dumps({ "filename": filename, "selected_sheet": selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), "column": column, "operation": op, "result": result, }, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error aggregating column: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @kernel_function( @@ -4674,6 +5292,9 @@ async def filter_rows( max_rows: Annotated[str, "Maximum rows to return per page"] = "100", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON list of matching rows"]: """Filter rows based on a condition.""" def _sync_work(): @@ -4687,7 +5308,7 @@ def _sync_work(): # When no explicit sheet_name is given, try cross-sheet search first normalized_sheet = (sheet_name or '').strip() normalized_sheet_idx = None if sheet_index is None else str(sheet_index).strip() - if not normalized_sheet and normalized_sheet_idx in (None, ''): + if not normalized_sheet and normalized_sheet_idx in (None, '') and table_id in (None, '', 'all') and not cell_range and header_row is None: cross_sheet_result = self._filter_rows_across_sheets( container, blob_path, @@ -4702,6 +5323,7 @@ def _sync_work(): max_rows=int(max_rows), start_row=int(start_row), return_columns=parsed_return_columns, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) if cross_sheet_result is not None: return cross_sheet_result @@ -4711,12 +5333,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -4760,28 +5384,26 @@ def _sync_work(): ) ) except ValueError as filter_error: - return json.dumps({"error": str(filter_error)}) + return json.dumps(self._tabular_error_payload(filter_error)) start, limit = self._parse_row_page_arguments(start_row, max_rows) filtered = filtered_df.iloc[start:start + limit] response_payload = { "filename": filename, "selected_sheet": selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), "filter_applied": applied_filters, "normalize_match": normalize_match_flag, "total_matches": len(filtered_df), } response_payload.update(self._build_tabular_row_page_payload( - filtered.to_dict(orient='records'), + filtered, len(filtered_df), start_row=start, max_rows=limit, return_columns=parsed_return_columns, )) response_json = json.dumps(response_payload, indent=2, default=str) - if not str(blob_path or '').lower().endswith('.csv'): - return response_json - replay_expression = None replay_error = None try: @@ -4808,11 +5430,14 @@ def _sync_work(): return_columns=return_columns, expected_row_count=len(filtered_df), replay_error=replay_error, + selected_sheet=selected_sheet, + sheet_names=[selected_sheet] if selected_sheet else None, + **self._table_selector_kwargs(table_id, cell_range, header_row), ), ) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error filtering rows: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @kernel_function( @@ -4847,6 +5472,9 @@ async def search_rows( max_rows: Annotated[str, "Maximum matching rows to return per page"] = "100", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON result containing matching rows, matched columns, and search metadata"]: """Search rows across one or more columns while preserving row context.""" def _sync_work(): @@ -4861,7 +5489,7 @@ def _sync_work(): normalized_sheet = (sheet_name or '').strip() normalized_sheet_idx = None if sheet_index is None else str(sheet_index).strip() - if not normalized_sheet and normalized_sheet_idx in (None, ''): + if not normalized_sheet and normalized_sheet_idx in (None, '') and table_id in (None, '', 'all') and not cell_range and header_row is None: cross_sheet_result = self._search_rows_across_sheets( container, blob_path, @@ -4880,6 +5508,7 @@ def _sync_work(): normalize_match=normalize_match_flag, max_rows=int(max_rows), start_row=int(start_row), + **self._table_selector_kwargs(table_id, cell_range, header_row), ) if cross_sheet_result is not None: return cross_sheet_result @@ -4890,12 +5519,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -4936,7 +5567,7 @@ def _sync_work(): ) except Exception as query_error: return json.dumps({ - 'error': f"Query/filter error: {query_error}", + **self._tabular_error_payload(query_error), 'filename': filename, 'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None, }) @@ -4977,14 +5608,16 @@ def _sync_work(): ) except ValueError as search_error: return json.dumps({ - 'error': str(search_error), + **self._tabular_error_payload(search_error), 'filename': filename, 'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), }) response_json = json.dumps({ 'filename': filename, 'selected_sheet': selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), 'search_value': search_value, 'search_operator': search_operator, 'searched_columns': search_result['searched_columns'], @@ -5000,9 +5633,6 @@ def _sync_work(): 'next_start_row': search_result['next_start_row'], 'data': search_result['data'], }, indent=2, default=str) - if not str(blob_path or '').lower().endswith('.csv'): - return response_json - replay_expression = None replay_error = None try: @@ -5033,11 +5663,14 @@ def _sync_work(): return_columns=return_columns, expected_row_count=search_result['total_matches'], replay_error=replay_error, + selected_sheet=selected_sheet, + sheet_names=[selected_sheet] if selected_sheet else None, + **self._table_selector_kwargs(table_id, cell_range, header_row), ), ) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error searching rows: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @@ -5064,6 +5697,9 @@ async def query_tabular_data( max_rows: Annotated[str, "Maximum rows to return per page"] = "100", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON result of the query"]: """Execute a pandas query expression against a tabular file.""" def _sync_work(): @@ -5074,6 +5710,11 @@ def _sync_work(): group_id=group_id, public_workspace_id=public_workspace_id ) if str(blob_path or '').lower().endswith('.csv'): + if self._table_selector_kwargs(table_id, cell_range, header_row): + raise TabularSelectionError( + "Table, range, and header selectors apply only to Excel workbooks.", + code='table_selection_invalid', + ) return self._query_csv_data_in_bounded_chunks( container_name=container, blob_path=blob_path, @@ -5086,12 +5727,13 @@ def _sync_work(): # When no explicit sheet_name is given, try cross-sheet query first normalized_sheet = (sheet_name or '').strip() normalized_sheet_idx = None if sheet_index is None else str(sheet_index).strip() - if not normalized_sheet and normalized_sheet_idx in (None, ''): + if not normalized_sheet and normalized_sheet_idx in (None, '') and table_id in (None, '', 'all') and not cell_range and header_row is None: cross_sheet_result = self._query_tabular_data_across_sheets( container, blob_path, filename, query_expression, max_rows=int(max_rows), start_row=int(start_row), return_columns=parsed_return_columns, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) if cross_sheet_result is not None: return cross_sheet_result @@ -5101,12 +5743,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -5120,45 +5764,32 @@ def _sync_work(): response_payload = { "filename": filename, "selected_sheet": selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), "query_expression": query_expression, "query_expression_fallback": used_reviewer_style_fallback, "total_matches": len(result_df), } response_payload.update(self._build_tabular_row_page_payload( - sliced_result_df.to_dict(orient='records'), + sliced_result_df, len(result_df), start_row=start, max_rows=limit, return_columns=parsed_return_columns, )) response_json = json.dumps(response_payload, indent=2, default=str) - source_blob_version = self._get_tabular_blob_version(container, blob_path) - internal_metadata = { - 'tabular_source_authorization': self._build_source_authorization_from_location( - container, - blob_path, - blob_version=source_blob_version, - ), - } - if str(blob_path or '').lower().endswith('.csv'): - internal_metadata['tabular_generated_export_source'] = ( - self._build_generated_export_query_descriptor_from_location( - container_name=container, - blob_path=blob_path, - filename=filename, - query_expression=query_expression, - return_columns=return_columns, - expected_row_count=len(result_df), - blob_version=source_blob_version, - ) - ) return PluginInvocationResult( response_json, - internal_metadata=internal_metadata, + internal_metadata=self._build_tabular_generated_export_internal_metadata( + container_name=container, blob_path=blob_path, filename=filename, + source_function='query_tabular_data', query_expression=query_expression, + return_columns=return_columns, expected_row_count=len(result_df), + selected_sheet=selected_sheet, sheet_names=[selected_sheet], + **self._table_selector_kwargs(table_id, cell_range, header_row), + ), ) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error querying data: {e}", level=logging.WARNING) - return json.dumps({"error": f"Query error: {str(e)}. Ensure column names and values are correct."}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @kernel_function( @@ -5197,6 +5828,16 @@ async def filter_rows_by_related_values( max_rows: Annotated[str, "Maximum related target rows to return per page"] = "100", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + source_table_id: Annotated[str, "Optional discovered Excel table ID or name for the source cohort."] = None, + source_cell_range: Annotated[str, "Optional source Excel range instead of source_table_id; requires source_header_row."] = None, + source_header_row: Annotated[str, "Actual source worksheet header row; zero means no header."] = None, + target_table_id: Annotated[str, "Optional discovered Excel table ID or name for the target rows."] = None, + target_cell_range: Annotated[str, "Optional target Excel range instead of target_table_id; requires target_header_row."] = None, + target_header_row: Annotated[str, "Actual target worksheet header row; zero means no header."] = None, + source_filename: Annotated[str, "Optional different filename for the source cohort; defaults to filename."] = None, + target_filename: Annotated[str, "Optional different filename for the target rows; defaults to filename."] = None, + source_source: Annotated[str, "Optional source cohort storage scope: workspace, chat, group, or public. Defaults to source."] = None, + target_source: Annotated[str, "Optional target storage scope: workspace, chat, group, or public. Defaults to source."] = None, ) -> Annotated[str, "JSON result containing explainable set-membership filtering output"]: """Filter target rows by membership in a source-sheet cohort.""" def _sync_work(): @@ -5206,6 +5847,14 @@ def _sync_work(): user_id, conversation_id, filename, source, group_id=group_id, public_workspace_id=public_workspace_id ) + source_location = self._resolve_blob_location_with_fallback( + user_id, conversation_id, source_filename or filename, source_source or source, + group_id=group_id, public_workspace_id=public_workspace_id, + ) + target_location = self._resolve_blob_location_with_fallback( + user_id, conversation_id, target_filename or filename, target_source or source, + group_id=group_id, public_workspace_id=public_workspace_id, + ) result_payload = self._evaluate_related_value_membership( container, blob_path, @@ -5230,11 +5879,15 @@ def _sync_work(): max_rows=int(max_rows), start_row=int(start_row), return_columns=return_columns, + source_table_id=source_table_id, source_cell_range=source_cell_range, + source_header_row=source_header_row, target_table_id=target_table_id, + target_cell_range=target_cell_range, target_header_row=target_header_row, + source_location=source_location, target_location=target_location, ) return json.dumps(result_payload, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error filtering rows by related values: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @@ -5271,6 +5924,16 @@ async def count_rows_by_related_values( source: Annotated[str, "Source: 'workspace', 'chat', 'group', or 'public'"] = "chat", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + source_table_id: Annotated[str, "Optional discovered Excel table ID or name for the source cohort."] = None, + source_cell_range: Annotated[str, "Optional source Excel range instead of source_table_id; requires source_header_row."] = None, + source_header_row: Annotated[str, "Actual source worksheet header row; zero means no header."] = None, + target_table_id: Annotated[str, "Optional discovered Excel table ID or name for the target rows."] = None, + target_cell_range: Annotated[str, "Optional target Excel range instead of target_table_id; requires target_header_row."] = None, + target_header_row: Annotated[str, "Actual target worksheet header row; zero means no header."] = None, + source_filename: Annotated[str, "Optional different filename for the source cohort; defaults to filename."] = None, + target_filename: Annotated[str, "Optional different filename for the target rows; defaults to filename."] = None, + source_source: Annotated[str, "Optional source cohort storage scope: workspace, chat, group, or public. Defaults to source."] = None, + target_source: Annotated[str, "Optional target storage scope: workspace, chat, group, or public. Defaults to source."] = None, ) -> Annotated[str, "JSON result containing an explainable relational row count"]: """Count target rows by membership in a source-sheet cohort.""" def _sync_work(): @@ -5280,6 +5943,14 @@ def _sync_work(): user_id, conversation_id, filename, source, group_id=group_id, public_workspace_id=public_workspace_id ) + source_location = self._resolve_blob_location_with_fallback( + user_id, conversation_id, source_filename or filename, source_source or source, + group_id=group_id, public_workspace_id=public_workspace_id, + ) + target_location = self._resolve_blob_location_with_fallback( + user_id, conversation_id, target_filename or filename, target_source or source, + group_id=group_id, public_workspace_id=public_workspace_id, + ) result_payload = self._evaluate_related_value_membership( container, blob_path, @@ -5302,6 +5973,10 @@ def _sync_work(): target_alias_column=target_alias_column, normalize_match=normalize_match_flag, max_rows=50, + source_table_id=source_table_id, source_cell_range=source_cell_range, + source_header_row=source_header_row, target_table_id=target_table_id, + target_cell_range=target_cell_range, target_header_row=target_header_row, + source_location=source_location, target_location=target_location, include_rows=False, ) if 'error' not in result_payload: result_payload['row_count'] = result_payload.get('matched_target_row_count', 0) @@ -5311,7 +5986,7 @@ def _sync_work(): return json.dumps(result_payload, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error counting rows by related values: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @@ -5340,6 +6015,9 @@ async def group_by_aggregate( sort_descending: Annotated[str, "Whether top_results should be sorted descending (true/false)"] = "true", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON result of the group-by aggregation"]: """Group by one column and aggregate another.""" def _sync_work(): @@ -5354,12 +6032,14 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) @@ -5386,6 +6066,7 @@ def _sync_work(): "error": "Unsupported operation. Use count, sum, mean, min, max, median, or std." }) + self._require_saved_values(df, [group_by_column, aggregate_column]) grouped = df.groupby(group_by_column)[aggregate_column].agg(op) grouped = grouped.dropna() if grouped.empty: @@ -5400,6 +6081,7 @@ def _sync_work(): return json.dumps({ "filename": filename, "selected_sheet": selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), "group_by": group_by_column, "aggregate_column": aggregate_column, "operation": op, @@ -5410,7 +6092,7 @@ def _sync_work(): }, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error in group-by: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) @kernel_function( @@ -5441,6 +6123,9 @@ async def group_by_datetime_component( sort_descending: Annotated[str, "Whether top_results should be sorted descending (true/false)"] = "true", group_id: Annotated[str, "Group ID (for group workspace documents)"] = None, public_workspace_id: Annotated[str, "Public workspace ID (for public workspace documents)"] = None, + table_id: Annotated[str, "Optional discovered Excel table ID or name; 'all' explicitly selects same-schema tables. Required when a worksheet has multiple tables."] = None, + cell_range: Annotated[str, "Optional Excel range such as A3:D100. Use instead of table_id and supply header_row."] = None, + header_row: Annotated[str, "Actual worksheet header row; zero means no header. Required for an explicit range or ambiguous header."] = None, ) -> Annotated[str, "JSON result of the datetime component grouping analysis"]: """Group data by a datetime component and aggregate a metric.""" def _sync_work(): @@ -5459,22 +6144,22 @@ def _sync_work(): sheet_name=sheet_name, sheet_index=sheet_index, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._read_tabular_blob_to_dataframe( container, blob_path, sheet_name=selected_sheet, require_explicit_sheet=True, + **self._table_selector_kwargs(table_id, cell_range, header_row), ) df = self._try_numeric_conversion(df) if filter_expression: try: - df = df.query(filter_expression) + df, _ = self._apply_query_expression_with_fallback(df, filter_expression) except Exception as query_error: - return json.dumps({ - "error": f"Filter query error: {query_error}. Ensure column names and values are correct." - }) + return json.dumps(self._tabular_error_payload(query_error)) if datetime_column not in df.columns: related_columns = [aggregate_column] if aggregate_column else [] @@ -5491,6 +6176,7 @@ def _sync_work(): ) ) + self._require_saved_values(df, [datetime_column]) parsed_datetime = self._parse_datetime_like_series(df[datetime_column]) valid_mask = parsed_datetime.notna() if not valid_mask.any(): @@ -5535,6 +6221,7 @@ def _sync_work(): available_columns=list(filtered_df.columns), ) ) + self._require_saved_values(filtered_df, [aggregate_column_name]) grouped = filtered_df.groupby(component_column_name)[aggregate_column_name].agg(op) grouped = grouped.dropna() @@ -5552,6 +6239,7 @@ def _sync_work(): return json.dumps({ "filename": filename, "selected_sheet": selected_sheet if workbook_metadata.get('is_workbook') else None, + **self._table_result_metadata(df), "datetime_column": datetime_column, "datetime_component": self._normalize_datetime_component(datetime_component), "aggregate_column": aggregate_column_name or None, @@ -5566,5 +6254,5 @@ def _sync_work(): }, indent=2, default=str) except Exception as e: log_event(f"[TABULAR_PROCESSING_PLUGIN] Error in datetime component grouping: {e}", level=logging.WARNING) - return json.dumps({"error": str(e)}) + return json.dumps(self._tabular_error_payload(e)) return await asyncio.to_thread(_sync_work) diff --git a/application/single_app/templates/admin/_panes/extraction.html b/application/single_app/templates/admin/_panes/extraction.html index 857acb69f..e9c910fbe 100644 --- a/application/single_app/templates/admin/_panes/extraction.html +++ b/application/single_app/templates/admin/_panes/extraction.html @@ -248,7 +248,7 @@
Azure AI Content Understanding<
Images Inside Office Files

- Neither extraction engine describes figures inside Word and PowerPoint files. When this is on, + Native extraction does not describe the pixels of images inside Word, PowerPoint, or Excel files. When this is on, embedded images are pulled out of the file, analyzed with whichever engine backs the selected extraction mode, and indexed as their own citable chunks. This works with Standard extraction too, using Document Intelligence. @@ -262,7 +262,7 @@

Images Inside Office Files
diff --git a/application/v2_ui/src/components/chat/EnhancedCitationViewer.tsx b/application/v2_ui/src/components/chat/EnhancedCitationViewer.tsx index 9aa30eadd..282742458 100644 --- a/application/v2_ui/src/components/chat/EnhancedCitationViewer.tsx +++ b/application/v2_ui/src/components/chat/EnhancedCitationViewer.tsx @@ -5,7 +5,7 @@ // falls back to the plain text citation, because a citation that cannot render its source // is still more useful as a readable passage than as a dead click. -import { useCallback, useEffect, useMemo, useRef, useState } from 'react'; +import { useCallback, useEffect, useId, useMemo, useRef, useState, type KeyboardEvent as ReactKeyboardEvent } from 'react'; import { clsx } from 'clsx'; import { ChevronLeft, @@ -159,21 +159,20 @@ function PdfViewer({ docId, location, onFail }: ViewerProps) { /* -------------------------------------------------------------------------- */ /** - * What ingestion extracted from a cited image. + * The original cited passage, independent of worksheet/table preview navigation. * - * An image has no page to scroll to, so the picture alone cannot show why it was cited. The - * cited passage is the text the assistant actually read -- any recognised text plus the - * image's description -- and is shown beneath the picture rather than instead of it. - * Nothing is drawn when the passage cannot be loaded; the image is still the source. + * The passage remains tied to the citation rather than the table currently being previewed. */ -function CitedImagePassage({ +function CitedSourcePassage({ citationId, docId, location, + sourceLabel = 'What was extracted from this image', }: { citationId: string; docId: string; location: string; + sourceLabel?: string; }) { const [passage, setPassage] = useState(null); const [failed, setFailed] = useState(false); @@ -214,7 +213,7 @@ function CitedImagePassage({ className="max-h-[40%] shrink-0 overflow-y-auto border-t border-edge px-5 py-3" > - What was extracted from this image + {sourceLabel} {passage === null ? (

@@ -252,7 +251,7 @@ function ImageViewer({ docId, location, metadata, onFail, citationId }: ViewerPr />

{citationId ? ( - + ) : null} ); @@ -311,34 +310,61 @@ function MediaViewer({ docId, location, metadata, onFail, kind }: ViewerProps & /* Tabular */ /* -------------------------------------------------------------------------- */ -function TabularViewer({ docId, location, onFail, citationId }: ViewerProps) { +function TabularViewer({ docId, location, metadata, onFail, citationId }: ViewerProps) { const [preview, setPreview] = useState(null); - const [sheet, setSheet] = useState( - // A sheet citation carries the sheet name where a page citation carries a number. - Number.isNaN(Number.parseInt(location, 10)) ? location || undefined : undefined, - ); + const [sheet, setSheet] = useState(); + const [tableId, setTableId] = useState(); + const [startRow, setStartRow] = useState(0); + const [previousStarts, setPreviousStarts] = useState([]); + const [jumpRecord, setJumpRecord] = useState('1'); const [loading, setLoading] = useState(true); + const [error, setError] = useState(''); + const [retry, setRetry] = useState(0); + const hasLoaded = useRef(false); + const initialLocationApplied = useRef(false); + const sheetButtons = useRef(new Map()); + const panelId = useId(); + const tableSelectId = useId(); + const recordInputId = useId(); useEffect(() => { let cancelled = false; + let redirected = false; + const controller = new AbortController(); setLoading(true); + setError(''); void (async () => { try { - const result = await fetchTabularPreview(docId, { sheetName: sheet }); + const result = await fetchTabularPreview( + docId, { sheetName: sheet, tableId, startRow }, controller.signal, + ); if (!cancelled) { + if (!initialLocationApplied.current) { + initialLocationApplied.current = true; + const requested = (result.sheet_names ?? []).find((name) => + name === location || `${name}!` === location.slice(0, name.length + 1), + ); + if (requested && requested !== result.selected_sheet) { + redirected = true; + setSheet(requested); + return; + } + } setPreview(result); + setJumpRecord(String((result.start_row ?? startRow) + 1)); + hasLoaded.current = true; } } catch (error) { if (!cancelled) { - onFail( - error instanceof Error - ? error.message - : 'Could not load the spreadsheet.', - ); + const message = error instanceof Error ? error.message : 'Could not load the spreadsheet.'; + setError(message); + if (!hasLoaded.current) { + onFail(message); + } } } finally { - if (!cancelled) { + if (!cancelled && !redirected) { setLoading(false); } } @@ -346,8 +372,9 @@ function TabularViewer({ docId, location, onFail, citationId }: ViewerProps) { return () => { cancelled = true; + controller.abort(); }; - }, [docId, sheet, onFail]); + }, [docId, location, sheet, tableId, startRow, retry, onFail]); if (loading && !preview) { return ; @@ -358,19 +385,66 @@ function TabularViewer({ docId, location, onFail, citationId }: ViewerProps) { } const sheets = preview.sheet_names ?? []; + const tables = preview.tables ?? []; + const selectedSheet = preview.selected_sheet ?? sheets[0]; + const currentStart = preview.start_row ?? 0; + const rowCount = preview.rows?.length ?? 0; + const hasMore = preview.has_more ?? preview.truncated ?? false; + const nextStart = preview.next_start_row ?? currentStart + rowCount; + + function changeSheet(name: string) { + if (name === selectedSheet && !loading && !error) { + return; + } + setLoading(true); + setSheet(name); + setTableId(undefined); + setStartRow(0); + setPreviousStarts([]); + } + + function moveSheet(event: ReactKeyboardEvent, index: number) { + let next: number; + if (event.key === 'ArrowRight') { + next = (index + 1) % sheets.length; + } else if (event.key === 'ArrowLeft') { + next = (index - 1 + sheets.length) % sheets.length; + } else if (event.key === 'Home') { + next = 0; + } else if (event.key === 'End') { + next = sheets.length - 1; + } else { + return; + } + event.preventDefault(); + changeSheet(sheets[next]); + sheetButtons.current.get(sheets[next])?.focus(); + } return (
{sheets.length > 1 && ( -
- {sheets.map((name) => ( +
+ {sheets.map((name, index) => (
)} -
- +
+

+ {selectedSheet ? `Worksheet: ${selectedSheet}` : 'CSV data'} + {preview.table_range ? ` · ${preview.table_range}` : ''} + {preview.header_row ? ` · Header row ${preview.header_row}` : ''} + {preview.header_status === 'inferred' ? ' (detected)' : ''} + {preview.header_status === 'ambiguous' ? ' · Header is unconfirmed; cell coordinates are retained.' : ''} +

+ {tables.length > 1 && ( +
+ + +
+ )} +
+ {error && ( +
+ {error} + +
+ )} +
+ {loading ? : rowCount === 0 ? ( +

No data rows in this selection.

+ ) :
+ + {(preview.columns ?? []).map((column, index) => ( {(preview.rows ?? []).map((row, rowIndex) => ( + {row.map((cell, cellIndex) => ( -
{preview.table_name || selectedSheet || 'CSV'} data preview
+ {sheets.length ? 'Worksheet row' : 'File row'} + {column} @@ -398,6 +517,9 @@ function TabularViewer({ docId, location, onFail, citationId }: ViewerProps) {
+ {preview.row_numbers?.[rowIndex] ?? currentStart + rowIndex + 2} + ))}
+ }
- {preview.truncated && ( -

- Showing the first {preview.rows?.length ?? 0} rows. Download the file for - the rest. +

+

+ {rowCount ? `Records ${currentStart + 1}–${currentStart + rowCount}` : '0 records'} + {preview.total_rows != null ? ` of ${preview.total_rows}` : ''} + {hasMore ? ' · More records available' : ''}

+ + +
{ + event.preventDefault(); + const record = Number(jumpRecord); + if (!Number.isSafeInteger(record) || record < 1 || (preview.total_rows != null && record > preview.total_rows)) { + setError('Choose a record number within this table.'); + return; + } + if (record - 1 === currentStart) { + if (error) { + setRetry((current) => current + 1); + } + return; + } + setLoading(true); + setPreviousStarts((starts) => [...starts, currentStart]); + setStartRow(record - 1); + }} + > + + setJumpRecord(event.target.value)} + className="min-h-11 w-24 rounded-lg border border-edge-strong bg-surface-1 px-2 text-base text-text-1 sm:text-sm" + /> + +
+
+ {(preview.columns_truncated || preview.cell_text_truncated) && ( +

Some preview columns or long cell text are shortened. Inspect a smaller cell range or download the original for full content.

)} {citationId ? ( - + ) : null}
); @@ -572,7 +756,9 @@ export function EnhancedCitationViewer({

{VIEWER_LABELS[type]} - {location ? ` · ${locationLabel} ${location}` : ''} + {location ? type === 'tabular' + ? ` · ${/^\d+$/.test(location) ? `Evidence segment ${location}` : locationLabel === 'Sheet' ? `Sheet ${location}` : location}` + : ` · ${locationLabel} ${location}` : ''}

@@ -600,7 +786,7 @@ export function EnhancedCitationViewer({ {type === 'image' && } {type === 'video' && } {type === 'audio' && } - {type === 'tabular' && } + {type === 'tabular' && } {type === 'visio' && } diff --git a/application/v2_ui/src/lib/endpoints.ts b/application/v2_ui/src/lib/endpoints.ts index a360b6039..df55327cb 100644 --- a/application/v2_ui/src/lib/endpoints.ts +++ b/application/v2_ui/src/lib/endpoints.ts @@ -1406,6 +1406,16 @@ export async function fetchEnhancedCitationPdf( }; } +export interface WorkbookPreviewTable { + id: string; + name: string; + range: string; + origin: 'named' | 'inferred' | 'range'; + header_row?: number | null; + header_status?: string; + row_count?: number; +} + export interface TabularPreview { filename?: string; selected_sheet?: string | null; @@ -1416,11 +1426,32 @@ export interface TabularPreview { columns?: string[]; rows?: string[][]; truncated?: boolean; + tables?: WorkbookPreviewTable[]; + table_count?: number; + table_id?: string; + table_name?: string; + table_range?: string; + header_row?: number | null; + header_status?: string; + row_numbers?: number[]; + start_row?: number; + has_more?: boolean; + next_start_row?: number | null; + columns_truncated?: boolean; + cell_text_truncated?: boolean; } export function fetchTabularPreview( docId: string, - options: { sheetName?: string; maxRows?: number } = {}, + options: { + sheetName?: string; + tableId?: string; + startRow?: number; + maxRows?: number; + cellRange?: string; + headerRow?: number; + } = {}, + signal?: AbortSignal, ) { const params = new URLSearchParams({ doc_id: docId }); if (options.sheetName) { @@ -1429,8 +1460,21 @@ export function fetchTabularPreview( if (options.maxRows) { params.set('max_rows', String(options.maxRows)); } + if (options.tableId) { + params.set('table_id', options.tableId); + } + if (options.startRow !== undefined) { + params.set('start_row', String(options.startRow)); + } + if (options.cellRange) { + params.set('cell_range', options.cellRange); + } + if (options.headerRow !== undefined) { + params.set('header_row', String(options.headerRow)); + } return api.get( `/api/enhanced_citations/tabular_preview?${params.toString()}`, + signal, ); } diff --git a/docs/_data/features.yml b/docs/_data/features.yml index d0a674688..389e54258 100644 --- a/docs/_data/features.yml +++ b/docs/_data/features.yml @@ -180,6 +180,8 @@ enhanced-citations: reference: - title: "Feature reference" url: /reference/features/ + - title: "Inspect Excel workbooks" + url: /guides/inspect-excel-workbooks/ chat-memory: name: "Chat memory" area: "Chat and retrieval" @@ -538,7 +540,7 @@ tabular-analysis: name: "Tabular analysis" area: "Media and ingestion" audience: "End users" - summary: "Runs structured CSV and spreadsheet analysis with durable planning, batching, checkpoints, and response controls." + summary: "Runs structured CSV and spreadsheet analysis with table/range-aware headers, durable planning, batching, checkpoints, and bounded responses." why: "Use this when users need computed answers, grouped results, exports, or charts from spreadsheet data rather than prose guesses. The many rollout flags exist because large workbook analysis needs reliability controls for planning, retries, batching, and durable checkpoints. The Analyze All Documents target stays off and hidden because no chat or workflow screen offers it yet." visual_sections: - heading: "Compute from the intended rows, not a sample" @@ -546,7 +548,7 @@ tabular-analysis: Schema inspection helps plan a calculation; the intended underlying rows must supply its totals and grouped results. Distinguish a computed table from the model's explanation and from an actual exported file. Check - source coverage, worksheet selection, validation notices, and limitations + source coverage, worksheet and table/range selection, validation notices, and limitations before relying on the result. The illustrated data is synthetic, not a benchmark or a capacity promise. media_id: slide-tabular-analysis diff --git a/docs/admin/knowledge.md b/docs/admin/knowledge.md index df4bb6f7d..59dc4e3b6 100644 --- a/docs/admin/knowledge.md +++ b/docs/admin/knowledge.md @@ -208,8 +208,8 @@ there is nothing further to configure. ### Images Inside Office Files {#office-embedded-image-section} -Neither extraction engine describes figures embedded in Word and PowerPoint files, so a -chart pasted into a slide deck is invisible to search. With this on, embedded images are +Native extraction does not describe the pixels of images embedded in Word, PowerPoint, +or Excel files. With this on, embedded images are extracted from the file, analysed with whichever engine backs the selected extraction mode, and indexed as their own citable chunks. It works with Standard extraction as well as Enhanced. @@ -330,8 +330,8 @@ already captures the surrounding structure. | Content Understanding Key | Provides the secret credential used when the selected authentication mode requires one. | Empty | `azure_content_understanding_key` | | API Version | Default: | Not specified in defaults | `azure_content_understanding_api_version` | | Document Analyzer | Default: | Not specified in defaults | `azure_content_understanding_analyzer_id` | -| Image Analyzer | Content Understanding analyzer that describes images embedded in DOCX and PPTX files, and standalone images when the document analyzer finds no text in them. Its `Summary` field is indexed as the image description. | prebuilt-imageSearch | `azure_content_understanding_image_analyzer_id` | -| Analyze images embedded in DOCX and PPTX files | Exposes the capability after required services, permissions, and rollout policy are ready. | On | `enable_office_embedded_image_analysis`; capability toggle | +| Image Analyzer | Content Understanding analyzer that describes images embedded in DOCX, PPTX, and OOXML Excel workbooks, and standalone images when the document analyzer finds no text in them. Its `Summary` field is indexed as the image description. Excel descriptions retain their worksheet/cell placements separately from saved alternative text. | prebuilt-imageSearch | `azure_content_understanding_image_analyzer_id` | +| Analyze images embedded in DOCX, PPTX, and Excel files | Adds configured image descriptions/OCR during ingestion or reprocessing, retaining available worksheet/object anchors separately from saved alternative text. Excel support was added in 0.261.405. | On | `enable_office_embedded_image_analysis`; capability toggle | | Minimum Image Size (pixels) | Images narrower or shorter than this are skipped as icons or spacers. | Not specified in defaults | `office_embedded_image_min_pixels` | | Maximum Images Per Document | Caps per-document cost. Duplicate images are analyzed once. | Not specified in defaults | `office_embedded_image_max_per_document` | | Use APIM instead of direct Document Intelligence endpoint | Routes Document Intelligence calls through APIM instead of calling the service endpoint directly. | Off | `enable_document_intelligence_apim`; capability toggle | diff --git a/docs/explanation/features/DOCUMENT_ACCESSIBILITY_AND_STRUCTURE_EXTRACTION.md b/docs/explanation/features/DOCUMENT_ACCESSIBILITY_AND_STRUCTURE_EXTRACTION.md index e7254b739..9b20f48a6 100644 --- a/docs/explanation/features/DOCUMENT_ACCESSIBILITY_AND_STRUCTURE_EXTRACTION.md +++ b/docs/explanation/features/DOCUMENT_ACCESSIBILITY_AND_STRUCTURE_EXTRACTION.md @@ -2,7 +2,8 @@ **Implemented in version: 0.261.391** (formatting, style inventory, and programmatic access added in **0.261.392**) **Excel implemented in version: 0.261.399** -**Related config.py version: `0.261.399`** +**Excel native content/table improvements implemented in version: 0.261.408** +**Related config.py version: `0.261.408`** ## 1. Overview and Purpose @@ -223,6 +224,16 @@ flowchart LR ### Excel native inspection (0.261.399) +The original extraction below was expanded in **0.261.408** with canonical +thread/reply handling, saved-cell context, streaming table discovery, and +revision-bound full-inventory paging. See +[Scalable Excel Native Inspection](EXCEL_NATIVE_INSPECTION.md) for current +storage/scale behavior and the +[comment/header fix](../fixes/EXCEL_COMMENT_CONTENT_AND_TABLE_HEADERS_FIX.md). +Existing retained Excel originals can be inspected without re-uploading. +The historical parent-record/style-sample limits below do not mean every +worksheet has one table or that complete native records must fit the parent. + Excel follows the same **parent metadata plus searchable native evidence** model as the other document formats without turning spreadsheet ingestion into full-data indexing. This lets users ask about the workbook itself, such as who authored it, which comments need review, whether an image has native alternative text, or what prints in a sheet's footer. `functions_excel_accessibility.py` reads modern workbook packages without saving or executing them. It follows workbook relationships to identify worksheets and chart sheets rather than assuming that a sheet's filename indicates its name or order. It also reads: @@ -251,7 +262,7 @@ Inspection is bounded to 5,000 ZIP entries, 16 MiB per XML part, 64 MiB total XM Legacy `.xls` is inspected with the existing OLE/BIFF dependencies. Its metadata and style coverage is best effort; unavailable object, thread and header/footer details are explicitly stated. No new cloud service or dependency is required. -To inspect an existing workbook, re-upload it to a personal, group or public workspace so native evidence is generated. Then ask, for example, "Show the cell notes and threaded comments", "Which objects have saved alt text?", or "What is in the first-page footer?" An agent with Document Search can request `get_document_accessibility_report` and retrieve the relevant native evidence segments for detailed findings. Chat-only uploads do not gain this workspace report. +From 0.261.408, existing active workbook originals can be inspected on demand without re-uploading. Reprocessing can add configured image-analysis enrichment; a new upload is needed only when required originals/inventories are unavailable. Ask, for example, "Show the cell notes and threaded comments", "Which objects have saved alt text?", or "What is in the first-page footer?" An agent with Document Search can request `get_document_accessibility_report` and follow native inventory continuations for detailed findings. Chat-only uploads do not gain workspace-report access. ### Programmatic Access: `get_document_accessibility_report` diff --git a/docs/explanation/features/EXCEL_NATIVE_INSPECTION.md b/docs/explanation/features/EXCEL_NATIVE_INSPECTION.md new file mode 100644 index 000000000..e6ef37607 --- /dev/null +++ b/docs/explanation/features/EXCEL_NATIVE_INSPECTION.md @@ -0,0 +1,131 @@ +# Scalable Excel Native Inspection + +Implemented in version: **0.261.408**. +Related application version: `application/single_app/config.py`. + +## Overview + +Excel inspection separates the workbook's saved data, reviewer feedback, and +document structure. A comment requesting a different value does not change the +saved cell value. A worksheet can contain several independent tables; its first +row is not automatically every table's header. + +The implementation uses the existing Open XML, openpyxl, xlrd, private artifact +storage, Document Search, and Tabular Processing dependencies. It introduces no +new cloud service. + +## Saved content and structure + +Modern `.xlsx` and `.xlsm` packages expose saved cell values and types, formula +text and available caches, genuine legacy notes, threaded messages and replies, +core/extended/custom properties, defined names, table definitions, hyperlinks, +validation expressions, layout, print information, and readable drawing/chart +text and caches. Drawing and comment locations retain worksheet/cell anchors. + +Threaded comments can have legacy compatibility representations. An identifiable +same-cell compatibility copy is not counted as another genuine note. Counts +distinguish legacy notes, thread roots, replies, and raw compatibility records. +Missing author/date/resolution fields remain unknown. A blank cell, zero, false, +and a formula without a saved result are different states. + +Images use the existing Office embedded-image analysis setting, configured +engine, size limits, and per-document cap during ingestion/reprocessing. +Generated image descriptions are separate from saved native alternative text. +Missing analysis does not prove that the workbook contains no pictures. + +## Tables and scale + +Named Excel table definitions provide authoritative ranges, columns, and +header/totals information. Ordinary occupied blocks are detected separately, +including horizontally or vertically separated regions, title rows, and +repeated headers. Inferred headers are labelled as inferred; ambiguous headers +require an explicit selection rather than a silent first-row assumption. + +Streaming worksheet reads support large workbooks without copying all rows into +metadata. Functional coverage includes 50,000- and 100,000-row workbooks, late-row +reads, and five independent named or ordinary tables on one worksheet. These +are correctness fixtures, not a capacity or performance guarantee for every file. + +Analytical operations use the selected table/range and preserve physical source +locations. Counts, filters, and aggregates must come from the underlying records, +not the displayed preview. CSV and ordinary single-table inputs retain their +existing analysis path. + +## Storage, access, and lifecycle + +The original retained workbook remains authoritative. Its table dataset is +identified by the source revision/hash, worksheet, range, headers, and columns; +worksheet rows are not placed in a large Cosmos metadata object. + +Parent Excel metadata remains bounded to 500,000 serialized bytes. Complete +native inventories use immutable, revision-bound pages in the existing private +artifact store, with the ready manifest written last. Long text has explicit +continuations rather than permanent loss at a parent-preview limit. Existing +durable tabular machinery handles large computed outputs. + +Every read, cached read, and continuation retains current source authorization +and revision checks. Private artifact references are not public document fields. +Metadata from an original file cannot be presented as the native metadata of a +different sanitized active representation. Revision cleanup removes its derived +private artifacts without deleting another document's artifacts. + +## Using existing files + +Existing stored comment records can be used without uploading the file again. +When the active original is retained, native inspection can generate the richer +inventory on demand. A retained current inventory can also be read without +downloading the workbook again. + +Image-analysis enrichment follows ingestion/reprocessing and its configured +cloud engine; an ordinary native metadata read does not silently run new vision +analysis. A re-upload is necessary only when required source bytes/inventories +are unavailable. A held or inaccessible document requires authorized resolution, +not re-uploading to bypass its policy. + +No automatic bulk reprocessing is started by this feature. + +## APIs and user workflow + +`Document Search.get_document_accessibility_report` preserves its +`accessibility`, `style`, and `issues` sections and adds bounded Excel native +section selection, continuation, and direct saved-cell range reads. Follow +`excel_inspection.page.next_cursor` while `has_more` is true when every record is +required. Explicit JSON record fragments must be continued before treating them +as a complete record. + +The V2 citation viewer has worksheet tabs, table selection, record paging, and a +record jump control. Its row headers show physical worksheet row numbers. +**Cited workbook evidence** remains the passage originally cited, independent +of the table currently previewed. Numeric native evidence segments are not +physical Excel print pages. + +See the [workbook inspection guide](../../guides/inspect-excel-workbooks.md) and +the [Document Search reference](../../reference/actions/document-search.md). + +## Validation and limitations + +Coverage includes real OOXML packages, canonical comment counts and contents, +saved/blank/uncached cell distinctions, final chat evidence, private-store +paging and authorization, table-aware previews, image anchors, and styled +desktop/mobile Playwright interaction. + +Relevant suites are `functional_tests/test_excel_*`, +`functional_tests/test_document_accessibility_report_action.py`, the tabular +analysis/replay suites, and `ui_tests/test_v2_excel_citation_inspection.py`. + +The investigated specimen's native model evidence contained the three threads +and one reply in 4,125 UTF-8 bytes; its metadata occupied 15,914 serialized bytes +and its original SHA-256 remained unchanged. A synthetic 50,000-row, +12-column worksheet expanded to 22,995,689 XML bytes, above the old 16 MiB +materialized-part ceiling. Its structural manifest occupied 1,746 bytes and a +reader-only CPython `tracemalloc` probe reported a 911,165-byte peak while +discovering the table and reading its last record. This measures traced Python +reader allocations, not total process RSS, analytical DataFrames, or a hosting +capacity guarantee. + +Inspection never recalculates Excel formulas, executes macros/ActiveX/OLE, +refreshes external links, or claims to reproduce Excel rendering. Conditional +formatting and other saved expressions are evidence, not evaluated appearance. +Legacy `.xls` is best effort for information its BIFF reader exposes. Input, +style-sampling, response-byte, and page limits remain explicit; partial evidence +must not be called an exhaustive whole-workbook result. diff --git a/docs/explanation/fixes/EXCEL_COMMENT_CONTENT_AND_TABLE_HEADERS_FIX.md b/docs/explanation/fixes/EXCEL_COMMENT_CONTENT_AND_TABLE_HEADERS_FIX.md new file mode 100644 index 000000000..fea48505b --- /dev/null +++ b/docs/explanation/fixes/EXCEL_COMMENT_CONTENT_AND_TABLE_HEADERS_FIX.md @@ -0,0 +1,91 @@ +# Excel Comment Content and Table Headers Fix + +Fixed in version: **0.261.408**. +Application version is maintained in `application/single_app/config.py`. +Import binding follow-up fixed in version: **0.261.409**. + +## Issue and root cause + +The Excel extractor could read comment text while the native chat handoff sent +only counts and a few shortened relevance excerpts. A request to list every +comment could therefore report that comment contents were unavailable even +though they had been extracted. + +Threaded comments' legacy compatibility copies were also classified as genuine +notes. One investigated specimen contained three threads and one reply plus +three compatibility copies, which appeared as seven independent comments. + +Preview/schema readers assumed the first worksheet row was its single header. +That misrepresented title rows and multiple tables. The V2 spreadsheet popup +also reused the image-specific extraction label. + +## Changes and impact + +Native evidence now prioritizes requested structured records and saved cell +context instead of depending on relevance hits. Compatibility correlation keeps +genuine notes and distinguishes roots, replies, and raw representations. +Long/native inventories remain available through revision-bound pages. +Reviewed publication preserves a native-evidence marker on every search +fragment and caps native search previews at one million characters, including +their markers. Complete inventories remain separately paged; sanitized +publication never republishes original native supplements. + +The shared streaming reader discovers named tables and ordinary regions, with +independent ranges and header locations. The preview and analytical selectors +use those boundaries rather than a worksheet-wide first-row header. +Released workbook schemas are generated from the active published bytes with +the same table-aware reader, including sanitized derivatives. + +The V2 popup labels workbook evidence accurately, identifies the selected sheet +and table/range, shows physical row coordinates, and pages records. Switching +between source sheets with identical values can legitimately leave the visible +values unchanged; this is not itself a switching defect. + +Primary components are `excel_workbook_reader.py`, +`functions_excel_accessibility.py`, `functions_excel_inventory.py`, +`functions_search_service.py`, `functions_documents.py`, the chat/tabular +adapters, and `EnhancedCitationViewer.tsx`. + +## Before and after + +| Before | After | +| --- | --- | +| Counts could reach the answer without comment text. | Requested comment records and available saved values are supplied together. | +| Compatibility notes inflated user-facing counts. | Genuine notes, threads, replies, and compatibility copies are distinguished. | +| A title could become the header for every worksheet table. | Each table/range has its own declared or explicitly inferred headers. | +| Large native records were lost at preview limits. | Parent previews are bounded; complete records have source-bound continuations. | +| Spreadsheet evidence was labelled as an image. | Workbook/CSV evidence has the appropriate label and stays tied to its citation. | + +## Validation + +Regression coverage uses real packages and inspects actual record contents and +final handoff text, including no relevance hits, blank cells, missing caches, +late rows, multiple tables, and unchanged original bytes. Private-store tests +cover restart/paging, revocation, source-bound cursors, failures, and cleanup. +UI tests exercise different and identical sheets, five tables, the 50,000th +record, error recovery, keyboard navigation, and desktop/mobile layout. + +### Import binding follow-up + +PR #1891's CodeQL alerts 5132 and 5136 identified a captured UUID factory and +mixed imports in the native-evidence test. `functions_excel_inventory.py` now +resolves `uuid.uuid4()` when creating each generation, so a factory replacement +after import is observed. The native-evidence test consistently uses its existing +`excel` module import. Neither change moves deferred imports or alters bootstrap, +authorization, source binding, storage format, or the inspection interface. + +`test_excel_inventory_persistence.py` replaces the UUID factory twice after the +inventory module is loaded, verifies the expected immutable generation keys, +reads both generations' complete comment records, and checks factory restoration. +The regression fails with the former imported function binding. Both updated +tests record version **0.261.409**, matching the single patch increment in +`application/single_app/config.py`. + +Focused offline validation passes all **16** inventory/native-evidence tests +under normal Python and all **16** under optimized Python. Documentation coverage +passes **7/7** checks and site quality **6/6**. The Cosmos response-boundary +inventory remains unchanged at **1,085 owners**, **425 doubles**, and **zero +review gaps**, so no storage-boundary reclassification is needed. + +See [Scalable Excel Native Inspection](../features/EXCEL_NATIVE_INSPECTION.md) +for the storage contract, test suites, and saved-state limitations. diff --git a/docs/explanation/release_notes.md b/docs/explanation/release_notes.md index 8d99cf09b..e93b68e27 100644 --- a/docs/explanation/release_notes.md +++ b/docs/explanation/release_notes.md @@ -2,6 +2,38 @@ For feature-focused and fix-focused drill-downs by version, see [Features by Version](https://github.com/microsoft/simplechat/tree/main/docs/explanation/features) and [Fixes by Version](https://github.com/microsoft/simplechat/tree/main/docs/explanation/fixes). +### **(v0.261.408)** + +#### Bug Fixes + +* **Excel Comment Contents And Correct Thread Counts** + * Supplies actual native comment records and saved cell context to chat instead of only counts and shortened relevance excerpts. Reviewer requests remain separate from worksheet values. + * Distinguishes genuine legacy notes, threaded roots/replies, and identifiable compatibility copies so mirrored comments do not inflate counts. + * Existing retained originals can be inspected without re-uploading; missing formula caches remain unavailable rather than becoming zero. + * (Ref: `functions_excel_accessibility.py`, `functions_excel_inventory.py`, `functions_search_service.py`, `route_backend_chats.py`, `docs/explanation/fixes/EXCEL_COMMENT_CONTENT_AND_TABLE_HEADERS_FIX.md`) + +#### New Features + +* **Scalable, Table-Aware Saved Excel Inspection** + * Discovers independent named tables and ordinary cell blocks with their own ranges, title/header rows, and source coordinates across worksheets. + * Keeps compact document metadata while full native inventories use private, revision-bound pages. Analytical selection and durable replay retain table/range/header context. + * Adds saved properties, links/validation, readable chart/object content, and configured Office-image analysis with available Excel anchors. Formulas, macros, and external links are never executed/refreshed. + * (Ref: `excel_workbook_reader.py`, `tabular_processing_plugin.py`, `functions_tabular_generated_exports.py`, `docs/explanation/features/EXCEL_NATIVE_INSPECTION.md`) + +#### User Interface Enhancements + +* **Workbook Citation Tables And Bounded Record Navigation** + * Identifies the selected worksheet/table and actual header/row locations, with table selection, record paging, record jumps, keyboard navigation, and retryable selection errors. + * Uses workbook/CSV evidence labels instead of image wording and keeps the originally cited passage independent of preview navigation. + * (Ref: `EnhancedCitationViewer.tsx`, `route_enhanced_citations.py`, `docs/guides/inspect-excel-workbooks.md`) + +#### Breaking Changes + +* **Legacy Queued Workbook Replay Requires Restart** + * Pending workbook computations using v1 worksheet-header descriptors no longer resume under changed table/header semantics. + * **Migration**: Start a new computation to pin the intended worksheet/table/range and header. Existing completed exports are unchanged; CSV replay compatibility is retained. + * (Ref: `functions_tabular_generated_exports.py`, versioned workbook source descriptors) + ### **(v0.261.392)** #### Bug Fixes diff --git a/docs/guides/inspect-excel-workbooks.md b/docs/guides/inspect-excel-workbooks.md new file mode 100644 index 000000000..0853468f9 --- /dev/null +++ b/docs/guides/inspect-excel-workbooks.md @@ -0,0 +1,76 @@ +--- +layout: page +title: "Inspect Excel data, comments, and structure" +description: "Read workbook feedback and metadata without confusing them with saved values or table calculations." +section: "Guides" +audience: user +version: "0.261.408" +--- + +Implemented in version: **0.261.408**, tracked in +`application/single_app/config.py`. + +## Ask about the file and its data separately + +Select the intended workspace workbook. To review feedback, ask: + +> List the genuine cell notes and threaded comments. Include worksheet/cell, +> saved value, author, text, replies, and available timestamps/status. +> Separate requested changes from the workbook's actual values. + +To compute business results, name the worksheet and table or range: + +> Describe the tables on Budget, then calculate total Amount for the Costs +> table. Do not combine other tables on that worksheet. + +An Excel cell can contain a saved formula without a cached result. SimpleChat +can report the formula, but it does not calculate Excel formulas or treat that +missing cache as zero. Recalculate/save in Excel when those results are needed. + +## Choose the actual table and headers + +A worksheet may contain title rows, five separate tables, or repeated printed +headers. Named Excel tables provide saved boundaries. Ordinary blocks have +detected boundaries and labelled inferred headers. When a header is ambiguous, +clarify the actual worksheet header row or that the range has no header. + +A schema preview is a sample. Use tabular analysis for exact counts, filters, +totals, and grouped results over all intended records. + +## Inspect a citation + +Open the workbook citation. The viewer identifies the selected worksheet, +table/range, and header row. Choose another **Table** when several regions are +present. Use **Previous records**, **Next records**, or **Go to record** for +large data. Record positions count data records; the left-hand row labels are +the original worksheet row numbers. + +**Cited workbook evidence** remains the passage supporting the answer. Switching +the preview does not rewrite it. Two different sheets may contain identical +values; use the visible worksheet identity and their metadata/comments rather +than assuming identical values mean the tab did not switch. + +## Large comment and metadata inventories + +An agent with Document Search can use +`get_document_accessibility_report(native_section="comments")` and follow each +`next_cursor` until `has_more` is false. Other sections include tables, objects, +properties, links, validation, and available image-analysis records. Direct cell +inspection accepts a worksheet and bounded A1 range. + +Returned pages, shortened parent previews, and explicit long-record fragments +are not exhaustive results. Check coverage and continuations before claiming +every comment or metadata record has been read. + +## Existing files and limitations + +Re-uploading is usually unnecessary when the active workbook is already stored. +Native inspection can generate new details from that retained original. +Configured image analysis may need reprocessing; ordinary metadata reads do not +silently run new vision analysis. If neither source bytes nor the needed +inventory remain, re-upload the file through the normal authorized workflow. + +Held/revoked sources require the appropriate access or review resolution. +Inspection never runs macros, ActiveX, embedded programs, or external refreshes, +and saved formatting is not a reproduction of Excel's rendered appearance. +Legacy `.xls` has narrower native coverage. diff --git a/docs/reference/actions/document-search.md b/docs/reference/actions/document-search.md index 98b124b94..fef603be6 100644 --- a/docs/reference/actions/document-search.md +++ b/docs/reference/actions/document-search.md @@ -52,11 +52,30 @@ From **0.261.399**, workspace Excel files also expose native workbook properties - Choose which parts to return with `sections` (`accessibility`, `style`, `issues`); all are returned by default. - Pass `page_number` to also get that page, slide or Excel indexed evidence segment's stored text. Excel segment numbers are not physical print-page numbers. -- Chat uploads are not supported; add the file to a workspace. Documents uploaded before this data was extracted need to be re-uploaded. +- The stored workspace report does not grant access to chat uploads. For an existing workspace Excel file, retained active source bytes can be inspected on demand without re-uploading; unavailable originals need the normal re-upload/reprocessing workflow. - The issues list is heuristic. It is not a formal WCAG, Section 508, or PDF/UA conformance check. To apply your own rules, write them into the agent's instructions and have it compare them with the returned values. See [Document accessibility, structure, and comment extraction](https://github.com/microsoft/simplechat/blob/13db876626a043e2c7b30f054354f07c9a1633b9/docs/explanation/features/DOCUMENT_ACCESSIBILITY_AND_STRUCTURE_EXTRACTION.md) for what is extracted for each file type. +### Paged Excel inspection + +Implemented in version: **0.261.408** (`application/single_app/config.py`). +Use `native_section` to request `comments`, `tables`, `objects`, +`property_records`, `custom_properties`, `extended_properties`, `defined_names`, +`hyperlinks`, `validations`, or available `image_analyses`. The default is +`comments`. `native_page_size` accepts 1–200 records, with a separate response +byte bound. Follow `excel_inspection.page.next_cursor` using `native_cursor` +while `has_more` is true. Explicit long JSON record fragments require their +continuation before the record is complete. + +`sheet_name` and `cell_range` read an A1 range of at most 2,000 saved cells, +including formula text/cache availability, without executing formulas. +Compatibility copies of threaded comments are not extra genuine notes. +Native evidence segment citations are not Excel print-page numbers. + +See [Inspect Excel workbooks]({{ '/guides/inspect-excel-workbooks/' | relative_url }}) +for table headers, saved values, and large-file workflows. + Shared wizard steps: [Common action setup steps](../#common-action-setup-steps). ## Related diff --git a/docs/reference/actions/tabular-processing.md b/docs/reference/actions/tabular-processing.md index 7c17ab569..b5a659592 100644 --- a/docs/reference/actions/tabular-processing.md +++ b/docs/reference/actions/tabular-processing.md @@ -46,6 +46,42 @@ Use Tabular Processing when users ask exact questions about spreadsheets or CSV - "Find rows where RenewalDate is in the next 30 days and Status is not Closed." - "Compare the Account sheet to the Tickets sheet and count open tickets by account owner." +## Tables, ranges, and saved formulas + +Implemented in version: **0.261.408** (`application/single_app/config.py`). +Describe a workbook before choosing a table when a worksheet contains several +regions. Named tables retain their saved definitions; ordinary blocks expose +their detected ranges and labelled inferred headers. A title row is not a +header for every table below it. + +Use the analytical operation's table/range/header selectors for the intended +dataset: `table_id` selects a discovered ID or named table; `cell_range` +selects an explicit Excel range and requires `header_row`. Specify the actual +worksheet header row when it is ambiguous; zero means no header. Related-source +operations expose the equivalent `source_` and `target_` selectors. An explicit +`table_id="all"` combines compatible same-schema tables, not unrelated schemas. +Do not silently combine different schemas. Explicit all-table +native jobs retain each selected table's identity through batching and replay. + +Physical worksheet/table/row provenance accompanies Excel row results. +Version-pinned exports preserve the selected ranges and headers instead of +reinterpreting the entire sheet on continuation. Large outputs still use the +existing bounded paging and durable export path. + +Queued workbook computations with legacy v1 worksheet-header descriptors must +be started again so the intended tables/headers can be pinned explicitly. +Previously completed export files are not rewritten. CSV descriptor compatibility +is retained. + +Formula text is inspectable, but analytical values require saved formula +caches. Missing results must not become zero. Recalculate/save the workbook in +Excel if those values are required; SimpleChat does not execute workbook +formulas, macros, or external refreshes. + +For reviewer feedback and workbook properties, use +[Document Search](../document-search/) rather than interpreting comments as data. +See [Inspect Excel workbooks]({{ '/guides/inspect-excel-workbooks/' | relative_url }}). + ## Troubleshooting | Symptom | Likely cause | Fix | diff --git a/docs/reference/chat-controls.md b/docs/reference/chat-controls.md index 52c982699..f87fecab0 100644 --- a/docs/reference/chat-controls.md +++ b/docs/reference/chat-controls.md @@ -4,7 +4,7 @@ title: "Chat interface controls" description: "Reference for every documented control in the SimpleChat chat interface." section: "Reference" audience: user -version: "0.261.406" +version: "0.261.408" --- ## How to use this reference @@ -49,6 +49,23 @@ for source selection, handoff review, and the private-conversation boundary. ## Conversation header and status +### Workbook citation preview + +Implemented in version: **0.261.408** (`application/single_app/config.py`). +Workbook citations show the selected worksheet and table/range independently +from their originally cited passage. + +| V2 control | Purpose | Availability | +| --- | --- | --- | +| Workbook worksheet tabs | Select a worksheet with mouse or Arrow/Home/End keys; the selected identity remains visible even when two sheets have identical values. | Enhanced workbook citation with multiple sheets | +| Table | Chooses one independently detected/named table instead of applying one header to the whole sheet. | Selected sheet has multiple tables | +| Previous records / Next records | Loads a bounded page rather than rendering the entire dataset. | Spreadsheet/CSV citation preview | +| Go to record | Navigates to a one-based data-record position; worksheet row labels preserve physical source coordinates. | Spreadsheet/CSV citation preview | +| Retry preview | Retries a failed selection without relabelling previously loaded data as the failed sheet/table. | Preview load failure | +| Cited workbook evidence / Cited CSV evidence | Shows the original cited extraction passage, not a new passage inferred from preview navigation. | Cited passage is available | + +See [Inspect Excel workbooks]({{ '/guides/inspect-excel-workbooks/' | relative_url }}). + ### Conversation details {% include media.html id="slide-conversation-details" %} diff --git a/functional_tests/cosmos_response_boundaries.json b/functional_tests/cosmos_response_boundaries.json index 6ba53d366..5cc9bdb11 100644 --- a/functional_tests/cosmos_response_boundaries.json +++ b/functional_tests/cosmos_response_boundaries.json @@ -139,12 +139,12 @@ "doubles": { "functional_tests/test_action_credentials_orchestration_continuation.py::test_owned_continue_consumes_only_selected_wait_and_never_replays_completed_steps.continue_wait::point-seam-1": { "boundary": { - "imports_sha256": "082a12e0daa2974ba679862ce9899e4826c9bccd396b63e902310a8abe18acf0", - "kind": "seam", + "sha256": "00949cc48e418c46407d3ceaa70f63b01d4e155796e299e750a4f73d9b87daeb", "methods": [ "read_item" ], - "sha256": "00949cc48e418c46407d3ceaa70f63b01d4e155796e299e750a4f73d9b87daeb" + "kind": "seam", + "imports_sha256": "082a12e0daa2974ba679862ce9899e4826c9bccd396b63e902310a8abe18acf0" }, "classification": "fault-injection", "contract": "The authorization_failure case injects a private read error only on the detached worker; browser reads still delegate to the SDK-default AtomicMemoryContainer. Real continuation must fail the selected interaction durably, retain completed siblings and avoid both action invocation and private-error disclosure.", @@ -154,12 +154,12 @@ }, "functional_tests/test_action_credentials_orchestration_continuation.py::test_saved_wait_authorization_uses_real_isolated_identity::point-seam-1": { "boundary": { - "imports_sha256": "082a12e0daa2974ba679862ce9899e4826c9bccd396b63e902310a8abe18acf0", - "kind": "seam", + "sha256": "e76497bd85e13ddd72c040c71cfe2425c56c3bc03b0a91c014800ca76bc17e40", "methods": [ "read_item" ], - "sha256": "e76497bd85e13ddd72c040c71cfe2425c56c3bc03b0a91c014800ca76bc17e40" + "kind": "seam", + "imports_sha256": "082a12e0daa2974ba679862ce9899e4826c9bccd396b63e902310a8abe18acf0" }, "classification": "fault-injection", "contract": "The storage_failure case raises a private read error instead of returning an easy document. Real action/agent saved-wait authorization propagates storage uncertainty, restores the Flask context and logs only the safe failure stage/type and hashed run identity; other cases retain SDK-default point responses.", @@ -169,12 +169,12 @@ }, "functional_tests/test_action_credentials_orchestration_continuation.py::test_saved_wait_authorization_uses_real_isolated_identity::point-seam-2": { "boundary": { - "imports_sha256": "082a12e0daa2974ba679862ce9899e4826c9bccd396b63e902310a8abe18acf0", - "kind": "seam", + "sha256": "e9be874d64606980d74fbcc54ec3ba5e11ba1245251d44210c5c6c0dc5dddb51", "methods": [ "read_item" ], - "sha256": "e9be874d64606980d74fbcc54ec3ba5e11ba1245251d44210c5c6c0dc5dddb51" + "kind": "seam", + "imports_sha256": "082a12e0daa2974ba679862ce9899e4826c9bccd396b63e902310a8abe18acf0" }, "classification": "fault-injection", "contract": "The allowed case injects a two-worker barrier and records each bridged user/conversation, then returns the original AtomicMemoryContainer.read_item CosmosDict unchanged. Real action/agent authorization must keep overlapping Flask identities isolated and restore both worker contexts; partition routing and ETags remain those of the SDK-default backing container.", @@ -184,12 +184,12 @@ }, "functional_tests/test_action_credentials_shared_conversations.py::test_storage_failure_remains_explicit_and_safe::point-seam-1": { "boundary": { - "imports_sha256": "4876bad40185b8f5f20a21552285691746c2c09c0c3b013295da317e139785e8", - "kind": "seam", + "sha256": "c670cfa0fba919627d4f8597369356ad8bbb01acbcb2eec7210c7e57cc28c3a9", "methods": [ "read_item" ], - "sha256": "c670cfa0fba919627d4f8597369356ad8bbb01acbcb2eec7210c7e57cc28c3a9" + "kind": "seam", + "imports_sha256": "4876bad40185b8f5f20a21552285691746c2c09c0c3b013295da317e139785e8" }, "classification": "fault-injection", "contract": "Scoped read_item failure injection raises an SDK 503 containing a private sentinel. The real credential route must return safe 503 JSON with no-store, not an empty success or private details; all successful points retain the installed SDK default.", @@ -199,15 +199,15 @@ }, "functional_tests/test_action_personal_credentials.py::CredentialContainer": { "boundary": { - "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e", - "inherited_bases": [ - "CosmosContainer" - ], - "kind": "class", + "sha256": "9c086de6148edfd5b4ca6c0a4b86a793dfd9828719464b90c3a82102d3b2933a", "methods": [ "delete_item" ], - "sha256": "9c086de6148edfd5b4ca6c0a4b86a793dfd9828719464b90c3a82102d3b2933a" + "kind": "class", + "inherited_bases": [ + "CosmosContainer" + ], + "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e" }, "classification": "sdk-default", "contract": "Inherits the shared installed-SDK CosmosDict point/write default with ETags and partitions. Queries return plain JSON; conditional deletes enforce IfNotModified before the real shared delete.", @@ -217,12 +217,12 @@ }, "functional_tests/test_action_personal_credentials.py::test_lost_identity_write_responses_keep_committed_keyvault_references::point-seam-1": { "boundary": { - "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e", - "kind": "seam", + "sha256": "8130af2588105a4e56f9e6d59e396d3ff690dd0a0c16e4cb485fa4cebdc252d1", "methods": [ "create_item" ], - "sha256": "8130af2588105a4e56f9e6d59e396d3ff690dd0a0c16e4cb485fa4cebdc252d1" + "kind": "seam", + "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e" }, "classification": "fault-injection", "contract": "Commits through the real SDK-default fake create/replace before throwing a lost-response outage. Owned point confirmation exercises the real identity owner without overriding response shape.", @@ -232,12 +232,12 @@ }, "functional_tests/test_action_personal_credentials.py::test_lost_identity_write_responses_keep_committed_keyvault_references::point-seam-2": { "boundary": { - "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e", - "kind": "seam", + "sha256": "44576681a87e5aa4b91bdfcf0241009a44008b3d6c54b4facb7a8eb6098ecc29", "methods": [ "replace_item" ], - "sha256": "44576681a87e5aa4b91bdfcf0241009a44008b3d6c54b4facb7a8eb6098ecc29" + "kind": "seam", + "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e" }, "classification": "fault-injection", "contract": "Commits through the real SDK-default fake create/replace before throwing a lost-response outage. Owned point confirmation exercises the real identity owner without overriding response shape.", @@ -247,12 +247,12 @@ }, "functional_tests/test_action_personal_credentials.py::test_private_purge_tolerates_concurrent_missing_rows_but_preserves_other_failures::point-seam-1": { "boundary": { - "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e", - "kind": "seam", + "sha256": "e3c717fddf8584360b30dfb42467be61cb94fd756b76510e18abb871a245f4ce", "methods": [ "delete_item" ], - "sha256": "e3c717fddf8584360b30dfb42467be61cb94fd756b76510e18abb871a245f4ce" + "kind": "seam", + "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e" }, "classification": "fault-injection", "contract": "Scoped delete override delegates to the SDK-default conditional container to simulate concurrent 404, or raises explicit 503; it never substitutes easy point/write documents. Real lifecycle-owner test proves not-found idempotence and outage propagation.", @@ -262,12 +262,12 @@ }, "functional_tests/test_action_personal_credentials.py::test_private_purge_tolerates_concurrent_missing_rows_but_preserves_other_failures::point-seam-2": { "boundary": { - "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e", - "kind": "seam", + "sha256": "74155a9b9c2300e9838a0265cf5bf5d088367bfe9fcb9e82e21eba447bba28a1", "methods": [ "delete_item" ], - "sha256": "74155a9b9c2300e9838a0265cf5bf5d088367bfe9fcb9e82e21eba447bba28a1" + "kind": "seam", + "imports_sha256": "3c60a891bc2ca212c159c9619970d0448256e03fdf71912f31c6df713285c75e" }, "classification": "fault-injection", "contract": "Scoped delete override delegates to the SDK-default conditional container to simulate concurrent 404, or raises explicit 503; it never substitutes easy point/write documents. Real lifecycle-owner test proves not-found idempotence and outage propagation.", @@ -277,12 +277,12 @@ }, "functional_tests/test_action_runtime_recovery.py::test_same_http_request_can_reuse_its_claim_but_etag_races_cannot::point-seam-1": { "boundary": { - "imports_sha256": "e654b15af64a72cc0e66617e0f69cad0ab687600402c6b25ba685625b99d8792", - "kind": "seam", + "sha256": "de7d0c468d49bc47c74de70316a82cd8ad3a236d36eb04ee6ae4ee73cd5e0f4b", "methods": [ "replace_item" ], - "sha256": "de7d0c468d49bc47c74de70316a82cd8ad3a236d36eb04ee6ae4ee73cd5e0f4b" + "kind": "seam", + "imports_sha256": "e654b15af64a72cc0e66617e0f69cad0ab687600402c6b25ba685625b99d8792" }, "classification": "fault-injection", "contract": "Scoped replace_item fault injection raises an explicit Cosmos 412 only for a continuation claim; all other operations delegate to the installed-SDK CosmosDict container. The regression proves the injected branch ran once and the real state owner kept the incident pending.", @@ -292,12 +292,12 @@ }, "functional_tests/test_agent_delegation_entrypoints.py::test_actual_stream_stop_finalizer_persists_completed_child_sources_and_usage::point-seam-1": { "boundary": { - "imports_sha256": "c6f70b20f6fb3a9392ffc15cd28a1d6a924a780c90c896dac7a227a01dd4b24f", - "kind": "seam", + "sha256": "e3e0a36ba35b8093999d1f708d2e909bedde133b0bac6a07c38e7c2c4fa50720", "methods": [ "upsert_item" ], - "sha256": "e3e0a36ba35b8093999d1f708d2e909bedde133b0bac6a07c38e7c2c4fa50720" + "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.", @@ -307,12 +307,12 @@ }, "functional_tests/test_agent_delegation_entrypoints.py::test_actual_stream_stop_finalizer_persists_completed_child_sources_and_usage::point-seam-2": { "boundary": { - "imports_sha256": "c6f70b20f6fb3a9392ffc15cd28a1d6a924a780c90c896dac7a227a01dd4b24f", - "kind": "seam", + "sha256": "7b7726438b5811ff6c165186fb27536df6266288d4db3348459d6652abfe3f79", "methods": [ "upsert_item" ], - "sha256": "7b7726438b5811ff6c165186fb27536df6266288d4db3348459d6652abfe3f79" + "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.", @@ -322,13 +322,13 @@ }, "functional_tests/test_ai_connection_embedding_migration.py::MigrationRuntime.__init__::point-seam-1": { "boundary": { - "imports_sha256": "aa19387acd0e45a2c110fe7fac9ed8ed63184e05288090808ae073dd23e7aeeb", - "kind": "seam", + "sha256": "05bb4a21b55f2274ded0e0e073034747efd7404fdf5316cc5d171643e4221876", "methods": [ "read_item", "replace_item" ], - "sha256": "05bb4a21b55f2274ded0e0e073034747efd7404fdf5316cc5d171643e4221876" + "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.", @@ -338,13 +338,13 @@ }, "functional_tests/test_ai_connection_embedding_migration.py::MigrationRuntime.installed::point-seam-1": { "boundary": { - "imports_sha256": "aa19387acd0e45a2c110fe7fac9ed8ed63184e05288090808ae073dd23e7aeeb", - "kind": "seam", + "sha256": "05bb4a21b55f2274ded0e0e073034747efd7404fdf5316cc5d171643e4221876", "methods": [ "read_item", "replace_item" ], - "sha256": "05bb4a21b55f2274ded0e0e073034747efd7404fdf5316cc5d171643e4221876" + "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.", @@ -354,12 +354,12 @@ }, "functional_tests/test_analysis_answer_and_export_data.py::test_workflow_explanation_exports_keep_the_original_source_restrictions::point-seam-1": { "boundary": { - "imports_sha256": "961625a668fb2c09e0a8c08ff17fd44bfaa8ae8dfa7e42a980bfc226342fbbe3", - "kind": "seam", + "sha256": "fb589a1ce6c51f6351d310e5344812ce2a174e11b9fbb085b5223c9b27109ff2", "methods": [ "upsert_item" ], - "sha256": "fb589a1ce6c51f6351d310e5344812ce2a174e11b9fbb085b5223c9b27109ff2" + "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.", @@ -369,12 +369,12 @@ }, "functional_tests/test_analysis_answer_and_export_data.py::test_workflow_explanation_exports_keep_the_original_source_restrictions::point-seam-2": { "boundary": { - "imports_sha256": "961625a668fb2c09e0a8c08ff17fd44bfaa8ae8dfa7e42a980bfc226342fbbe3", - "kind": "seam", + "sha256": "fb589a1ce6c51f6351d310e5344812ce2a174e11b9fbb085b5223c9b27109ff2", "methods": [ "upsert_item" ], - "sha256": "fb589a1ce6c51f6351d310e5344812ce2a174e11b9fbb085b5223c9b27109ff2" + "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.", @@ -384,14 +384,14 @@ }, "functional_tests/test_analysis_artifact_publication.py::MemoryContainer": { "boundary": { - "imports_sha256": "b2bee56464274703f7e48cf3866a2fd222524e3d376715d5800caf01a1f82eed", - "inherited_bases": [], - "kind": "class", + "sha256": "02b8d14bba4e33ed27d612295bcd840172c7c5761c9ee38000d74bf1c84d6ecc", "methods": [ "read_item", "replace_item" ], - "sha256": "02b8d14bba4e33ed27d612295bcd840172c7c5761c9ee38000d74bf1c84d6ecc" + "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.", @@ -401,14 +401,14 @@ }, "functional_tests/test_analysis_artifact_publication.py::test_upload_digest_binds_idempotent_streams_to_actual_bytes_and_producer.Messages": { "boundary": { - "imports_sha256": "b2bee56464274703f7e48cf3866a2fd222524e3d376715d5800caf01a1f82eed", - "inherited_bases": [], - "kind": "class", + "sha256": "8c0f0ae85223251b4253b0473ee463ac9a20f1872eba81c2ea27ab3f293d26ef", "methods": [ "read_item", "upsert_item" ], - "sha256": "8c0f0ae85223251b4253b0473ee463ac9a20f1872eba81c2ea27ab3f293d26ef" + "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.", @@ -418,12 +418,12 @@ }, "functional_tests/test_analysis_artifact_publication.py::test_upload_digest_binds_idempotent_streams_to_actual_bytes_and_producer::point-seam-1": { "boundary": { - "imports_sha256": "b2bee56464274703f7e48cf3866a2fd222524e3d376715d5800caf01a1f82eed", - "kind": "seam", + "sha256": "b0ad08ddd0b13d8f63f6e75084f0aec1c5d2f0e20a1304805d0a792f40ba964a", "methods": [ "read_item" ], - "sha256": "b0ad08ddd0b13d8f63f6e75084f0aec1c5d2f0e20a1304805d0a792f40ba964a" + "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.", @@ -433,12 +433,12 @@ }, "functional_tests/test_analysis_result_store.py::ChatAnalysisResultStoreTests.test_cleanup_tolerates_objects_disappearing_during_conditional_deletion::point-seam-1": { "boundary": { - "imports_sha256": "58f8293350c3be2e466e6ade0d130c017f38eacfbb21b50cc32953ad786a61cc", - "kind": "seam", + "sha256": "20ba34b2909f5d28ffe593c274e267fe1efd1e681ebcc5c6b49c32fb0f5acc90", "methods": [ "delete_item" ], - "sha256": "20ba34b2909f5d28ffe593c274e267fe1efd1e681ebcc5c6b49c32fb0f5acc90" + "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.", @@ -448,12 +448,12 @@ }, "functional_tests/test_analysis_unavailable_message_families.py::test_former_bare_raises_name_the_container_that_failed::point-seam-1": { "boundary": { - "imports_sha256": "921977db01f354bbc5bec922a32d8efe61255413cbf1610bd60eb943ccf03aac", - "kind": "seam", + "sha256": "9755b148463f42ec88f59ddadd36f81f8faeb8e2c69b7de5edf1fae754c0c462", "methods": [ "read_item" ], - "sha256": "9755b148463f42ec88f59ddadd36f81f8faeb8e2c69b7de5edf1fae754c0c462" + "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.", @@ -463,12 +463,12 @@ }, "functional_tests/test_analysis_unavailable_message_families.py::test_former_bare_raises_name_the_container_that_failed::point-seam-2": { "boundary": { - "imports_sha256": "921977db01f354bbc5bec922a32d8efe61255413cbf1610bd60eb943ccf03aac", - "kind": "seam", + "sha256": "1c3e9e0860d18c848c15b12fe91f66830b8b1c2759b73a16942647040682b1cc", "methods": [ "read_item" ], - "sha256": "1c3e9e0860d18c848c15b12fe91f66830b8b1c2759b73a16942647040682b1cc" + "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.", @@ -478,15 +478,15 @@ }, "functional_tests/test_analyze_backend_saved_integration.py::MessageStore": { "boundary": { - "imports_sha256": "2cc597c86bbe58da4c04c65c66484b1ef45ac65e6f21d26b7ba00f7dfc74e3a8", - "inherited_bases": [], - "kind": "class", + "sha256": "ba224936d2f9c87d6cd6aabe228e8d0c141491602c09fff2cc100cabc9465743", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "ba224936d2f9c87d6cd6aabe228e8d0c141491602c09fff2cc100cabc9465743" + "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.", @@ -496,12 +496,12 @@ }, "functional_tests/test_analyze_backend_saved_integration.py::chat::point-seam-1": { "boundary": { - "imports_sha256": "2cc597c86bbe58da4c04c65c66484b1ef45ac65e6f21d26b7ba00f7dfc74e3a8", - "kind": "seam", + "sha256": "4a48d15a44e25c7338da8de520ed4cecd3858059bbad30a07dd893a592df2db1", "methods": [ "upsert_item" ], - "sha256": "4a48d15a44e25c7338da8de520ed4cecd3858059bbad30a07dd893a592df2db1" + "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.", @@ -511,12 +511,12 @@ }, "functional_tests/test_analyze_backend_saved_integration.py::test_direct_analyze_persists_one_assistant_inside_the_merged_guards::point-seam-1": { "boundary": { - "imports_sha256": "2cc597c86bbe58da4c04c65c66484b1ef45ac65e6f21d26b7ba00f7dfc74e3a8", - "kind": "seam", + "sha256": "8d8e38b93d2a588e2274db108e90d7e276301403fff2dfc40831696ce4ce44a7", "methods": [ "upsert_item" ], - "sha256": "8d8e38b93d2a588e2274db108e90d7e276301403fff2dfc40831696ce4ce44a7" + "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.", @@ -526,12 +526,12 @@ }, "functional_tests/test_analyze_live_write_fences.py::test_cached_conversation_update_cannot_erase_a_racing_deletion_marker::point-seam-1": { "boundary": { - "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2", - "kind": "seam", + "sha256": "06b1ca512cd2613e10dcabb8fe392462c4a1d6954f59398f6495ab7623eb4cc0", "methods": [ "replace_item" ], - "sha256": "06b1ca512cd2613e10dcabb8fe392462c4a1d6954f59398f6495ab7623eb4cc0" + "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.", @@ -541,12 +541,12 @@ }, "functional_tests/test_analyze_live_write_fences.py::test_deleted_followup_turn_cannot_publish_a_late_explanation::point-seam-1": { "boundary": { - "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2", - "kind": "seam", + "sha256": "720b3db2b9a0b587f737283fe835846b8ac13d6742bdb8516984038c74995206", "methods": [ "delete_item" ], - "sha256": "720b3db2b9a0b587f737283fe835846b8ac13d6742bdb8516984038c74995206" + "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.", @@ -556,12 +556,12 @@ }, "functional_tests/test_analyze_live_write_fences.py::test_deleted_followup_turn_cannot_publish_a_late_explanation::point-seam-2": { "boundary": { - "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2", - "kind": "seam", + "sha256": "e8e410ae2dcf0a383212c66070d73c01aaad5f7267fbd60a494fa3ab7ccb1e86", "methods": [ "upsert_item" ], - "sha256": "e8e410ae2dcf0a383212c66070d73c01aaad5f7267fbd60a494fa3ab7ccb1e86" + "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.", @@ -571,12 +571,12 @@ }, "functional_tests/test_analyze_live_write_fences.py::test_stop_between_guard_read_and_payload_batch_is_conditional::point-seam-1": { "boundary": { - "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2", - "kind": "seam", + "sha256": "c6da310aeae94a86a8eaaf0c59fa9c56d1fac638c076bfb47aba5be94caf7718", "methods": [ "execute_item_batch" ], - "sha256": "c6da310aeae94a86a8eaaf0c59fa9c56d1fac638c076bfb47aba5be94caf7718" + "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.", @@ -586,12 +586,12 @@ }, "functional_tests/test_analyze_live_write_fences.py::test_user_turn_retry_association_is_conditional_and_actor_bound::point-seam-1": { "boundary": { - "imports_sha256": "18f903c8799401a2786b0d565aa77f973e421fe61f709769944279076cf5fbb2", - "kind": "seam", + "sha256": "0b12bf18a89efed4322432076349135a3044ab90a6a8bee1084bb33c83911519", "methods": [ "replace_item" ], - "sha256": "0b12bf18a89efed4322432076349135a3044ab90a6a8bee1084bb33c83911519" + "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.", @@ -601,12 +601,12 @@ }, "functional_tests/test_app_settings_embedding_write_guard.py::test_guard_covers_cas_and_shared_publication::point-seam-1": { "boundary": { - "imports_sha256": "3552d865b4ba560436058e86bcc1046123d6e88227bfda938ca643739710be2e", - "kind": "seam", + "sha256": "4122ca217ffb775c67d9830829e934175b32f8f1e1c2a188c2c5721e0e2e6ccb", "methods": [ "replace_item" ], - "sha256": "4122ca217ffb775c67d9830829e934175b32f8f1e1c2a188c2c5721e0e2e6ccb" + "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.", @@ -616,15 +616,15 @@ }, "functional_tests/test_app_settings_import_boundaries.py::embedded-BOOTSTRAP_PROBE::Container": { "boundary": { - "embedded_source_sha256": "18937bdc7fb9a63dd52b3e6ceba1048289c8c41b2d5ebdf74f6320e0939776d0", - "imports_sha256": "5d7607d00227de444f1b96c124f2e08824c04641e25c293b045f57fa0a9b8741", - "inherited_bases": [], - "kind": "class", + "sha256": "ebbde58700931bdeb95e344bdf8030e4f996665a5c89880c7fb9d8a4cf9643a3", "methods": [ "read_item", "upsert_item" ], - "sha256": "ebbde58700931bdeb95e344bdf8030e4f996665a5c89880c7fb9d8a4cf9643a3" + "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.", @@ -634,15 +634,15 @@ }, "functional_tests/test_app_settings_store_consistency.py::FakeCosmos": { "boundary": { - "imports_sha256": "bb763bdfe08cb3d88be9ce9693bcf0fa1a678501a70c304ccf1af8c8a8e34fe9", - "inherited_bases": [], - "kind": "class", + "sha256": "4f5de21abf8aabbf5deec4e2439a8a4e396be30306eaaeb074c2d008d8e8d4de", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "4f5de21abf8aabbf5deec4e2439a8a4e396be30306eaaeb074c2d008d8e8d4de" + "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.", @@ -652,13 +652,13 @@ }, "functional_tests/test_approval_notification_routing_fix.py::FakeActivityLogsContainer": { "boundary": { - "imports_sha256": "b84eacfda6d9cef33ff56945a3bcd2aabc764a8b7841c7dc5b6ae0469f6dcf7f", - "inherited_bases": [], - "kind": "class", + "sha256": "06d297c76039334bd2adf624ac90b8fcc7d0b8d9fdb91e40e44c0907f668159b", "methods": [ "create_item" ], - "sha256": "06d297c76039334bd2adf624ac90b8fcc7d0b8d9fdb91e40e44c0907f668159b" + "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.", @@ -668,15 +668,15 @@ }, "functional_tests/test_approval_notification_routing_fix.py::FakeApprovalsContainer": { "boundary": { - "imports_sha256": "b84eacfda6d9cef33ff56945a3bcd2aabc764a8b7841c7dc5b6ae0469f6dcf7f", - "inherited_bases": [], - "kind": "class", + "sha256": "57f85161ce13bc8217d7dafd26c6f1fa2cedc749bbb6298deb6fdbcae6a00054", "methods": [ "create_item", "read_item", "upsert_item" ], - "sha256": "57f85161ce13bc8217d7dafd26c6f1fa2cedc749bbb6298deb6fdbcae6a00054" + "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.", @@ -686,15 +686,15 @@ }, "functional_tests/test_approval_notification_routing_fix.py::FakeNotificationContainer": { "boundary": { - "imports_sha256": "b84eacfda6d9cef33ff56945a3bcd2aabc764a8b7841c7dc5b6ae0469f6dcf7f", - "inherited_bases": [], - "kind": "class", + "sha256": "80ea1aa9cbbda01072f8233283de92d3795b66e604647b635966cff34ae238ad", "methods": [ "create_item", "delete_item", "upsert_item" ], - "sha256": "80ea1aa9cbbda01072f8233283de92d3795b66e604647b635966cff34ae238ad" + "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.", @@ -704,15 +704,15 @@ }, "functional_tests/test_approval_notification_routing_fix.py::FakeTemplateContainer": { "boundary": { - "imports_sha256": "b84eacfda6d9cef33ff56945a3bcd2aabc764a8b7841c7dc5b6ae0469f6dcf7f", - "inherited_bases": [], - "kind": "class", + "sha256": "5be2324ac9a6fb293441736b080efd98107df7cf819acb0761b7836f2e434f82", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "5be2324ac9a6fb293441736b080efd98107df7cf819acb0761b7836f2e434f82" + "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.", @@ -722,13 +722,13 @@ }, "functional_tests/test_authenticated_request_login_activity.py::FakeContainer": { "boundary": { - "imports_sha256": "3ed7624a4d63e0906e428793cad7fc762b2a01d14c1ef210ae8c19447262ff1f", - "inherited_bases": [], - "kind": "class", + "sha256": "84bc5b272353ee11d453c834f8b72b462807ae8786461f9f1fa099b18b50868e", "methods": [ "create_item" ], - "sha256": "84bc5b272353ee11d453c834f8b72b462807ae8786461f9f1fa099b18b50868e" + "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.", @@ -738,13 +738,13 @@ }, "functional_tests/test_broken_access_control_findings_fix.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "f97ceaaa05b0f633db9bb614191f973bb8faf8322e9ab2cd639bc227848f79cb", - "inherited_bases": [], - "kind": "class", + "sha256": "12a4cfd9fbeaf69cf210806637d5950a885570d6edc0d986e3c85689f9400f30", "methods": [ "read_item" ], - "sha256": "12a4cfd9fbeaf69cf210806637d5950a885570d6edc0d986e3c85689f9400f30" + "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.", @@ -754,13 +754,13 @@ }, "functional_tests/test_chat_activity_logging_consistency.py::FakeCreateItemContainer": { "boundary": { - "imports_sha256": "fec79c76b8b8d19ff06c115f0cdffa0e78f730c7a0fdedabdf35bd1d9a802651", - "inherited_bases": [], - "kind": "class", + "sha256": "af6fe12d5c2c650b8bddf8f780e810f45eba847d3589f645704c8a6c16777533", "methods": [ "create_item" ], - "sha256": "af6fe12d5c2c650b8bddf8f780e810f45eba847d3589f645704c8a6c16777533" + "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.", @@ -770,13 +770,13 @@ }, "functional_tests/test_chat_activity_logging_consistency.py::FakeUpsertContainer": { "boundary": { - "imports_sha256": "fec79c76b8b8d19ff06c115f0cdffa0e78f730c7a0fdedabdf35bd1d9a802651", - "inherited_bases": [], - "kind": "class", + "sha256": "3d07d4b5fa2bfacff8394ce503e73406bafe6b9c381ff7f9c6e74e636a422868", "methods": [ "upsert_item" ], - "sha256": "3d07d4b5fa2bfacff8394ce503e73406bafe6b9c381ff7f9c6e74e636a422868" + "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.", @@ -786,13 +786,13 @@ }, "functional_tests/test_chat_artifact_download_bytes.py::SnapshotContainer": { "boundary": { - "imports_sha256": "081bd1a8c570e7a3704106db0b3cf9fdcad9ac6e33c84f42662e4a34a232133e", - "inherited_bases": [], - "kind": "class", + "sha256": "b88da2c7be88197616f1c1c6c33140a27a64dbf6100d97c1ea37692b2bb9b67a", "methods": [ "read_item" ], - "sha256": "b88da2c7be88197616f1c1c6c33140a27a64dbf6100d97c1ea37692b2bb9b67a" + "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.", @@ -802,14 +802,14 @@ }, "functional_tests/test_chat_completion_notifications.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "f2ffd1bb87a6a55b45b8a4a51a35da2d49d9e68c5b1ecccbe869a331a984ddfb", - "inherited_bases": [], - "kind": "class", + "sha256": "068a24534d52e96bd7acb95c6627827537ba2af11df26665ad5b56a0bee55646", "methods": [ "read_item", "upsert_item" ], - "sha256": "068a24534d52e96bd7acb95c6627827537ba2af11df26665ad5b56a0bee55646" + "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.", @@ -819,14 +819,14 @@ }, "functional_tests/test_chat_completion_notifications.py::FakeNotificationContainer": { "boundary": { - "imports_sha256": "f2ffd1bb87a6a55b45b8a4a51a35da2d49d9e68c5b1ecccbe869a331a984ddfb", - "inherited_bases": [], - "kind": "class", + "sha256": "8180c7e62c96d63f340781917d8e92974d170485a4def27397920f3dea1fa3ea", "methods": [ "create_item", "upsert_item" ], - "sha256": "8180c7e62c96d63f340781917d8e92974d170485a4def27397920f3dea1fa3ea" + "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.", @@ -836,15 +836,15 @@ }, "functional_tests/test_chat_content_review.py::MemoryContainer": { "boundary": { - "imports_sha256": "fe92ff542fcfef00aeb73007c07492571ce7d532d3ff1203f4945e4a7ce61742", - "inherited_bases": [], - "kind": "class", + "sha256": "9f3c1f4cf9d89382cb81b72607e98dfc14e8aeb087acce36aa2f892694671760", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "9f3c1f4cf9d89382cb81b72607e98dfc14e8aeb087acce36aa2f892694671760" + "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.", @@ -854,14 +854,14 @@ }, "functional_tests/test_chat_retry_attempt_lifecycle.py::AttemptContainer": { "boundary": { - "imports_sha256": "d79f3089ee119b3090c118dcd4a147cbf937a221a0169f47a2d9db2b7db6feae", - "inherited_bases": [], - "kind": "class", + "sha256": "b6dc5887981e863f45cc7d2c14575fa6cf817eb4ef0becd49a79e06075a94e14", "methods": [ "create_item", "replace_item" ], - "sha256": "b6dc5887981e863f45cc7d2c14575fa6cf817eb4ef0becd49a79e06075a94e14" + "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.", @@ -871,15 +871,15 @@ }, "functional_tests/test_chat_retry_import_boundaries.py::embedded-EARLY_PROBE::Store": { "boundary": { - "embedded_source_sha256": "9d508b48960fb173104836cc6eabcea7ce919fdffe73187d03a52afcf0d674a0", - "imports_sha256": "2aad9254c24a9d1a43390bef7aad3a73dc02e5ad9d004d01db54fe6e6d2ea3ce", - "inherited_bases": [], - "kind": "class", + "sha256": "a43ae348daab1439d8ba944ceb7f43234cb14995c0601124f3a6343d83020da8", "methods": [ "read_item", "replace_item" ], - "sha256": "a43ae348daab1439d8ba944ceb7f43234cb14995c0601124f3a6343d83020da8" + "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.", @@ -889,16 +889,16 @@ }, "functional_tests/test_chat_soft_deleted_message_visibility_fix.py::FakeContainer": { "boundary": { - "imports_sha256": "e1feacfe578c5d6865f7db5a95d5d690b3d8e0e0a1dee57a0c489d6a112cd535", - "inherited_bases": [], - "kind": "class", + "sha256": "ed4179ce1741552c67053fde5a85a7884294c04cc1fcf6e6774d517c8436dc6b", "methods": [ "delete_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "ed4179ce1741552c67053fde5a85a7884294c04cc1fcf6e6774d517c8436dc6b" + "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.", @@ -908,14 +908,14 @@ }, "functional_tests/test_chats_user_settings_hardening_fix.py::FakeContainer": { "boundary": { - "imports_sha256": "0ea9b5e92c69e14a31f1d7d2ac12522a19585e6469c06352edddce0b09822670", - "inherited_bases": [], - "kind": "class", + "sha256": "8bac7795ceca120f440f8ad50adcaddbfd7b66bf432986c2468f3802fad6a807", "methods": [ "read_item", "upsert_item" ], - "sha256": "8bac7795ceca120f440f8ad50adcaddbfd7b66bf432986c2468f3802fad6a807" + "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.", @@ -925,13 +925,13 @@ }, "functional_tests/test_collaboration_conversation_summary_export_fix.py::FailingLegacyConversationContainer": { "boundary": { - "imports_sha256": "c833900e2f24aad948933f18f6b938a0c5f806dafeada4f4e1174585c724d3f9", - "inherited_bases": [], - "kind": "class", + "sha256": "bf54b68678d7c9c3a9643a8f4dc2119cb6e4a40277326bd8f22921d8bad3012a", "methods": [ "read_item" ], - "sha256": "bf54b68678d7c9c3a9643a8f4dc2119cb6e4a40277326bd8f22921d8bad3012a" + "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.", @@ -941,13 +941,13 @@ }, "functional_tests/test_collaboration_conversation_summary_export_fix.py::FakeCollaborationConversationContainer": { "boundary": { - "imports_sha256": "c833900e2f24aad948933f18f6b938a0c5f806dafeada4f4e1174585c724d3f9", - "inherited_bases": [], - "kind": "class", + "sha256": "a8a8acf7dfa56b647b960ae317b6711433d335913cde8b3eee081b966ade78da", "methods": [ "upsert_item" ], - "sha256": "a8a8acf7dfa56b647b960ae317b6711433d335913cde8b3eee081b966ade78da" + "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.", @@ -957,14 +957,14 @@ }, "functional_tests/test_collaboration_group_agent_stream_fix.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "49ba2176247c489174b415c8b12d17bcb326b0bd5098d7fddefe917b7924641d", - "inherited_bases": [], - "kind": "class", + "sha256": "0750b24d9ef4abd518ab393d6035bcca4448408926d2d40f2900eb07401077e8", "methods": [ "read_item", "upsert_item" ], - "sha256": "0750b24d9ef4abd518ab393d6035bcca4448408926d2d40f2900eb07401077e8" + "kind": "class", + "inherited_bases": [], + "imports_sha256": "49ba2176247c489174b415c8b12d17bcb326b0bd5098d7fddefe917b7924641d" }, "classification": "sdk-default", "contract": "Collaboration stream test container returns installed SDK CosmosDict point/upsert responses by default while preserving deep-copied document isolation.", @@ -974,14 +974,14 @@ }, "functional_tests/test_collaboration_group_agent_stream_fix.py::FakeItemContainer": { "boundary": { - "imports_sha256": "49ba2176247c489174b415c8b12d17bcb326b0bd5098d7fddefe917b7924641d", - "inherited_bases": [], - "kind": "class", + "sha256": "70ab5ea4246065bb9fa91c39548c9b2778d6ebf5da5228bdfa78b7baaf1e97b9", "methods": [ "read_item", "upsert_item" ], - "sha256": "70ab5ea4246065bb9fa91c39548c9b2778d6ebf5da5228bdfa78b7baaf1e97b9" + "kind": "class", + "inherited_bases": [], + "imports_sha256": "49ba2176247c489174b415c8b12d17bcb326b0bd5098d7fddefe917b7924641d" }, "classification": "sdk-default", "contract": "Collaboration stream test container returns installed SDK CosmosDict point/upsert responses by default while preserving deep-copied document isolation.", @@ -991,13 +991,13 @@ }, "functional_tests/test_collaboration_message_delete_fix.py::FakeCollaborationMessageContainer": { "boundary": { - "imports_sha256": "688c03c398ff84c5c57263cc3ea4eed9ed2c7b97aa8124a619b93fe18bff95ee", - "inherited_bases": [], - "kind": "class", + "sha256": "a6b39b3acbe8fcaa3cf81b1f0d136301c7dfa4cab007e306d099dd2d23f01292", "methods": [ "delete_item" ], - "sha256": "a6b39b3acbe8fcaa3cf81b1f0d136301c7dfa4cab007e306d099dd2d23f01292" + "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.", @@ -1007,14 +1007,14 @@ }, "functional_tests/test_collaboration_message_delete_fix.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "688c03c398ff84c5c57263cc3ea4eed9ed2c7b97aa8124a619b93fe18bff95ee", - "inherited_bases": [], - "kind": "class", + "sha256": "e1dabc2fb3875f43ba2d00f6d88957a577acc41132fbb6f6dc6030ab4b4c54dc", "methods": [ "read_item", "upsert_item" ], - "sha256": "e1dabc2fb3875f43ba2d00f6d88957a577acc41132fbb6f6dc6030ab4b4c54dc" + "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.", @@ -1024,13 +1024,13 @@ }, "functional_tests/test_collaboration_message_notifications.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "fb887b17ebf65dc427c928b051c1d42b2ae12d5f826b2a811e601c02fb66e229", - "inherited_bases": [], - "kind": "class", + "sha256": "3104cd803a5b90841b73932d1e2baacfe0bf755c8ca526a1d0640d6c198175ce", "methods": [ "read_item" ], - "sha256": "3104cd803a5b90841b73932d1e2baacfe0bf755c8ca526a1d0640d6c198175ce" + "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.", @@ -1040,14 +1040,14 @@ }, "functional_tests/test_collaboration_message_notifications.py::FakeNotificationContainer": { "boundary": { - "imports_sha256": "fb887b17ebf65dc427c928b051c1d42b2ae12d5f826b2a811e601c02fb66e229", - "inherited_bases": [], - "kind": "class", + "sha256": "9ecc3f7d7efacf11c4a45a20482e0fa818e11964289ff354af8b123e7aff4071", "methods": [ "create_item", "upsert_item" ], - "sha256": "9ecc3f7d7efacf11c4a45a20482e0fa818e11964289ff354af8b123e7aff4071" + "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.", @@ -1057,14 +1057,14 @@ }, "functional_tests/test_collaboration_stream_image_completion_fix.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "3a237bd7086828db841a6d42369120b12e07eed263965f09ac5bb3c46b97cb1e", - "inherited_bases": [], - "kind": "class", + "sha256": "70685f738d190cbba9104c9a9b5809d00b4bd1c5b54658af26262d5a0d82ac1a", "methods": [ "read_item", "upsert_item" ], - "sha256": "70685f738d190cbba9104c9a9b5809d00b4bd1c5b54658af26262d5a0d82ac1a" + "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.", @@ -1074,14 +1074,14 @@ }, "functional_tests/test_collaboration_stream_image_completion_fix.py::FakeItemContainer": { "boundary": { - "imports_sha256": "3a237bd7086828db841a6d42369120b12e07eed263965f09ac5bb3c46b97cb1e", - "inherited_bases": [], - "kind": "class", + "sha256": "e01c9508802ce3a8f0ce50244898c7a15aa7b27529acfdbdc610742203ff2782", "methods": [ "read_item", "upsert_item" ], - "sha256": "e01c9508802ce3a8f0ce50244898c7a15aa7b27529acfdbdc610742203ff2782" + "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.", @@ -1091,13 +1091,13 @@ }, "functional_tests/test_content_screening_access.py::FakeContainer": { "boundary": { - "imports_sha256": "30d6c8687ccfa555b47e656a8c240f0e5518b1c222389a109ef93f379361097e", - "inherited_bases": [], - "kind": "class", + "sha256": "5ba63f06185fb56fa377eb078a3478fc31c0289a5a12ab5b7b41f63e031c8384", "methods": [ "read_item" ], - "sha256": "5ba63f06185fb56fa377eb078a3478fc31c0289a5a12ab5b7b41f63e031c8384" + "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.", @@ -1107,14 +1107,14 @@ }, "functional_tests/test_content_screening_activity.py::ActivityContainer": { "boundary": { - "imports_sha256": "591beb432249aedadfb914c9d37a6d76e57c4dbebbe6dfce69787af020bd61c1", - "inherited_bases": [], - "kind": "class", + "sha256": "65c9acb818b67d365d41d2a396813abea4c8a05066e5073e1ee00e3f98c96b48", "methods": [ "create_item", "read_item" ], - "sha256": "65c9acb818b67d365d41d2a396813abea4c8a05066e5073e1ee00e3f98c96b48" + "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.", @@ -1124,12 +1124,12 @@ }, "functional_tests/test_content_screening_model.py::ModelScreeningTests.setUp::point-seam-1": { "boundary": { - "imports_sha256": "a9f2d8670bcf84373644251a2d0a6db96e31fc495c2eb82ac60ca5f10423696b", - "kind": "seam", + "sha256": "9b6aa36423851ac524cf7db0c9b0023d27a2031de4c7ce4e9365f7b94af6a685", "methods": [ "read_item" ], - "sha256": "9b6aa36423851ac524cf7db0c9b0023d27a2031de4c7ce4e9365f7b94af6a685" + "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.", @@ -1139,15 +1139,15 @@ }, "functional_tests/test_content_screening_persistence.py::FakeCosmos": { "boundary": { - "imports_sha256": "52228234e84d23a77c019f61b6263d59b7b367fc06a20163d206bf6c4ad6ab68", - "inherited_bases": [], - "kind": "class", + "sha256": "1a5528339036dba9e842e25188bd085759fdc802a975529c7562c3c85cd0a653", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "1a5528339036dba9e842e25188bd085759fdc802a975529c7562c3c85cd0a653" + "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.", @@ -1157,15 +1157,15 @@ }, "functional_tests/test_content_screening_persistence_lifecycle.py::TransferCosmos": { "boundary": { - "imports_sha256": "a3954f2a795d5d814a3a00c772435ceabcd7063134754049b37d90a7afe33348", - "inherited_bases": [], - "kind": "class", + "sha256": "5b416912a717acdd28ee3f0c4ceafde6a5e14a77ebd7130b23b5e3d063883b62", "methods": [ "create_item", "read_item", "upsert_item" ], - "sha256": "5b416912a717acdd28ee3f0c4ceafde6a5e14a77ebd7130b23b5e3d063883b62" + "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.", @@ -1175,12 +1175,12 @@ }, "functional_tests/test_content_screening_settings_api.py::ScreeningApiTests.setUp::point-seam-1": { "boundary": { - "imports_sha256": "b86279d8962a19604def30220a0c600e8c8b634f3eed6f09cec757441b231e22", - "kind": "seam", + "sha256": "ebf33e52af67942a3151386be88cf0be0a4c926af81fdf91a31441095e129f23", "methods": [ "read_item" ], - "sha256": "ebf33e52af67942a3151386be88cf0be0a4c926af81fdf91a31441095e129f23" + "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.", @@ -1190,13 +1190,13 @@ }, "functional_tests/test_content_screening_upload_only_intake.py::ScanStore": { "boundary": { - "imports_sha256": "8f0947601931ac3e8a20dd7b62d5fbcb029a86ed24240f98e06a15757f1820a5", - "inherited_bases": [], - "kind": "class", + "sha256": "d03d7ea9aa47de5248998d4492c518f34d911f993b2fdda366cfe5d2e734e5c9", "methods": [ "read_item" ], - "sha256": "d03d7ea9aa47de5248998d4492c518f34d911f993b2fdda366cfe5d2e734e5c9" + "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.", @@ -1206,12 +1206,12 @@ }, "functional_tests/test_control_center_group_writers.py::after_first_read::point-seam-1": { "boundary": { - "imports_sha256": "9342c945afcecc5f164655f5d751b5bc850ea337f16ac2dc2a6c98c355a2723c", - "kind": "seam", + "sha256": "a0d566c18636c32ec440ab615ec4cae01fd6a216842cd7e0c98d6884a5b10d7d", "methods": [ "read_item" ], - "sha256": "a0d566c18636c32ec440ab615ec4cae01fd6a216842cd7e0c98d6884a5b10d7d" + "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.", @@ -1221,15 +1221,15 @@ }, "functional_tests/test_conversation_fork.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "18d547c52eda08a030067f28b4c08b3b29ce022605077d8c195a115808589f27", - "inherited_bases": [], - "kind": "class", + "sha256": "d123c8a1d6cb318097112417f47f520bffb9a2232c385f7e4d05ea92e41b9bfa", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "d123c8a1d6cb318097112417f47f520bffb9a2232c385f7e4d05ea92e41b9bfa" + "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.", @@ -1239,15 +1239,15 @@ }, "functional_tests/test_conversation_fork.py::FakeMessageContainer": { "boundary": { - "imports_sha256": "18d547c52eda08a030067f28b4c08b3b29ce022605077d8c195a115808589f27", - "inherited_bases": [], - "kind": "class", + "sha256": "0ceebd0d633dbb71d9c206ec2da6bbf93611e259361ab33e07b24717935833d4", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "0ceebd0d633dbb71d9c206ec2da6bbf93611e259361ab33e07b24717935833d4" + "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.", @@ -1257,13 +1257,13 @@ }, "functional_tests/test_conversation_handoffs.py::HandoffContainer": { "boundary": { - "imports_sha256": "7491e85e63d2e230d901bc707f908f0789660bb963047e40e7e41e7c317a251b", + "sha256": "8e891bd1c9a1af08b6f7354859efb79bbdcfd772d37ce615d2c111238e45434a", + "methods": [], + "kind": "class", "inherited_bases": [ "CosmosContainer" ], - "kind": "class", - "methods": [], - "sha256": "8e891bd1c9a1af08b6f7354859efb79bbdcfd772d37ce615d2c111238e45434a" + "imports_sha256": "7491e85e63d2e230d901bc707f908f0789660bb963047e40e7e41e7c317a251b" }, "classification": "sdk-default", "contract": "Inherits CosmosContainer SDK-default CosmosDict point responses and transactional batch support for handoff queue/lease tests.", @@ -1273,13 +1273,13 @@ }, "functional_tests/test_conversation_references.py::ReferenceContainer": { "boundary": { - "imports_sha256": "b6caaf9f5a016f937da51611f44db0d83fa32d4dcc64f134bf5f61122df3b3db", + "sha256": "65a027d4f7fdd618624f4e60bdc42d0efdf88841bd5a1fa91c1024bdaf7ba2d0", + "methods": [], + "kind": "class", "inherited_bases": [ "CosmosContainer" ], - "kind": "class", - "methods": [], - "sha256": "65a027d4f7fdd618624f4e60bdc42d0efdf88841bd5a1fa91c1024bdaf7ba2d0" + "imports_sha256": "b6caaf9f5a016f937da51611f44db0d83fa32d4dcc64f134bf5f61122df3b3db" }, "classification": "sdk-default", "contract": "Inherits CosmosContainer SDK-default CosmosDict point responses with plain query rows for private conversation reference tests.", @@ -1289,14 +1289,14 @@ }, "functional_tests/test_conversations_read_ownership_authorization.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "592ddce8ee0dd79b708ab83477dbb2480d843dd27332812527dc275d15ed9e9c", - "inherited_bases": [], - "kind": "class", + "sha256": "6b9ca012301696532cbe99ce06c1b4e05047201635573d252f2e90ffd44a01f2", "methods": [ "read_item", "upsert_item" ], - "sha256": "6b9ca012301696532cbe99ce06c1b4e05047201635573d252f2e90ffd44a01f2" + "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.", @@ -1306,13 +1306,13 @@ }, "functional_tests/test_conversations_read_ownership_authorization.py::FakeMessageContainer": { "boundary": { - "imports_sha256": "592ddce8ee0dd79b708ab83477dbb2480d843dd27332812527dc275d15ed9e9c", - "inherited_bases": [], - "kind": "class", + "sha256": "c55ef6419ec7b5dc7a2ecbb5830ecb1664022e0d538203c2dff2d4ad861b4a3c", "methods": [ "read_item" ], - "sha256": "c55ef6419ec7b5dc7a2ecbb5830ecb1664022e0d538203c2dff2d4ad861b4a3c" + "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.", @@ -1322,14 +1322,14 @@ }, "functional_tests/test_cosmos_document_boundaries.py::embedded-source::embedded-PROBE::OfflineContainer": { "boundary": { - "embedded_source_sha256": "5cb5fdf9a3df7e99d93cb8a862391ec7194c532359d8ebe842d029f1451f1c98", - "imports_sha256": "3521e91219551ecc285401f634cdbd9a734fdf711e565c51f67cb7d8dff3bfc8", - "inherited_bases": [], - "kind": "class", + "sha256": "500eeaa57834d5d36c2c33c0568279ec592b31e76e4652a0e24edb476f36ebe2", "methods": [ "read_item" ], - "sha256": "500eeaa57834d5d36c2c33c0568279ec592b31e76e4652a0e24edb476f36ebe2" + "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.", @@ -1339,9 +1339,7 @@ }, "functional_tests/test_cosmos_phase3_shared_cache_metrics.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "2e5da0fc5f42ceb0db06811b601b256e9985f92c4a571a30f5ede8e1b7d487dd", - "inherited_bases": [], - "kind": "class", + "sha256": "0bf8083f3b03b204edd2f422bf771f86ff9b31ef90280600a62145af36fa0559", "methods": [ "create_item", "delete_item", @@ -1349,7 +1347,9 @@ "replace_item", "upsert_item" ], - "sha256": "0bf8083f3b03b204edd2f422bf771f86ff9b31ef90280600a62145af36fa0559" + "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.", @@ -1359,14 +1359,14 @@ }, "functional_tests/test_cosmos_query_plugin.py::FakeConfigCosmosContainer": { "boundary": { - "imports_sha256": "3d8c4f1a5acbd32daf9f94fe19bb05e9dea02a27b0c900db6bd57d938ee59901", - "inherited_bases": [], - "kind": "class", + "sha256": "5b8cac6bb9f86d6868431c2d5e6d65b2a89a9aa4b34fa3d68e3668504409c964", "methods": [ "read_item", "upsert_item" ], - "sha256": "5b8cac6bb9f86d6868431c2d5e6d65b2a89a9aa4b34fa3d68e3668504409c964" + "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.", @@ -1376,9 +1376,7 @@ }, "functional_tests/test_cosmos_wave1_app_maintenance.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "2e5da0fc5f42ceb0db06811b601b256e9985f92c4a571a30f5ede8e1b7d487dd", - "inherited_bases": [], - "kind": "class", + "sha256": "f65b9661b0f4afbc29d28d93fdf4805ad0216a00fcca89698a7a80e3e3711ae9", "methods": [ "create_item", "delete_item", @@ -1386,7 +1384,9 @@ "replace_item", "upsert_item" ], - "sha256": "f65b9661b0f4afbc29d28d93fdf4805ad0216a00fcca89698a7a80e3e3711ae9" + "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.", @@ -1396,9 +1396,7 @@ }, "functional_tests/test_cosmos_wave1_cache_fallback.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "f068f1e3fce9ebbde6e0966d2bee8119adcb8b7dd7498d9b596960c333e9a9da", - "inherited_bases": [], - "kind": "class", + "sha256": "a0987efad2e64e379db5b202faf84e6989fdc4ce0fe55f7b02db0d0b748e47e5", "methods": [ "create_item", "delete_item", @@ -1406,7 +1404,9 @@ "replace_item", "upsert_item" ], - "sha256": "a0987efad2e64e379db5b202faf84e6989fdc4ce0fe55f7b02db0d0b748e47e5" + "kind": "class", + "inherited_bases": [], + "imports_sha256": "f068f1e3fce9ebbde6e0966d2bee8119adcb8b7dd7498d9b596960c333e9a9da" }, "classification": "sdk-default", "contract": "Cache fallback test container returns installed SDK CosmosDict point/write responses by default with ETag generation and IfNotModified checks.", @@ -1416,15 +1416,15 @@ }, "functional_tests/test_cosmos_wave1_cache_fallback.py::StreamAppendConflictContainer": { "boundary": { - "imports_sha256": "f068f1e3fce9ebbde6e0966d2bee8119adcb8b7dd7498d9b596960c333e9a9da", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "648361a62b86ad6e07191cfc6d37f0e236367f000da1a78f7492e3d14dd82d06", "methods": [ "replace_item" ], - "sha256": "648361a62b86ad6e07191cfc6d37f0e236367f000da1a78f7492e3d14dd82d06" + "kind": "class", + "inherited_bases": [ + "FakeCosmosContainer" + ], + "imports_sha256": "f068f1e3fce9ebbde6e0966d2bee8119adcb8b7dd7498d9b596960c333e9a9da" }, "classification": "sdk-default", "contract": "Inherits FakeCosmosContainer SDK-default CosmosDict point/write responses and injects one concurrent 412 conflict before delegating to super().replace_item.", @@ -1434,9 +1434,7 @@ }, "functional_tests/test_cosmos_wave2a_chat_bootstrap_cache.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "cc6b2673fcb8ab1c6032fc3dd3b504ec8179cc7daa154fb39ef1447506a990d0", - "inherited_bases": [], - "kind": "class", + "sha256": "6948558a10feb437cead02c110392334a7c8b1e78f8d299452f5c78e9f1b45f8", "methods": [ "create_item", "delete_item", @@ -1444,7 +1442,9 @@ "replace_item", "upsert_item" ], - "sha256": "6948558a10feb437cead02c110392334a7c8b1e78f8d299452f5c78e9f1b45f8" + "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.", @@ -1454,9 +1454,7 @@ }, "functional_tests/test_cosmos_wave2a_custom_pages_cache.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "2e5da0fc5f42ceb0db06811b601b256e9985f92c4a571a30f5ede8e1b7d487dd", - "inherited_bases": [], - "kind": "class", + "sha256": "4a14f89da4e1978de9823c8921731ff2ee15b50bba6390b3885ed748f8e4de2d", "methods": [ "create_item", "delete_item", @@ -1464,7 +1462,9 @@ "replace_item", "upsert_item" ], - "sha256": "4a14f89da4e1978de9823c8921731ff2ee15b50bba6390b3885ed748f8e4de2d" + "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.", @@ -1474,15 +1474,15 @@ }, "functional_tests/test_cosmos_wave2b_conversation_cache.py::ConflictOnceFakeCosmosContainer": { "boundary": { - "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "d77b6994d2f4551ff214853dfa18c7d3204abbface4f25d8ead7ca761deec87c", "methods": [ "replace_item" ], - "sha256": "d77b6994d2f4551ff214853dfa18c7d3204abbface4f25d8ead7ca761deec87c" + "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.", @@ -1492,9 +1492,7 @@ }, "functional_tests/test_cosmos_wave2b_conversation_cache.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97", - "inherited_bases": [], - "kind": "class", + "sha256": "3bcf0168a5bd42a3ecf8f035298710e426a513f824e009c1717dd19ef09064ca", "methods": [ "create_item", "delete_item", @@ -1502,7 +1500,9 @@ "replace_item", "upsert_item" ], - "sha256": "3bcf0168a5bd42a3ecf8f035298710e426a513f824e009c1717dd19ef09064ca" + "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.", @@ -1512,9 +1512,7 @@ }, "functional_tests/test_cosmos_wave3a_indexing_maintenance.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "18008d80cf9d671fafcc37867b8583636b646ec1b96d387bccc70d740611d87d", - "inherited_bases": [], - "kind": "class", + "sha256": "241bf99d2627ed8cca738a1e4b1a50295146eb1f921cdbed3f5da0664d25e22e", "methods": [ "create_item", "delete_item", @@ -1522,7 +1520,9 @@ "replace_item", "upsert_item" ], - "sha256": "241bf99d2627ed8cca738a1e4b1a50295146eb1f921cdbed3f5da0664d25e22e" + "kind": "class", + "inherited_bases": [], + "imports_sha256": "18008d80cf9d671fafcc37867b8583636b646ec1b96d387bccc70d740611d87d" }, "classification": "sdk-default", "contract": "Point reads and returned creates/replaces/upserts use the installed SDK CosmosDict; nested data and query rows stay plain dictionaries. ETags, immutable partition keys, and conflict fault injection are enforced.", @@ -1532,15 +1532,15 @@ }, "functional_tests/test_cosmos_wave3b_document_access_index.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97", - "inherited_bases": [], - "kind": "class", + "sha256": "4da208451ec70ee785152fd23d7fdabd1eefbcf8c5b3c5d5e7f408734994505a", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "4da208451ec70ee785152fd23d7fdabd1eefbcf8c5b3c5d5e7f408734994505a" + "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.", @@ -1550,15 +1550,15 @@ }, "functional_tests/test_cosmos_wave3b_document_access_index.py::FakeRepairBacklogStateWriteFailContainer": { "boundary": { - "imports_sha256": "49c0848672b0644f77ca08272f3d9869216d4e51fbf2e4f78cadbb47322d3f97", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "9ed06655a2a45a7fc432afe41c1c41aaed2dea1e2cea776f95fcdc2e1f2bbbca", "methods": [ "upsert_item" ], - "sha256": "9ed06655a2a45a7fc432afe41c1c41aaed2dea1e2cea776f95fcdc2e1f2bbbca" + "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.", @@ -1568,15 +1568,15 @@ }, "functional_tests/test_cosmos_wave4a_document_access_backfill.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "592313eb753fe7b168e9549e54c206d2b4ca2c91a235bd8af257c64b11afb22e", - "inherited_bases": [], - "kind": "class", + "sha256": "74175cd3eb3f373e215deef12c6f7860fa71f793d53fae6cd126af8374eab045", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "74175cd3eb3f373e215deef12c6f7860fa71f793d53fae6cd126af8374eab045" + "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.", @@ -1586,15 +1586,15 @@ }, "functional_tests/test_cosmos_wave4a_document_access_backfill.py::FakeRepairBacklogStateWriteFailContainer": { "boundary": { - "imports_sha256": "592313eb753fe7b168e9549e54c206d2b4ca2c91a235bd8af257c64b11afb22e", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "9ed06655a2a45a7fc432afe41c1c41aaed2dea1e2cea776f95fcdc2e1f2bbbca", "methods": [ "upsert_item" ], - "sha256": "9ed06655a2a45a7fc432afe41c1c41aaed2dea1e2cea776f95fcdc2e1f2bbbca" + "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.", @@ -1604,15 +1604,15 @@ }, "functional_tests/test_cosmos_wave4b_document_access_shadow_validation.py::ConflictOnceShadowStateContainer": { "boundary": { - "imports_sha256": "869465b8d2f98f89f078c9625547e485d1343f97e855b803a9d3d3b97d2ba672", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "95026b06529598da3d47d4c6c193e0fcdaa9b1a83ce3fc405273a730d449bf37", "methods": [ "replace_item" ], - "sha256": "95026b06529598da3d47d4c6c193e0fcdaa9b1a83ce3fc405273a730d449bf37" + "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.", @@ -1622,9 +1622,7 @@ }, "functional_tests/test_cosmos_wave4b_document_access_shadow_validation.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "869465b8d2f98f89f078c9625547e485d1343f97e855b803a9d3d3b97d2ba672", - "inherited_bases": [], - "kind": "class", + "sha256": "b155142d8134208d4646c0a1e3b9fadd0635d5591c0e4b31ab5821f100856737", "methods": [ "create_item", "delete_item", @@ -1632,7 +1630,9 @@ "replace_item", "upsert_item" ], - "sha256": "b155142d8134208d4646c0a1e3b9fadd0635d5591c0e4b31ab5821f100856737" + "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.", @@ -1642,15 +1642,15 @@ }, "functional_tests/test_cosmos_wave5a_document_access_read_switch.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "49973a3fe47d9f043efd1809d044c83cbfcb9d8196d7f951d835a228f0aa33d2", - "inherited_bases": [], - "kind": "class", + "sha256": "f5619645b160fa0d1506125247502e67eca439709d4011208d42c1e338af591e", "methods": [ "read_item", "replace_item", "upsert_item" ], - "sha256": "f5619645b160fa0d1506125247502e67eca439709d4011208d42c1e338af591e" + "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.", @@ -1660,15 +1660,15 @@ }, "functional_tests/test_cosmos_wave5a_document_access_read_switch.py::FakeRepairBacklogStateReadFailContainer": { "boundary": { - "imports_sha256": "49973a3fe47d9f043efd1809d044c83cbfcb9d8196d7f951d835a228f0aa33d2", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "e3d140a7fa460b25f96f2cd13148957a396aa45e42751d5db668767a689db80c", "methods": [ "read_item" ], - "sha256": "e3d140a7fa460b25f96f2cd13148957a396aa45e42751d5db668767a689db80c" + "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.", @@ -1678,15 +1678,15 @@ }, "functional_tests/test_cosmos_wave6_document_access_cache.py::FailingRepairDocumentContainer": { "boundary": { - "imports_sha256": "9cbcfd0bfdc926d51203d71640608ab42c5001f5aa4bd63a87c5a0b05407a378", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "5a8b79e54e8adc9c8b02fe8d251963106307f3add5cafe1158b6ce244b64aa90", "methods": [ "upsert_item" ], - "sha256": "5a8b79e54e8adc9c8b02fe8d251963106307f3add5cafe1158b6ce244b64aa90" + "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.", @@ -1696,15 +1696,15 @@ }, "functional_tests/test_cosmos_wave6_document_access_cache.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "9cbcfd0bfdc926d51203d71640608ab42c5001f5aa4bd63a87c5a0b05407a378", - "inherited_bases": [], - "kind": "class", + "sha256": "c82472ca8e6038647fdc9b017855385f94a68054268c4677d3b45d01ee76cc21", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "c82472ca8e6038647fdc9b017855385f94a68054268c4677d3b45d01ee76cc21" + "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.", @@ -1714,16 +1714,16 @@ }, "functional_tests/test_cosmos_wave6_document_access_cache.py::FakeFencedDocumentsContainer": { "boundary": { - "imports_sha256": "9cbcfd0bfdc926d51203d71640608ab42c5001f5aa4bd63a87c5a0b05407a378", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "3940402fe081a96a6e5764f06d84b8474a4e66e69f9d746d4d87c88d44f4597b", "methods": [ "replace_item", "upsert_item" ], - "sha256": "3940402fe081a96a6e5764f06d84b8474a4e66e69f9d746d4d87c88d44f4597b" + "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.", @@ -1733,15 +1733,15 @@ }, "functional_tests/test_cosmos_wave6_document_access_cache.py::ToggleFailUpsertContainer": { "boundary": { - "imports_sha256": "9cbcfd0bfdc926d51203d71640608ab42c5001f5aa4bd63a87c5a0b05407a378", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "f105e7a1fbffa90ecd5ce8409865c59dada0ca0b4415de81142be6ac4cd2bffd", "methods": [ "upsert_item" ], - "sha256": "f105e7a1fbffa90ecd5ce8409865c59dada0ca0b4415de81142be6ac4cd2bffd" + "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.", @@ -1751,14 +1751,14 @@ }, "functional_tests/test_data_management_ai_search_backup_export.py::FakeItemStateContainer": { "boundary": { - "imports_sha256": "f58024c00a893d8318fc86f4817c4aee21f351b145a9d66e46c6c60d5d36ddcb", - "inherited_bases": [], - "kind": "class", + "sha256": "1e8e346908b034c279c1d580646d487b2da1c61c516c4cfad3c12f64abd428ac", "methods": [ "read_item", "upsert_item" ], - "sha256": "1e8e346908b034c279c1d580646d487b2da1c61c516c4cfad3c12f64abd428ac" + "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.", @@ -1768,16 +1768,16 @@ }, "functional_tests/test_data_management_ai_search_backup_export.py::FakeJobContainer": { "boundary": { - "imports_sha256": "f58024c00a893d8318fc86f4817c4aee21f351b145a9d66e46c6c60d5d36ddcb", - "inherited_bases": [], - "kind": "class", + "sha256": "810acfb6f777f60ffcc708c84ba824c45dabd3c20c5c8c0fe0f4b2fb27e40daf", "methods": [ "create_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "810acfb6f777f60ffcc708c84ba824c45dabd3c20c5c8c0fe0f4b2fb27e40daf" + "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.", @@ -1787,14 +1787,14 @@ }, "functional_tests/test_data_management_ai_search_migration_resilience.py::FakeJobContainer": { "boundary": { - "imports_sha256": "e3c6e72ab80aae2b9cfe32f5bbe1639da55236478e1ecee8ca96e4c33f0d71a7", - "inherited_bases": [], - "kind": "class", + "sha256": "566eea21954fd0b34e97bcc18adb587d7f0c9220811e281302ba6be4912c2e0b", "methods": [ "create_item", "upsert_item" ], - "sha256": "566eea21954fd0b34e97bcc18adb587d7f0c9220811e281302ba6be4912c2e0b" + "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.", @@ -1804,15 +1804,15 @@ }, "functional_tests/test_data_management_backup_durability.py::FakeItemStateContainer": { "boundary": { - "imports_sha256": "c4a4a354af2aa70cbad13304ba9b6c9e690730c2f009479cd93732cf804aa149", - "inherited_bases": [], - "kind": "class", + "sha256": "582837b574f48f26856843ccf613f6337182b565566b55ec2cfcdc99e805eb9b", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "582837b574f48f26856843ccf613f6337182b565566b55ec2cfcdc99e805eb9b" + "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.", @@ -1822,9 +1822,7 @@ }, "functional_tests/test_data_management_backup_durability.py::FakeJobContainer": { "boundary": { - "imports_sha256": "c4a4a354af2aa70cbad13304ba9b6c9e690730c2f009479cd93732cf804aa149", - "inherited_bases": [], - "kind": "class", + "sha256": "1e7aa905bb6cf319d0c7af56722d8c7ed11d868d724c0a2b0adbfd19fc36f1dc", "methods": [ "create_item", "delete_item", @@ -1832,7 +1830,9 @@ "replace_item", "upsert_item" ], - "sha256": "1e7aa905bb6cf319d0c7af56722d8c7ed11d868d724c0a2b0adbfd19fc36f1dc" + "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.", @@ -1842,14 +1842,14 @@ }, "functional_tests/test_data_management_backup_parallelism.py::FakeItemStateContainer": { "boundary": { - "imports_sha256": "3bca505e200858e46615e80f5a2af8d3a3f8d36894a16d17611d0c39ceaadc1e", - "inherited_bases": [], - "kind": "class", + "sha256": "61278a199f4eeb338d4468f6787ef04def46473a3b4922a621318966f4eba448", "methods": [ "read_item", "upsert_item" ], - "sha256": "61278a199f4eeb338d4468f6787ef04def46473a3b4922a621318966f4eba448" + "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.", @@ -1859,16 +1859,16 @@ }, "functional_tests/test_data_management_backup_parallelism.py::FakeJobContainer": { "boundary": { - "imports_sha256": "3bca505e200858e46615e80f5a2af8d3a3f8d36894a16d17611d0c39ceaadc1e", - "inherited_bases": [], - "kind": "class", + "sha256": "5fee25b2dbc920bc1668f8e59491757b219769c43251be22867da3c788a88ab0", "methods": [ "create_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "5fee25b2dbc920bc1668f8e59491757b219769c43251be22867da3c788a88ab0" + "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.", @@ -1878,15 +1878,15 @@ }, "functional_tests/test_data_management_blob_backup_transfers.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "c334e2bcf0f907bcd9e57c9e1ecc5c034031f8717ead60d2fe27cc1b9b580c0e", - "inherited_bases": [], - "kind": "class", + "sha256": "b51cde142a78c9e8d6925c1916a1308a3d79550b59f9f84efa70c492f4fb2b84", "methods": [ "create_item", "read_item", "upsert_item" ], - "sha256": "b51cde142a78c9e8d6925c1916a1308a3d79550b59f9f84efa70c492f4fb2b84" + "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.", @@ -1896,14 +1896,14 @@ }, "functional_tests/test_data_management_blob_migration_resilience.py::FakeJobContainer": { "boundary": { - "imports_sha256": "5974356585aa5209eb3a95aa244f3ed32144a622ddd7eb50778ee072af0e4457", - "inherited_bases": [], - "kind": "class", + "sha256": "eb1b15272aba95b53269252e762a69582547e21083cf9bfc3d332a88421f24ef", "methods": [ "create_item", "upsert_item" ], - "sha256": "eb1b15272aba95b53269252e762a69582547e21083cf9bfc3d332a88421f24ef" + "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.", @@ -1913,14 +1913,14 @@ }, "functional_tests/test_data_management_cosmos_migration_resilience.py::FakeJobContainer": { "boundary": { - "imports_sha256": "86ffad215434c4d03ec4e8195400134d2a6b7c9eda2c4bae684a9cf73c9b7d72", - "inherited_bases": [], - "kind": "class", + "sha256": "e3b15dcdf0e7701d9e21b0637fa0acaf8c3f7adab90190952e5b7cdbe35e4748", "methods": [ "create_item", "upsert_item" ], - "sha256": "e3b15dcdf0e7701d9e21b0637fa0acaf8c3f7adab90190952e5b7cdbe35e4748" + "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.", @@ -1930,15 +1930,15 @@ }, "functional_tests/test_data_management_cosmos_migration_resilience.py::FakeTargetContainer": { "boundary": { - "imports_sha256": "86ffad215434c4d03ec4e8195400134d2a6b7c9eda2c4bae684a9cf73c9b7d72", - "inherited_bases": [], - "kind": "class", + "sha256": "a4694b69b132eae2968490e47820b7c5f2e6d082f937a52c4b470f7191ed310b", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "a4694b69b132eae2968490e47820b7c5f2e6d082f937a52c4b470f7191ed310b" + "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.", @@ -1948,13 +1948,13 @@ }, "functional_tests/test_data_management_cosmos_migration_resilience.py::test_cosmos_write_renews_heartbeat_while_request_is_in_flight.SlowTargetContainer": { "boundary": { - "imports_sha256": "86ffad215434c4d03ec4e8195400134d2a6b7c9eda2c4bae684a9cf73c9b7d72", - "inherited_bases": [], - "kind": "class", + "sha256": "d7d96109da7cf1982e9e9ca1954c121df2c81220ea9360c6261bd5b133578bde", "methods": [ "create_item" ], - "sha256": "d7d96109da7cf1982e9e9ca1954c121df2c81220ea9360c6261bd5b133578bde" + "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.", @@ -1964,15 +1964,15 @@ }, "functional_tests/test_data_management_destination_cosmos_capacity.py::FakeJobContainer": { "boundary": { - "imports_sha256": "2870dd068c55be83c21832ac34d97fa43c19d20adc1ee58c39c05e446c212950", - "inherited_bases": [], - "kind": "class", + "sha256": "0ba585d8caf4105cbde4c283a36542e413383c9042efe94e0e78b612b5e2974d", "methods": [ "create_item", "read_item", "upsert_item" ], - "sha256": "0ba585d8caf4105cbde4c283a36542e413383c9042efe94e0e78b612b5e2974d" + "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.", @@ -1982,15 +1982,15 @@ }, "functional_tests/test_data_management_destination_cosmos_capacity.py::FakeTargetContainer": { "boundary": { - "imports_sha256": "2870dd068c55be83c21832ac34d97fa43c19d20adc1ee58c39c05e446c212950", - "inherited_bases": [], - "kind": "class", + "sha256": "051267fe06a72562a7c693874003707ad6f905ff859d16b1ae753ce7167516f1", "methods": [ "create_item", "delete_item", "read_item" ], - "sha256": "051267fe06a72562a7c693874003707ad6f905ff859d16b1ae753ce7167516f1" + "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.", @@ -2000,13 +2000,13 @@ }, "functional_tests/test_data_management_incremental_migration_modes.py::FakeJobContainer": { "boundary": { - "imports_sha256": "4c08e60cbe34855a3c170f97606225bc2e3703445c6788458ccd5358b909fc37", - "inherited_bases": [], - "kind": "class", + "sha256": "9f784d318785d9d2257ab59aa7eefdc9492fa0f8a45d2a73393218384933f238", "methods": [ "read_item" ], - "sha256": "9f784d318785d9d2257ab59aa7eefdc9492fa0f8a45d2a73393218384933f238" + "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.", @@ -2016,14 +2016,14 @@ }, "functional_tests/test_data_management_job_step_status.py::StubContainer": { "boundary": { - "imports_sha256": "e098e6d03b405c4c5415f0353da3ded435916016b3c762e07f5c782d2e080535", - "inherited_bases": [], - "kind": "class", + "sha256": "b58342fa28cbeacdd317963e47fdfb40ad78322bbd1317793b6de0fb9243c0ef", "methods": [ "create_item", "upsert_item" ], - "sha256": "b58342fa28cbeacdd317963e47fdfb40ad78322bbd1317793b6de0fb9243c0ef" + "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.", @@ -2033,14 +2033,14 @@ }, "functional_tests/test_data_management_migration_cancellation.py::FakeJobContainer": { "boundary": { - "imports_sha256": "2870dd068c55be83c21832ac34d97fa43c19d20adc1ee58c39c05e446c212950", - "inherited_bases": [], - "kind": "class", + "sha256": "2d4b42ba8e4c55a7daa681595d74cf41045eae42362e66a2728892e007aa699e", "methods": [ "read_item", "upsert_item" ], - "sha256": "2d4b42ba8e4c55a7daa681595d74cf41045eae42362e66a2728892e007aa699e" + "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.", @@ -2050,9 +2050,7 @@ }, "functional_tests/test_data_management_migration_coordinator.py::FakeCoordinatorContainer": { "boundary": { - "imports_sha256": "8f0390dde9b3f787cfe360a9fc7f56cf81f6e47a1ec8a4943ce5320d902bfa30", - "inherited_bases": [], - "kind": "class", + "sha256": "74cbdac3d4e32c6fad003e35652c3d24adf13bc70b48d3db9da4d7766cb09a56", "methods": [ "create_item", "delete_item", @@ -2060,7 +2058,9 @@ "replace_item", "upsert_item" ], - "sha256": "74cbdac3d4e32c6fad003e35652c3d24adf13bc70b48d3db9da4d7766cb09a56" + "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.", @@ -2070,14 +2070,14 @@ }, "functional_tests/test_data_management_migration_manifest.py::FakeJobContainer": { "boundary": { - "imports_sha256": "ab05f04bc4c926d70d11691d8553a89a5d3ab40c9e3cd4f07f6ec0250535432d", - "inherited_bases": [], - "kind": "class", + "sha256": "10164a1f413a73dee8311b56d9263fe7e45d04277d1333fa198e6e2de6e989be", "methods": [ "read_item", "upsert_item" ], - "sha256": "10164a1f413a73dee8311b56d9263fe7e45d04277d1333fa198e6e2de6e989be" + "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.", @@ -2087,14 +2087,14 @@ }, "functional_tests/test_data_management_migration_manifest.py::FakeManifestContainer": { "boundary": { - "imports_sha256": "ab05f04bc4c926d70d11691d8553a89a5d3ab40c9e3cd4f07f6ec0250535432d", - "inherited_bases": [], - "kind": "class", + "sha256": "b4938081a97d0138378d631f728a999086a3ab3bc3918657655bbcd5cd515c50", "methods": [ "create_item", "read_item" ], - "sha256": "b4938081a97d0138378d631f728a999086a3ab3bc3918657655bbcd5cd515c50" + "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.", @@ -2104,14 +2104,14 @@ }, "functional_tests/test_data_management_migration_orchestration.py::FakeJobContainer": { "boundary": { - "imports_sha256": "2870dd068c55be83c21832ac34d97fa43c19d20adc1ee58c39c05e446c212950", - "inherited_bases": [], - "kind": "class", + "sha256": "19cab06cbab19e887c8edc77c865c192e7b2511ab0fd669be5e9b0181df9af60", "methods": [ "read_item", "upsert_item" ], - "sha256": "19cab06cbab19e887c8edc77c865c192e7b2511ab0fd669be5e9b0181df9af60" + "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.", @@ -2121,16 +2121,16 @@ }, "functional_tests/test_data_management_migration_preflight.py::FakeJobContainer": { "boundary": { - "imports_sha256": "ab05f04bc4c926d70d11691d8553a89a5d3ab40c9e3cd4f07f6ec0250535432d", - "inherited_bases": [], - "kind": "class", + "sha256": "4f2f6dedddab02d3324206996f9e80d6915411d2b7360a4bc4ac9e59e5fa5173", "methods": [ "create_item", "delete_item", "read_item", "upsert_item" ], - "sha256": "4f2f6dedddab02d3324206996f9e80d6915411d2b7360a4bc4ac9e59e5fa5173" + "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.", @@ -2140,14 +2140,14 @@ }, "functional_tests/test_data_management_migration_reconciliation.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "7ed17f5d8c9de60c3bc2c8252571dbcb7b7ecf08b97701f452ab837bf52e2b5e", - "inherited_bases": [], - "kind": "class", + "sha256": "98093e74c747188f85c15f3ac1b59792c60a1c081a3d195b49996bd36c23a7ac", "methods": [ "delete_item", "read_item" ], - "sha256": "98093e74c747188f85c15f3ac1b59792c60a1c081a3d195b49996bd36c23a7ac" + "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.", @@ -2157,15 +2157,15 @@ }, "functional_tests/test_data_management_migration_reconciliation.py::FakeJobContainer": { "boundary": { - "imports_sha256": "7ed17f5d8c9de60c3bc2c8252571dbcb7b7ecf08b97701f452ab837bf52e2b5e", - "inherited_bases": [], - "kind": "class", + "sha256": "f622d3457ad239c254986c80e3bcce9e6531c097b77a6fa4bb8c21df077081c0", "methods": [ "create_item", "read_item", "upsert_item" ], - "sha256": "f622d3457ad239c254986c80e3bcce9e6531c097b77a6fa4bb8c21df077081c0" + "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.", @@ -2175,15 +2175,15 @@ }, "functional_tests/test_data_management_migration_reconciliation.py::FakeSearchGateContainer": { "boundary": { - "imports_sha256": "7ed17f5d8c9de60c3bc2c8252571dbcb7b7ecf08b97701f452ab837bf52e2b5e", - "inherited_bases": [], - "kind": "class", + "sha256": "e9d83682bcf1a6302696474aca855fcb49976e951605489b2dce59268d128194", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "e9d83682bcf1a6302696474aca855fcb49976e951605489b2dce59268d128194" + "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.", @@ -2193,14 +2193,14 @@ }, "functional_tests/test_data_management_migration_recovery.py::FakeJobContainer": { "boundary": { - "imports_sha256": "89aa35b665941b9d2f04e1241ba9defdba48acc0cbff468518594a01f2675d67", - "inherited_bases": [], - "kind": "class", + "sha256": "299da354642eaffec52fa1c66429b78a516c0303ccc4ff1eec03e2c16f0b3f0d", "methods": [ "read_item", "upsert_item" ], - "sha256": "299da354642eaffec52fa1c66429b78a516c0303ccc4ff1eec03e2c16f0b3f0d" + "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.", @@ -2210,14 +2210,14 @@ }, "functional_tests/test_data_management_migration_retry.py::FakeConditionalJobContainer": { "boundary": { - "imports_sha256": "6ebefe9e1184126863bd218b2987dd7c4bf927d966ac6668142ea7d7bd0708a2", - "inherited_bases": [], - "kind": "class", + "sha256": "02f5d9a1b2e576747586072091a41dc0b73092a9a4407bcd80fb2be4403a2d09", "methods": [ "replace_item", "upsert_item" ], - "sha256": "02f5d9a1b2e576747586072091a41dc0b73092a9a4407bcd80fb2be4403a2d09" + "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.", @@ -2227,14 +2227,14 @@ }, "functional_tests/test_data_management_migration_retry.py::FakeJobContainer": { "boundary": { - "imports_sha256": "6ebefe9e1184126863bd218b2987dd7c4bf927d966ac6668142ea7d7bd0708a2", - "inherited_bases": [], - "kind": "class", + "sha256": "ccf4adb13690f2d8db9a0dc5788cd9a31ca7021b6dd20128aba56a89b9a579a0", "methods": [ "read_item", "upsert_item" ], - "sha256": "ccf4adb13690f2d8db9a0dc5788cd9a31ca7021b6dd20128aba56a89b9a579a0" + "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.", @@ -2244,16 +2244,16 @@ }, "functional_tests/test_data_management_migration_workflow_contract.py::FakeJobContainer": { "boundary": { - "imports_sha256": "8af3bceb0ffde567e17e9af16b84efa26dfc464e81b7afeb4ad8507e041039c1", - "inherited_bases": [], - "kind": "class", + "sha256": "51392ad9dc47ca98374ec8bc03cc6492a5ff1e3284e026567fa01c194bf06972", "methods": [ "create_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "51392ad9dc47ca98374ec8bc03cc6492a5ff1e3284e026567fa01c194bf06972" + "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.", @@ -2263,14 +2263,14 @@ }, "functional_tests/test_data_management_public_prompt_migration.py::FakeJobContainer": { "boundary": { - "imports_sha256": "b9a3ab25672d0c9e29c420d5ddb501f41058675f92c9ee83d009271de56457c3", - "inherited_bases": [], - "kind": "class", + "sha256": "010ac06827e371695ed8c02d4fc030deed453ea7caafabb88a9f99f7465b7512", "methods": [ "create_item", "upsert_item" ], - "sha256": "010ac06827e371695ed8c02d4fc030deed453ea7caafabb88a9f99f7465b7512" + "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.", @@ -2280,14 +2280,14 @@ }, "functional_tests/test_data_management_public_prompt_migration.py::FakePromptContainer": { "boundary": { - "imports_sha256": "b9a3ab25672d0c9e29c420d5ddb501f41058675f92c9ee83d009271de56457c3", - "inherited_bases": [], - "kind": "class", + "sha256": "da22c479cca5a86a7b97be76f451de142b91fa6cccd42c0d051a62acf871da11", "methods": [ "create_item", "read_item" ], - "sha256": "da22c479cca5a86a7b97be76f451de142b91fa6cccd42c0d051a62acf871da11" + "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.", @@ -2297,16 +2297,16 @@ }, "functional_tests/test_data_management_restore_workflow.py::FakeJobContainer": { "boundary": { - "imports_sha256": "a29470212ebdcf5b18387256db488c869c8cc756438402030b38fcda4b4c4776", - "inherited_bases": [], - "kind": "class", + "sha256": "dc70aa21154df668fce5601f1b5c0db2ae19340b2bb5c98612d2414935b86991", "methods": [ "create_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "dc70aa21154df668fce5601f1b5c0db2ae19340b2bb5c98612d2414935b86991" + "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.", @@ -2316,13 +2316,13 @@ }, "functional_tests/test_data_management_search_write_fence.py::ConflictHeavyGateContainer": { "boundary": { - "imports_sha256": "0bbed936318aa30734511d2f48f5b8a666203db6409f9850e4995b0a0ea25faf", - "inherited_bases": [], - "kind": "class", + "sha256": "893c13a6c8e89d5ac08fcdf447fa471c9a37683effa28ed01aef3a5ee143a2ca", "methods": [ "replace_item" ], - "sha256": "893c13a6c8e89d5ac08fcdf447fa471c9a37683effa28ed01aef3a5ee143a2ca" + "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.", @@ -2332,16 +2332,16 @@ }, "functional_tests/test_data_management_search_write_fence.py::FakeGateContainer": { "boundary": { - "imports_sha256": "0bbed936318aa30734511d2f48f5b8a666203db6409f9850e4995b0a0ea25faf", - "inherited_bases": [], - "kind": "class", + "sha256": "f80b2b61caaf6ed23371471fae0e5c291cab1a831f9420d310e9423ea7988284", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "f80b2b61caaf6ed23371471fae0e5c291cab1a831f9420d310e9423ea7988284" + "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.", @@ -2351,13 +2351,13 @@ }, "functional_tests/test_data_management_search_write_fence_authorization.py::FakeDocumentContainer": { "boundary": { - "imports_sha256": "4af4933dd56caa2c252251bb1b80f72d47982dd78211e33b6c372f31d09b7ed2", - "inherited_bases": [], - "kind": "class", + "sha256": "a3e358957e94e377e64ee9b208dbed1e8572adbafc1b76a1e13f61031baba269", "methods": [ "read_item" ], - "sha256": "a3e358957e94e377e64ee9b208dbed1e8572adbafc1b76a1e13f61031baba269" + "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.", @@ -2367,13 +2367,13 @@ }, "functional_tests/test_document_action_token_usage_aggregation.py::FakeContainer": { "boundary": { - "imports_sha256": "2d140dff180790e2a86d1f649964299edd0c83473afd63f8e6f3d64204c073b5", - "inherited_bases": [], - "kind": "class", + "sha256": "e3b0c3ac83f2740747cfbf0ffb6f6db2fff2ac4fec060338564957487ff9177f", "methods": [ "upsert_item" ], - "sha256": "e3b0c3ac83f2740747cfbf0ffb6f6db2fff2ac4fec060338564957487ff9177f" + "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.", @@ -2383,15 +2383,15 @@ }, "functional_tests/test_document_analysis_work_recovery.py::AnalysisMemoryContainer": { "boundary": { - "imports_sha256": "4b4278fd72804c2e70e8520a07537409a4fbeb00b53b3d77db8b92737dcc6f42", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "753c65a3bb25721270098329c77ec9ceed989434b639701dd49c1eff9ec0890c", "methods": [ "delete_item" ], - "sha256": "753c65a3bb25721270098329c77ec9ceed989434b639701dd49c1eff9ec0890c" + "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.", @@ -2401,12 +2401,12 @@ }, "functional_tests/test_document_analysis_work_recovery.py::test_lost_unit_completion_acknowledgement_resumes_the_committed_payload::point-seam-1": { "boundary": { - "imports_sha256": "4b4278fd72804c2e70e8520a07537409a4fbeb00b53b3d77db8b92737dcc6f42", - "kind": "seam", + "sha256": "b12e8395b3837094867a4cb38a92a62b79a011343757f69a2b6c955d687a9e69", "methods": [ "execute_item_batch" ], - "sha256": "b12e8395b3837094867a4cb38a92a62b79a011343757f69a2b6c955d687a9e69" + "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.", @@ -2431,13 +2431,13 @@ }, "functional_tests/test_document_provenance_origin.py::ConversationStore": { "boundary": { - "imports_sha256": "0307cd1717ff3d0bda795e71133a23b8d70dba0dc4fbab0a73ec045f89b2df8b", - "inherited_bases": [], - "kind": "class", + "sha256": "d943e8cb283f884d3b33aef1973c7ba45f85ae468d64f7a96c3cbf7e54d00f96", "methods": [ "read_item" ], - "sha256": "d943e8cb283f884d3b33aef1973c7ba45f85ae468d64f7a96c3cbf7e54d00f96" + "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.", @@ -2447,13 +2447,13 @@ }, "functional_tests/test_document_provenance_publication.py::test_an_unreadable_conversation_never_blocks_publication.UnavailableConversations": { "boundary": { - "imports_sha256": "0e67fbb453d04d7dd5298e22e47c3da6d67e6595081c638b9249628db9af8d13", - "inherited_bases": [], - "kind": "class", + "sha256": "d848b62fa55e3fcf9a26501b132816d727402c877a2241e42b82ff9dcb45174f", "methods": [ "read_item" ], - "sha256": "d848b62fa55e3fcf9a26501b132816d727402c877a2241e42b82ff9dcb45174f" + "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.", @@ -2463,13 +2463,13 @@ }, "functional_tests/test_document_provenance_versions_and_guards.py::ConversationReads": { "boundary": { - "imports_sha256": "148538a78646624a3979525f01ec0c1f4d85a800092a237c137c115b39dfc9bb", - "inherited_bases": [], - "kind": "class", + "sha256": "69f27e199299001c1b7c9147fa38017fbbd22261be7da8c5db5816fe42e289cb", "methods": [ "read_item" ], - "sha256": "69f27e199299001c1b7c9147fa38017fbbd22261be7da8c5db5816fe42e289cb" + "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.", @@ -2479,16 +2479,16 @@ }, "functional_tests/test_document_search_metadata_sync.py::FakeDocumentsContainer": { "boundary": { - "imports_sha256": "ab3456cf1a8dd8d10b8162c85e19d9f98f65e72e6942605ef6d6eebccfeaace8", - "inherited_bases": [], - "kind": "class", + "sha256": "cd7e418381a1d0e30689d610106821eba9427898434de404917301b11dd2534b", "methods": [ "create_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "cd7e418381a1d0e30689d610106821eba9427898434de404917301b11dd2534b" + "kind": "class", + "inherited_bases": [], + "imports_sha256": "ab3456cf1a8dd8d10b8162c85e19d9f98f65e72e6942605ef6d6eebccfeaace8" }, "classification": "sdk-default", "contract": "read_item and create/replace/upsert responses use the installed SDK CosmosDict by default; query rows and nested JSON stay plain dictionaries. The shared store keeps copied document fields, new ETags, scoped query filtering and 409/404/412 failures. Status runtime tests cover strict SDK-returning writes, stale ETags, screening holds and expired operation guards.", @@ -2498,12 +2498,12 @@ }, "functional_tests/test_document_transform_sources.py::artifact_source::point-seam-1": { "boundary": { - "imports_sha256": "b5f65b0f3fabc70a0edaef885e91642e2bdd94f24ed8482b0295fc8ea5373612", - "kind": "seam", + "sha256": "df5c308aea815ee21760a5807ae9222975d4de889f247b04445f333cddc95977", "methods": [ "read_item" ], - "sha256": "df5c308aea815ee21760a5807ae9222975d4de889f247b04445f333cddc95977" + "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.", @@ -2513,12 +2513,12 @@ }, "functional_tests/test_document_transform_sources.py::artifact_source::point-seam-2": { "boundary": { - "imports_sha256": "b5f65b0f3fabc70a0edaef885e91642e2bdd94f24ed8482b0295fc8ea5373612", - "kind": "seam", + "sha256": "26fa8c64e93c10c5ea72e63a4a52f8cf839bfd9769a0f4e4e8b9ef95d497a8cf", "methods": [ "read_item" ], - "sha256": "26fa8c64e93c10c5ea72e63a4a52f8cf839bfd9769a0f4e4e8b9ef95d497a8cf" + "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.", @@ -2528,15 +2528,15 @@ }, "functional_tests/test_fact_memory_profile_and_mini_sk.py::FakeFactContainer": { "boundary": { - "imports_sha256": "ed74ee3422c6897f32b88c600a081b8acd433488ad01644226aa8007e318f0e7", - "inherited_bases": [], - "kind": "class", + "sha256": "ca45e87d160cc2cc548e5b5a0a6a2b7756bdf7dc8a798873e4206932373e4f44", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "ca45e87d160cc2cc548e5b5a0a6a2b7756bdf7dc8a798873e4206932373e4f44" + "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.", @@ -2546,13 +2546,13 @@ }, "functional_tests/test_feedback_submission_authorization.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "8c69fce4303f85688c6e511e049c779dd7e1fc22e7b51b3e3709ae331cbecb46", - "inherited_bases": [], - "kind": "class", + "sha256": "4f56feb2fdee56f9a16b1ddc4185fc7f6ddc7215b953cbab042c4a08046b352d", "methods": [ "read_item" ], - "sha256": "4f56feb2fdee56f9a16b1ddc4185fc7f6ddc7215b953cbab042c4a08046b352d" + "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.", @@ -2562,13 +2562,13 @@ }, "functional_tests/test_feedback_submission_authorization.py::FakeFeedbackContainer": { "boundary": { - "imports_sha256": "8c69fce4303f85688c6e511e049c779dd7e1fc22e7b51b3e3709ae331cbecb46", - "inherited_bases": [], - "kind": "class", + "sha256": "0b66a3b6619bdc8740699f9af1118555530e78ed9129a0319a1f084052ae5b0e", "methods": [ "upsert_item" ], - "sha256": "0b66a3b6619bdc8740699f9af1118555530e78ed9129a0319a1f084052ae5b0e" + "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.", @@ -2578,13 +2578,13 @@ }, "functional_tests/test_file_processing_log_cleanup.py::FakeContainer": { "boundary": { - "imports_sha256": "532e0c012e780de5fa9d248e29b2a9e2f1134575555a1df7f86d539177f62b5d", - "inherited_bases": [], - "kind": "class", + "sha256": "06d53ccdf9560425ed1e817239a10c6fd9605fa0fe5742d4e78d3199791dcca5", "methods": [ "delete_item" ], - "sha256": "06d53ccdf9560425ed1e817239a10c6fd9605fa0fe5742d4e78d3199791dcca5" + "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.", @@ -2594,9 +2594,7 @@ }, "functional_tests/test_file_sync_concurrent_write_safety.py::FakeContainer": { "boundary": { - "imports_sha256": "016c42b33c26778a9c563840280671bdc577eb9844818eec77cec8d1a2024f1c", - "inherited_bases": [], - "kind": "class", + "sha256": "67f5d5b8fa38f8d5236e9e2a0f06f83424758d6d5e432748e6abd2d1a9e363b8", "methods": [ "create_item", "delete_item", @@ -2604,7 +2602,9 @@ "replace_item", "upsert_item" ], - "sha256": "67f5d5b8fa38f8d5236e9e2a0f06f83424758d6d5e432748e6abd2d1a9e363b8" + "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.", @@ -2614,15 +2614,15 @@ }, "functional_tests/test_file_sync_cosmos_response_contract.py::FileSyncContainer": { "boundary": { - "imports_sha256": "78a6739dc8ffef6db528b82e888e06bc9e3dba0229653a71e8d29f33a1887d95", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "f14f39dffad3e876b7c287f764fe2f1d38fe13cdfc6b81665659a8ff2ee3c983", "methods": [ "delete_item" ], - "sha256": "f14f39dffad3e876b7c287f764fe2f1d38fe13cdfc6b81665659a8ff2ee3c983" + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "78a6739dc8ffef6db528b82e888e06bc9e3dba0229653a71e8d29f33a1887d95" }, "classification": "sdk-default", "contract": "Inherits real installed SDK CosmosDict point responses, nested plain JSON, ETags, partition routing, conditional writes and fault injection from AtomicMemoryContainer. Adds the File Sync query subset with plain rows/scalar counts and a one-shot conditional-delete race.", @@ -2632,14 +2632,14 @@ }, "functional_tests/test_generated_artifact_lifecycle_authorization.py::FakeContainer": { "boundary": { - "imports_sha256": "e9499130d78e5ee6fb32512279a73a6ec2a79d4765f11b38187fc17f3bbb1f86", - "inherited_bases": [], - "kind": "class", + "sha256": "691193ac86088e1e1428f951fba7ff4df848fd4c07c228a1e2965c1afec96a5a", "methods": [ "read_item", "upsert_item" ], - "sha256": "691193ac86088e1e1428f951fba7ff4df848fd4c07c228a1e2965c1afec96a5a" + "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.", @@ -2649,14 +2649,14 @@ }, "functional_tests/test_global_action_user_audit_fallback.py::FakeContainer": { "boundary": { - "imports_sha256": "ff3b964960dc41d57ba72a37e89d9e22b101271c24ba35e6438ba1f4356adf95", - "inherited_bases": [], - "kind": "class", + "sha256": "67ba030b6e0fa75b55fdfd67eb6ef67e91ec7ff3d7ad8cb3488881e3783fdbfc", "methods": [ "read_item", "upsert_item" ], - "sha256": "67ba030b6e0fa75b55fdfd67eb6ef67e91ec7ff3d7ad8cb3488881e3783fdbfc" + "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.", @@ -2665,15 +2665,15 @@ ] }, "functional_tests/test_governance_activity_logging.py::_InMemoryContainer": { - "boundary": { - "imports_sha256": "2e15f3bd3d955a17d59dc7a9d01e98cd15052fe3edecb4a2bca9fc8044fa6f16", - "inherited_bases": [], - "kind": "class", + "boundary": { + "sha256": "55cd9e7729194475f5d6cb377f263f242e6c8963bd9c87e646d7e34c04f5295b", "methods": [ "read_item", "upsert_item" ], - "sha256": "55cd9e7729194475f5d6cb377f263f242e6c8963bd9c87e646d7e34c04f5295b" + "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.", @@ -2683,16 +2683,16 @@ }, "functional_tests/test_governance_activity_logging.py::_TestContainer": { "boundary": { - "imports_sha256": "2e15f3bd3d955a17d59dc7a9d01e98cd15052fe3edecb4a2bca9fc8044fa6f16", - "inherited_bases": [], - "kind": "class", + "sha256": "38af4e0b659088b03b28e6cc635a2d848736795ea2890d64969b583bee65d876", "methods": [ "create_item", "delete_item", "read_item", "upsert_item" ], - "sha256": "38af4e0b659088b03b28e6cc635a2d848736795ea2890d64969b583bee65d876" + "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.", @@ -2702,13 +2702,13 @@ }, "functional_tests/test_governance_activity_logging.py::test_log_governance_change_payload_shape._CaptureContainer": { "boundary": { - "imports_sha256": "2e15f3bd3d955a17d59dc7a9d01e98cd15052fe3edecb4a2bca9fc8044fa6f16", - "inherited_bases": [], - "kind": "class", + "sha256": "aa53faaa41b71493553f94d440231d4b0cab88facff3f129543e60919cdec9b1", "methods": [ "create_item" ], - "sha256": "aa53faaa41b71493553f94d440231d4b0cab88facff3f129543e60919cdec9b1" + "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.", @@ -2718,15 +2718,15 @@ }, "functional_tests/test_governance_enforcement_logic.py::_TestContainer": { "boundary": { - "imports_sha256": "be46a5d17909f1afa752ec4b9e9327280ba47ef91a692cab07efd9ceaabf7288", - "inherited_bases": [], - "kind": "class", + "sha256": "98727859bee328810570165b1e5e8e7d1912b3cc4e3cbce9d63d0fede2807bd5", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "98727859bee328810570165b1e5e8e7d1912b3cc4e3cbce9d63d0fede2807bd5" + "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.", @@ -2736,15 +2736,15 @@ }, "functional_tests/test_governance_enforcement_logic.py::test_item_policy_retarget_moves_existing_policy_document._RetargetContainer": { "boundary": { - "imports_sha256": "be46a5d17909f1afa752ec4b9e9327280ba47ef91a692cab07efd9ceaabf7288", - "inherited_bases": [], - "kind": "class", + "sha256": "fe07b44ec9de4405f291a3dac0474b98b99cf56040c0c474066eb1daf26f56f7", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "fe07b44ec9de4405f291a3dac0474b98b99cf56040c0c474066eb1daf26f56f7" + "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.", @@ -2754,12 +2754,12 @@ }, "functional_tests/test_group_bulk_endpoint_save_writer.py::test_an_uncertain_write_failure_keeps_the_staged_credential::point-seam-1": { "boundary": { - "imports_sha256": "458fdcc8d40ba10bd2d743c7211dd8936109725afc285961cf1a9921c4efac5f", - "kind": "seam", + "sha256": "9efa6d2be9d6958d1f0d31966538b195d95299b56d82c6a8bccd413505e72fd2", "methods": [ "replace_item" ], - "sha256": "9efa6d2be9d6958d1f0d31966538b195d95299b56d82c6a8bccd413505e72fd2" + "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.", @@ -2769,12 +2769,12 @@ }, "functional_tests/test_group_collaboration_source_storage_fix.py::::point-seam-1": { "boundary": { - "imports_sha256": "4029463e248875fcc10807601561ffb87d1d5eee42d2fe9b4c479e3850a840d5", - "kind": "seam", + "sha256": "12f18785ec3b5177a1a7c4640fa80b511fbf592a191c95d6792999908dd7bcff", "methods": [ "upsert_item" ], - "sha256": "12f18785ec3b5177a1a7c4640fa80b511fbf592a191c95d6792999908dd7bcff" + "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.", @@ -2784,15 +2784,15 @@ }, "functional_tests/test_group_collaboration_source_storage_fix.py::TrackingContainer": { "boundary": { - "imports_sha256": "4029463e248875fcc10807601561ffb87d1d5eee42d2fe9b4c479e3850a840d5", - "inherited_bases": [], - "kind": "class", + "sha256": "624d51cb151f27a503b9b93047754d606efd2f3e54634c66820576200edb16c3", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "624d51cb151f27a503b9b93047754d606efd2f3e54634c66820576200edb16c3" + "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.", @@ -2802,12 +2802,12 @@ }, "functional_tests/test_group_directory_apis.py::test_a_storage_failure_is_a_generic_500_without_the_exception_text::point-seam-1": { "boundary": { - "imports_sha256": "a0028b58a4a82c229332137247412b4e93fd81b127c589d62b4b56773fc57520", - "kind": "seam", + "sha256": "53a129d8269fb8d8c672707f59137686ffd5ae01194be745526e4cf7924bcec2", "methods": [ "create_item" ], - "sha256": "53a129d8269fb8d8c672707f59137686ffd5ae01194be745526e4cf7924bcec2" + "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.", @@ -2817,16 +2817,16 @@ }, "functional_tests/test_group_document_blob_upload_etag.py::EtagContainer": { "boundary": { - "imports_sha256": "4d2c75454c04c3b15f7e011ab5b0e9a37e28ea9d8d49fc244df67fe260cf02dd", - "inherited_bases": [], - "kind": "class", + "sha256": "f72c109202df244c2de6e2b5ba23426813b1b0547c9b1a5ab29edb35da01e462", "methods": [ "create_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "f72c109202df244c2de6e2b5ba23426813b1b0547c9b1a5ab29edb35da01e462" + "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.", @@ -2836,14 +2836,14 @@ }, "functional_tests/test_group_document_collaboration.py::NotificationStore": { "boundary": { - "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe", - "inherited_bases": [], - "kind": "class", + "sha256": "fd83d961c5a88340e50e5aa5dea8b627e9ff90465606156fd6719ed0f469fe95", "methods": [ "delete_item", "read_item" ], - "sha256": "fd83d961c5a88340e50e5aa5dea8b627e9ff90465606156fd6719ed0f469fe95" + "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.", @@ -2853,12 +2853,12 @@ }, "functional_tests/test_group_document_collaboration.py::sharing::point-seam-1": { "boundary": { - "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe", - "kind": "seam", + "sha256": "c03644aff628e2a3eef29f55c82602bb7d9f78f87a2472bf3a8358902e1758ce", "methods": [ "upsert_item" ], - "sha256": "c03644aff628e2a3eef29f55c82602bb7d9f78f87a2472bf3a8358902e1758ce" + "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.", @@ -2868,12 +2868,12 @@ }, "functional_tests/test_group_document_collaboration.py::test_lost_effect_checkpoint_acknowledgement_never_replays_completed_work::point-seam-1": { "boundary": { - "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe", - "kind": "seam", + "sha256": "3a72acae523289dceff2aeb1992720e3acda78bd8858513aff40afa35ad44241", "methods": [ "replace_item" ], - "sha256": "3a72acae523289dceff2aeb1992720e3acda78bd8858513aff40afa35ad44241" + "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.", @@ -2883,12 +2883,12 @@ }, "functional_tests/test_group_document_collaboration.py::test_unknown_notification_create_acknowledgement_is_not_a_replayable_refusal::point-seam-1": { "boundary": { - "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe", - "kind": "seam", + "sha256": "b57318009f91dbbfcbd974df4e9299c49111a288ab42463a37838bac818683e0", "methods": [ "create_item" ], - "sha256": "b57318009f91dbbfcbd974df4e9299c49111a288ab42463a37838bac818683e0" + "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.", @@ -2898,12 +2898,12 @@ }, "functional_tests/test_group_document_collaboration.py::test_unknown_notification_create_acknowledgement_is_not_a_replayable_refusal::point-seam-2": { "boundary": { - "imports_sha256": "f78483d01199b8ff5829201ee54538ceb476bfce888c77d58734a7b5aead6abe", - "kind": "seam", + "sha256": "b2781f2c00998f02be7f2f50724d7cdf662af1c155f44b22bddf15ef28683791", "methods": [ "create_item" ], - "sha256": "b2781f2c00998f02be7f2f50724d7cdf662af1c155f44b22bddf15ef28683791" + "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.", @@ -2913,12 +2913,12 @@ }, "functional_tests/test_group_document_etag_guard.py::test_a_lost_response_commit_is_recognised_rather_than_retried::point-seam-1": { "boundary": { - "imports_sha256": "260ba27105274a5f9b809d9dc1ed3ed034efe76a3e13466400dbd417a04a599c", - "kind": "seam", + "sha256": "16b139e8e995e8fadceb8ec9340c3c18099dc124f29dc0993ca8275bb000125d", "methods": [ "replace_item" ], - "sha256": "16b139e8e995e8fadceb8ec9340c3c18099dc124f29dc0993ca8275bb000125d" + "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.", @@ -2928,12 +2928,12 @@ }, "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": { - "imports_sha256": "260ba27105274a5f9b809d9dc1ed3ed034efe76a3e13466400dbd417a04a599c", - "kind": "seam", + "sha256": "16b139e8e995e8fadceb8ec9340c3c18099dc124f29dc0993ca8275bb000125d", "methods": [ "replace_item" ], - "sha256": "16b139e8e995e8fadceb8ec9340c3c18099dc124f29dc0993ca8275bb000125d" + "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.", @@ -2943,9 +2943,7 @@ }, "functional_tests/test_group_document_management.py::MutableContainer": { "boundary": { - "imports_sha256": "4cedaa57c6a547144e32820585c5484b20534246ed0322569a4f55a3b9e5ca14", - "inherited_bases": [], - "kind": "class", + "sha256": "24a9a73bf0e9a7557cdb5b89be4a319b20a631fcea70739a95f6c7b4faf62e33", "methods": [ "create_item", "delete_item", @@ -2953,7 +2951,9 @@ "replace_item", "upsert_item" ], - "sha256": "24a9a73bf0e9a7557cdb5b89be4a319b20a631fcea70739a95f6c7b4faf62e33" + "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.", @@ -2963,14 +2963,14 @@ }, "functional_tests/test_group_document_projection_fence.py::ConditionalSource": { "boundary": { - "imports_sha256": "f9678253d5f94f2bc91ffdda295fee2a81c11c01c35f7c762fec49a3859ac028", - "inherited_bases": [], - "kind": "class", + "sha256": "e59e031c44eaed7c84800bbbd527329607a5ec98e4de41346ccdf7f6d079eb46", "methods": [ "read_item", "replace_item" ], - "sha256": "e59e031c44eaed7c84800bbbd527329607a5ec98e4de41346ccdf7f6d079eb46" + "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.", @@ -2980,13 +2980,13 @@ }, "functional_tests/test_group_document_publication.py::ReceiptStore": { "boundary": { - "imports_sha256": "439edc9ca6db5fe920de447fd839793ab56393cedab67ca1b04851603ee3d733", - "inherited_bases": [], - "kind": "class", + "sha256": "2aa58f7aeca39e036dcd875abf9119130e45373b4237809b1bdf2ce20ac18f6a", "methods": [ "read_item" ], - "sha256": "2aa58f7aeca39e036dcd875abf9119130e45373b4237809b1bdf2ce20ac18f6a" + "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.", @@ -2996,13 +2996,13 @@ }, "functional_tests/test_group_document_read_apis.py::ReadOnlyContainer": { "boundary": { - "imports_sha256": "3a9431f0b11483f22d1f5b5c8c01fcba4d21c8ed3c4d9fb8ae431fbe89392738", - "inherited_bases": [], - "kind": "class", + "sha256": "37edaa6d4bc77a4cc85760f7cc989906e564ee80d1856f5d2de6bf4da31bf3ef", "methods": [ "read_item" ], - "sha256": "37edaa6d4bc77a4cc85760f7cc989906e564ee80d1856f5d2de6bf4da31bf3ef" + "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.", @@ -3012,12 +3012,12 @@ }, "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": { - "imports_sha256": "39a1d91917706f6db9d3f912480c0a3813f637d64b732ffbd12aa8eb1f097ec3", - "kind": "seam", + "sha256": "3ef2ef43fe07a5a90ab0d3915e5fda77c9b8b6f1ca8b4467abe5c7cd642157be", "methods": [ "replace_item" ], - "sha256": "3ef2ef43fe07a5a90ab0d3915e5fda77c9b8b6f1ca8b4467abe5c7cd642157be" + "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.", @@ -3027,12 +3027,12 @@ }, "functional_tests/test_group_endpoint_apis.py::test_a_lost_response_commit_is_reported_committed_and_its_key_kept::point-seam-1": { "boundary": { - "imports_sha256": "39a1d91917706f6db9d3f912480c0a3813f637d64b732ffbd12aa8eb1f097ec3", - "kind": "seam", + "sha256": "b50b81a363d8b097b5746a0556394589aabf04f635d30ece4d462f2bb94bf6f5", "methods": [ "replace_item" ], - "sha256": "b50b81a363d8b097b5746a0556394589aabf04f635d30ece4d462f2bb94bf6f5" + "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.", @@ -3042,12 +3042,12 @@ }, "functional_tests/test_group_endpoint_apis.py::test_an_uncertain_failure_keeps_staged_keys::point-seam-1": { "boundary": { - "imports_sha256": "39a1d91917706f6db9d3f912480c0a3813f637d64b732ffbd12aa8eb1f097ec3", - "kind": "seam", + "sha256": "3f7e4c14eab523b4ac70dd8744622a9359a91c49e06e00ce2e24bc3ff8c2a499", "methods": [ "replace_item" ], - "sha256": "3f7e4c14eab523b4ac70dd8744622a9359a91c49e06e00ce2e24bc3ff8c2a499" + "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.", @@ -3057,12 +3057,12 @@ }, "functional_tests/test_group_membership_apis.py::test_an_unexpected_failure_is_a_logged_generic_500::point-seam-1": { "boundary": { - "imports_sha256": "d291d81abc7bc89a1d1cbc3ba1142b8034ec105cb3298653f64a2eaeb819ae88", - "kind": "seam", + "sha256": "69967a7bec26f7925866d4e6a9099741af49b108ced0f26214f92a59335716ef", "methods": [ "read_item" ], - "sha256": "69967a7bec26f7925866d4e6a9099741af49b108ced0f26214f92a59335716ef" + "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.", @@ -3072,12 +3072,12 @@ }, "functional_tests/test_group_screening_fixture_parity.py::RealScreening.__init__::point-seam-1": { "boundary": { - "imports_sha256": "0b85da00d16d42d0232c364b48a07b77c9ba3aece4db3405f0cf0084d74c645f", - "kind": "seam", + "sha256": "af33512d32e42fb2e8860a0c9f49fad194937e2fd9cd957234cfb7c5966658db", "methods": [ "read_item" ], - "sha256": "af33512d32e42fb2e8860a0c9f49fad194937e2fd9cd957234cfb7c5966658db" + "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.", @@ -3087,12 +3087,12 @@ }, "functional_tests/test_group_settings_apis.py::test_a_storage_failure_mid_write_is_a_data_free_500::point-seam-1": { "boundary": { - "imports_sha256": "b060fa01a84f8f864df39c3e6b933aade6c0bb1380fcad66681325da7456dbc2", - "kind": "seam", + "sha256": "c8ad2bc393a568bbb2e08a5b6bb1befee9815552d7a06ae96f8666f1e9274906", "methods": [ "replace_item" ], - "sha256": "c8ad2bc393a568bbb2e08a5b6bb1befee9815552d7a06ae96f8666f1e9274906" + "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.", @@ -3102,12 +3102,12 @@ }, "functional_tests/test_group_settings_apis.py::test_an_unexpected_failure_is_a_logged_data_free_500::point-seam-1": { "boundary": { - "imports_sha256": "b060fa01a84f8f864df39c3e6b933aade6c0bb1380fcad66681325da7456dbc2", - "kind": "seam", + "sha256": "36fc1099c4a13d53c875e51bde00667c2e197eefdf8e620a228f0077cf464519", "methods": [ "read_item" ], - "sha256": "36fc1099c4a13d53c875e51bde00667c2e197eefdf8e620a228f0077cf464519" + "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.", @@ -3117,12 +3117,12 @@ }, "functional_tests/test_group_settings_legacy_fixes.py::test_a_storage_failure_answers_reviewed_text_and_logs_no_detail::point-seam-1": { "boundary": { - "imports_sha256": "b06be0a0fd150f4e58c5a70feb36c9bff1a6511695eb78808d2b18e580a0e926", - "kind": "seam", + "sha256": "c8ad2bc393a568bbb2e08a5b6bb1befee9815552d7a06ae96f8666f1e9274906", "methods": [ "replace_item" ], - "sha256": "c8ad2bc393a568bbb2e08a5b6bb1befee9815552d7a06ae96f8666f1e9274906" + "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.", @@ -3132,12 +3132,12 @@ }, "functional_tests/test_group_tag_definition_writers.py::after_read::point-seam-1": { "boundary": { - "imports_sha256": "279a2c52556f2708b56ac14dddc977cf355d2b62f01c9477a78b319205b6a386", - "kind": "seam", + "sha256": "a0d566c18636c32ec440ab615ec4cae01fd6a216842cd7e0c98d6884a5b10d7d", "methods": [ "read_item" ], - "sha256": "a0d566c18636c32ec440ab615ec4cae01fd6a216842cd7e0c98d6884a5b10d7d" + "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.", @@ -3147,12 +3147,12 @@ }, "functional_tests/test_group_tag_definition_writers.py::tag_environment::point-seam-1": { "boundary": { - "imports_sha256": "279a2c52556f2708b56ac14dddc977cf355d2b62f01c9477a78b319205b6a386", - "kind": "seam", + "sha256": "76433caafd6d3c20a1efb44fa9be91390721a06a1e368ea30cfd885dca3fee17", "methods": [ "replace_item" ], - "sha256": "76433caafd6d3c20a1efb44fa9be91390721a06a1e368ea30cfd885dca3fee17" + "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.", @@ -3162,15 +3162,15 @@ }, "functional_tests/test_group_workflow_round_trip_preservation.py::WorkflowContainer": { "boundary": { - "imports_sha256": "213a78c7899a26c20dc181f07157990609fe837a4fa5d6e42e411892d69c70f4", - "inherited_bases": [], - "kind": "class", + "sha256": "fcfdcbc6eb450b7eefeef8ea71dd486450ab8253606f9124b0d57cd430110965", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "fcfdcbc6eb450b7eefeef8ea71dd486450ab8253606f9124b0d57cd430110965" + "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.", @@ -3180,15 +3180,15 @@ }, "functional_tests/test_image_chat_route_integration.py::MemoryContainer": { "boundary": { - "imports_sha256": "23548f44b2266b8b7fda3af985daaf1c99b171bca3c5c98a7c1659dafb6c058a", - "inherited_bases": [], - "kind": "class", + "sha256": "66c3681c61324062ea4f16f3292cfbc5f307e245c248af5b873f221e58082873", "methods": [ "read_item", "replace_item", "upsert_item" ], - "sha256": "66c3681c61324062ea4f16f3292cfbc5f307e245c248af5b873f221e58082873" + "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.", @@ -3198,13 +3198,13 @@ }, "functional_tests/test_image_reference_resolver.py::ImageReferenceResolverTests.test_personal_metadata_reader_never_searches_group_or_public_containers.FakeContainer": { "boundary": { - "imports_sha256": "0d82be48089ab62223b082c18d78e73c4f345b4d6c764aa7e567ad817f443290", - "inherited_bases": [], - "kind": "class", + "sha256": "3432746f67549a02907ede93fb407775652811a8d5ddaeae6cbb9c7014d2d30f", "methods": [ "read_item" ], - "sha256": "3432746f67549a02907ede93fb407775652811a8d5ddaeae6cbb9c7014d2d30f" + "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.", @@ -3214,14 +3214,14 @@ }, "functional_tests/test_keyvault_external_notification_telemetry.py::FakeReminderContainer": { "boundary": { - "imports_sha256": "ff3b964960dc41d57ba72a37e89d9e22b101271c24ba35e6438ba1f4356adf95", - "inherited_bases": [], - "kind": "class", + "sha256": "ced6026dd22762297ce7875f0ef300a761f54f91e7e875a27782001d3e7c2aa5", "methods": [ "read_item", "upsert_item" ], - "sha256": "ced6026dd22762297ce7875f0ef300a761f54f91e7e875a27782001d3e7c2aa5" + "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.", @@ -3231,13 +3231,13 @@ }, "functional_tests/test_large_image_api.py::FakeMessageContainer": { "boundary": { - "imports_sha256": "c776d34d76eba1a6dfa5178c57229551db9bac6378e6d2b2cae88a923706486d", - "inherited_bases": [], - "kind": "class", + "sha256": "d1094cc92298cad5298db3ce7b9a69e434cec50a0d3ed4be234a8abb12b22430", "methods": [ "read_item" ], - "sha256": "d1094cc92298cad5298db3ce7b9a69e434cec50a0d3ed4be234a8abb12b22430" + "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.", @@ -3247,14 +3247,14 @@ }, "functional_tests/test_log_credential_key_redaction.py::install_cosmos_stub.StubContainer": { "boundary": { - "imports_sha256": "0fd9fbef22fb5a8d978431b9162ac4fa157cf4f3a1edd57bf1af564b3ea6d00d", - "inherited_bases": [], - "kind": "class", + "sha256": "c6665c0f59b81a8b8a51c5bfdd3e7bb7575c4e804e4d98b1d99ff7c1c6c8b857", "methods": [ "read_item", "upsert_item" ], - "sha256": "c6665c0f59b81a8b8a51c5bfdd3e7bb7575c4e804e4d98b1d99ff7c1c6c8b857" + "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.", @@ -3264,15 +3264,15 @@ }, "functional_tests/test_log_injection_codeql_alerts_fix.py::CacheContainer": { "boundary": { - "imports_sha256": "ca7c1f871f49511c5e45d1b1caf305bcd8b7878de35925ae7bc6dda0d3e4d778", - "inherited_bases": [], - "kind": "class", + "sha256": "850fc4dc0539b2eaf57663b899d929566c18b48c5c6722965d7deb6f3436c7de", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "850fc4dc0539b2eaf57663b899d929566c18b48c5c6722965d7deb6f3436c7de" + "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.", @@ -3282,13 +3282,13 @@ }, "functional_tests/test_m365_action_card_api.py::CardContainer": { "boundary": { - "imports_sha256": "223e6494bc6d16315ef13da74c898b605f8787c7c16c4c858e517cdac83b7746", + "sha256": "5c5fa84ccf6faf43fe3f89db14a411da17ce9574e53fb77b3f1a7c2b345c615f", + "methods": [], + "kind": "class", "inherited_bases": [ "CosmosContainer" ], - "kind": "class", - "methods": [], - "sha256": "5c5fa84ccf6faf43fe3f89db14a411da17ce9574e53fb77b3f1a7c2b345c615f" + "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.", @@ -3298,9 +3298,7 @@ }, "functional_tests/test_m365_action_lifecycle.py::MemoryContainer": { "boundary": { - "imports_sha256": "7c17178a7266fe661f78e79c8e34dbf1613078b060537a245c7710c4417f18d6", - "inherited_bases": [], - "kind": "class", + "sha256": "4741678cd1dc20e09f9b5c26e3947409724a125764dfe0c47eb40f9219dcf0ea", "methods": [ "create_item", "delete_item", @@ -3309,7 +3307,9 @@ "replace_item", "upsert_item" ], - "sha256": "4741678cd1dc20e09f9b5c26e3947409724a125764dfe0c47eb40f9219dcf0ea" + "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.", @@ -3319,12 +3319,12 @@ }, "functional_tests/test_m365_action_lifecycle.py::test_exact_id_lookup_never_treats_storage_failure_as_absence::point-seam-1": { "boundary": { - "imports_sha256": "7c17178a7266fe661f78e79c8e34dbf1613078b060537a245c7710c4417f18d6", - "kind": "seam", + "sha256": "2e7b9535a14222fa8f62d879d5d4030861284bf8d85da24d2f30b18be6b24982", "methods": [ "read_item" ], - "sha256": "2e7b9535a14222fa8f62d879d5d4030861284bf8d85da24d2f30b18be6b24982" + "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.", @@ -3334,12 +3334,12 @@ }, "functional_tests/test_m365_action_lifecycle.py::test_migration_receipt_lookup_never_treats_storage_failure_as_absence::point-seam-1": { "boundary": { - "imports_sha256": "7c17178a7266fe661f78e79c8e34dbf1613078b060537a245c7710c4417f18d6", - "kind": "seam", + "sha256": "c287777136ee63a74e717bdd163ed58e713691c017e0f8a502c31d5ac0c802b2", "methods": [ "read_item" ], - "sha256": "c287777136ee63a74e717bdd163ed58e713691c017e0f8a502c31d5ac0c802b2" + "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.", @@ -3349,17 +3349,17 @@ }, "functional_tests/test_m365_chat_action_cards.py::run_offline_scenarios.Container": { "boundary": { - "imports_sha256": "157376cd360768efe2d84a5d030254dfdf587e56045075b21594e22884da2337", - "inherited_bases": [ - "OfflineContainer" - ], - "kind": "class", + "sha256": "f2d33f0cfc0606ced1211bdd1a1649c3b03fd6f3f5545b4c28292344d93f0b15", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "f2d33f0cfc0606ced1211bdd1a1649c3b03fd6f3f5545b4c28292344d93f0b15" + "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.", @@ -3369,15 +3369,15 @@ }, "functional_tests/test_m365_continuations.py::PendingJobs": { "boundary": { - "imports_sha256": "170b73fefd9f10a74777d8870f746c46a49f9f0b57f97cc7b2b9b67b751ec0a0", - "inherited_bases": [ - "CosmosContainer" - ], - "kind": "class", + "sha256": "374ed222329c5a7b15badf2083f10142d53b9be06bdd766ef70a36381f50a731", "methods": [ "replace_item" ], - "sha256": "374ed222329c5a7b15badf2083f10142d53b9be06bdd766ef70a36381f50a731" + "kind": "class", + "inherited_bases": [ + "CosmosContainer" + ], + "imports_sha256": "170b73fefd9f10a74777d8870f746c46a49f9f0b57f97cc7b2b9b67b751ec0a0" }, "classification": "sdk-default", "contract": "Inherits installed SDK CosmosDict point/write responses and conditional ETag/partition behavior. Filtered query rows are plain dictionaries; before_replace injects storage failures or concurrent state changes without changing response shape.", @@ -3387,15 +3387,15 @@ }, "functional_tests/test_m365_conversation_lifecycle.py::PendingContainer": { "boundary": { - "imports_sha256": "ade1afad3c494c1be72d915bb19e8e7171428de5454a8a50c29a85aa8287ec24", - "inherited_bases": [ - "CosmosContainer" - ], - "kind": "class", + "sha256": "50e82aa336f310c9692377119748028f14af5dc5d012e462696123ed00b8e6da", "methods": [ "replace_item" ], - "sha256": "50e82aa336f310c9692377119748028f14af5dc5d012e462696123ed00b8e6da" + "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.", @@ -3405,12 +3405,12 @@ }, "functional_tests/test_m365_file_runtime.py::test_conditional_conflicts_retry_the_same_budget_with_fresh_etags::point-seam-1": { "boundary": { - "imports_sha256": "67e69c7f26dc001fad12112c8c8c75a41705da2963df550ac99fd30632b5582e", - "kind": "seam", + "sha256": "fb8f6c7d4f97eb72efc225356b65966ed8175882365ff6e34c87e99cb7bcd9bb", "methods": [ "replace_item" ], - "sha256": "fb8f6c7d4f97eb72efc225356b65966ed8175882365ff6e34c87e99cb7bcd9bb" + "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.", @@ -3420,12 +3420,12 @@ }, "functional_tests/test_m365_file_runtime.py::test_conflict_cannot_switch_to_another_request_budget::point-seam-1": { "boundary": { - "imports_sha256": "67e69c7f26dc001fad12112c8c8c75a41705da2963df550ac99fd30632b5582e", - "kind": "seam", + "sha256": "906ae1300b4f7097877fd71555578e9d7b27d46ef4ca3f7d247e06b4185b8587", "methods": [ "replace_item" ], - "sha256": "906ae1300b4f7097877fd71555578e9d7b27d46ef4ca3f7d247e06b4185b8587" + "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.", @@ -3435,12 +3435,12 @@ }, "functional_tests/test_m365_file_runtime.py::test_final_conflict_exhaustion_is_an_error_not_an_empty_budget::point-seam-1": { "boundary": { - "imports_sha256": "67e69c7f26dc001fad12112c8c8c75a41705da2963df550ac99fd30632b5582e", - "kind": "seam", + "sha256": "03beaa2c2a904c20d0b089af667297cb11582c87f39f43636252ba7589aac1c6", "methods": [ "replace_item" ], - "sha256": "03beaa2c2a904c20d0b089af667297cb11582c87f39f43636252ba7589aac1c6" + "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.", @@ -3450,12 +3450,12 @@ }, "functional_tests/test_m365_file_runtime.py::test_non_conflict_storage_failures_are_surfaced_without_retry::point-seam-1": { "boundary": { - "imports_sha256": "67e69c7f26dc001fad12112c8c8c75a41705da2963df550ac99fd30632b5582e", - "kind": "seam", + "sha256": "5dcb21190e289075c7878379ef1b7d479518edda960e5da2e9ab96ffa99d64e4", "methods": [ "replace_item" ], - "sha256": "5dcb21190e289075c7878379ef1b7d479518edda960e5da2e9ab96ffa99d64e4" + "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.", @@ -3465,12 +3465,12 @@ }, "functional_tests/test_m365_pending_action_provenance.py::test_capture_step_reference_consumes_sdk_point_reads_and_real_owned_run::point-seam-1": { "boundary": { - "imports_sha256": "42f33051b762084913dd8fe138850f528e188013e6be27d5da89b3c0fcf54332", - "kind": "seam", + "sha256": "633549856b976da82a3f5a0631dbd766f50eeb15a3053a10d3611af45b60d11f", "methods": [ "read_item" ], - "sha256": "633549856b976da82a3f5a0631dbd766f50eeb15a3053a10d3611af45b60d11f" + "kind": "seam", + "imports_sha256": "42f33051b762084913dd8fe138850f528e188013e6be27d5da89b3c0fcf54332" }, "classification": "sdk-default", "contract": "Observing wrapper delegates unchanged to the SDK-default CosmosContainer point read, records the actual CosmosDict and ETag, and verifies owned request/run provenance through the real capture callback.", @@ -3481,12 +3481,12 @@ }, "functional_tests/test_m365_pending_action_provenance.py::test_capture_step_reference_consumes_sdk_point_reads_and_real_owned_run::point-seam-2": { "boundary": { - "imports_sha256": "42f33051b762084913dd8fe138850f528e188013e6be27d5da89b3c0fcf54332", - "kind": "seam", + "sha256": "9425db33552cf53ce14aecd24deb008954518b2415504b5aca4693cdfaee9dc9", "methods": [ "read_item" ], - "sha256": "9425db33552cf53ce14aecd24deb008954518b2415504b5aca4693cdfaee9dc9" + "kind": "seam", + "imports_sha256": "42f33051b762084913dd8fe138850f528e188013e6be27d5da89b3c0fcf54332" }, "classification": "sdk-default", "contract": "Observing wrapper delegates unchanged to the SDK-default CosmosContainer point read, records the actual CosmosDict and ETag, and verifies owned request/run provenance through the real capture callback.", @@ -3497,13 +3497,13 @@ }, "functional_tests/test_m365_pending_delivery.py::PendingContainer": { "boundary": { - "imports_sha256": "cd44d9968998c5e949b8a9f11772a70562ed1171aa42189b0e6f9549c044c7f3", + "sha256": "781a9a2f4b437798bb857da970ba2502e71cdf9918a4d7fa1abca12c6ea56747", + "methods": [], + "kind": "class", "inherited_bases": [ "CosmosContainer" ], - "kind": "class", - "methods": [], - "sha256": "781a9a2f4b437798bb857da970ba2502e71cdf9918a4d7fa1abca12c6ea56747" + "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.", @@ -3513,12 +3513,12 @@ }, "functional_tests/test_m365_pending_review.py::test_lost_batch_acknowledgement_does_not_overwrite_the_committed_save::point-seam-1": { "boundary": { - "imports_sha256": "cf46ffcf60dbee59bbeeeea8cfc0588bf28c9e58d091a65b9a15c087721db736", - "kind": "seam", + "sha256": "cc55654c5cab6ff39f1a785c73efe1ac28e3248d00bd5c016427352d6ea3f462", "methods": [ "execute_item_batch" ], - "sha256": "cc55654c5cab6ff39f1a785c73efe1ac28e3248d00bd5c016427352d6ea3f462" + "kind": "seam", + "imports_sha256": "cf46ffcf60dbee59bbeeeea8cfc0588bf28c9e58d091a65b9a15c087721db736" }, "classification": "fault-injection", "contract": "Inject an explicit Cosmos batch acknowledgement/persistence failure into the SDK-default owner-partitioned transaction fixture; preserve ETags and verify non-sendable reconciliation or no overwrite after a committed acknowledgement is lost.", @@ -3529,12 +3529,12 @@ }, "functional_tests/test_m365_pending_review.py::test_partial_graph_cosmos_save_blocks_send_until_read_only_reconciliation::point-seam-1": { "boundary": { - "imports_sha256": "cf46ffcf60dbee59bbeeeea8cfc0588bf28c9e58d091a65b9a15c087721db736", - "kind": "seam", + "sha256": "f7870c08e9da054315f356a6e45912031d09d04ecd86f2417969e96de0080469", "methods": [ "execute_item_batch" ], - "sha256": "f7870c08e9da054315f356a6e45912031d09d04ecd86f2417969e96de0080469" + "kind": "seam", + "imports_sha256": "cf46ffcf60dbee59bbeeeea8cfc0588bf28c9e58d091a65b9a15c087721db736" }, "classification": "fault-injection", "contract": "Inject an explicit Cosmos batch acknowledgement/persistence failure into the SDK-default owner-partitioned transaction fixture; preserve ETags and verify non-sendable reconciliation or no overwrite after a committed acknowledgement is lost.", @@ -3545,12 +3545,12 @@ }, "functional_tests/test_m365_pending_review.py::test_partial_graph_cosmos_save_blocks_send_until_read_only_reconciliation::point-seam-2": { "boundary": { - "imports_sha256": "cf46ffcf60dbee59bbeeeea8cfc0588bf28c9e58d091a65b9a15c087721db736", - "kind": "seam", + "sha256": "507500b208d5f908f2d58b66cfa361e29d999855fc7fb77a1823701cd95770b9", "methods": [ "execute_item_batch" ], - "sha256": "507500b208d5f908f2d58b66cfa361e29d999855fc7fb77a1823701cd95770b9" + "kind": "seam", + "imports_sha256": "cf46ffcf60dbee59bbeeeea8cfc0588bf28c9e58d091a65b9a15c087721db736" }, "classification": "fault-injection", "contract": "Inject an explicit Cosmos batch acknowledgement/persistence failure into the SDK-default owner-partitioned transaction fixture; preserve ETags and verify non-sendable reconciliation or no overwrite after a committed acknowledgement is lost.", @@ -3561,12 +3561,12 @@ }, "functional_tests/test_m365_routes.py::M365RouteTests.test_bindings_recheck_removed_group_membership_before_reading_the_workflow::point-seam-1": { "boundary": { - "imports_sha256": "cf36de4529542b772d9e2fcc20ff53b7f06475c6f1ee37ef0a447d4245a0c452", - "kind": "seam", + "sha256": "6f8e0e49b9a01b2c27b59739b5948290eac804a2ba0146dd6b9d785ec951738c", "methods": [ "read_item" ], - "sha256": "6f8e0e49b9a01b2c27b59739b5948290eac804a2ba0146dd6b9d785ec951738c" + "kind": "seam", + "imports_sha256": "cf36de4529542b772d9e2fcc20ff53b7f06475c6f1ee37ef0a447d4245a0c452" }, "classification": "sdk-default", "contract": "Scoped wraps spy retains the shared CosmosContainer's actual SDK point responses and proves denied group membership prevents any workflow point read.", @@ -3576,12 +3576,12 @@ }, "functional_tests/test_m365_routes.py::M365RouteTests.test_bindings_resolve_duplicate_revisions_once_and_keep_them_separate::point-seam-1": { "boundary": { - "imports_sha256": "cf36de4529542b772d9e2fcc20ff53b7f06475c6f1ee37ef0a447d4245a0c452", - "kind": "seam", + "sha256": "3cf321d5508cc7f0c6b91cb83615631bd4aaf9f83d839827eb006ddcc921efbd", "methods": [ "read_item" ], - "sha256": "3cf321d5508cc7f0c6b91cb83615631bd4aaf9f83d839827eb006ddcc921efbd" + "kind": "seam", + "imports_sha256": "cf36de4529542b772d9e2fcc20ff53b7f06475c6f1ee37ef0a447d4245a0c452" }, "classification": "sdk-default", "contract": "Scoped wraps spy delegates unchanged to SDK-default CosmosContainer.read_item and proves duplicate revision projections share exactly one point read without collapsing authorization rows.", @@ -3591,12 +3591,12 @@ }, "functional_tests/test_m365_routes.py::M365RouteTests.test_bindings_storage_outage_is_a_safe_error_not_an_empty_success::point-seam-1": { "boundary": { - "imports_sha256": "cf36de4529542b772d9e2fcc20ff53b7f06475c6f1ee37ef0a447d4245a0c452", - "kind": "seam", + "sha256": "53f954faea243b7a5da24cc366055fa1eeaa97a2da85806af15318aa766676e8", "methods": [ "read_item" ], - "sha256": "53f954faea243b7a5da24cc366055fa1eeaa97a2da85806af15318aa766676e8" + "kind": "seam", + "imports_sha256": "cf36de4529542b772d9e2fcc20ff53b7f06475c6f1ee37ef0a447d4245a0c452" }, "classification": "fault-injection", "contract": "Scoped read_item override injects an actual Cosmos 503; route regression requires a safe service error rather than an empty authorization list and restores the override afterward.", @@ -3606,12 +3606,12 @@ }, "functional_tests/test_m365_routes.py::M365RouteTests.test_dependency_errors_do_not_reveal_sdk_or_configuration_text::point-seam-1": { "boundary": { - "imports_sha256": "cf36de4529542b772d9e2fcc20ff53b7f06475c6f1ee37ef0a447d4245a0c452", - "kind": "seam", + "sha256": "cea48015294e2bdb9f4be906ce1b7452838f89eb8de70ebbef5011013501d9c4", "methods": [ "read_item" ], - "sha256": "cea48015294e2bdb9f4be906ce1b7452838f89eb8de70ebbef5011013501d9c4" + "kind": "seam", + "imports_sha256": "cf36de4529542b772d9e2fcc20ff53b7f06475c6f1ee37ef0a447d4245a0c452" }, "classification": "fault-injection", "contract": "Scoped existing read_item error injection verifies that SDK/configuration details do not reach the client. The override is restored and shared CosmosContainer SDK responses remain the normal path.", @@ -3621,16 +3621,16 @@ }, "functional_tests/test_m365_runtime_imports.py::embedded-PROBE::Container": { "boundary": { - "embedded_source_sha256": "e4bb84504993bb9aa316f4dddc893e6969d2e1264e6db89a804b9dca7cb4ed0d", - "imports_sha256": "5d7607d00227de444f1b96c124f2e08824c04641e25c293b045f57fa0a9b8741", - "inherited_bases": [], - "kind": "class", + "sha256": "c3c82162303c319991945e0a07391391d4b5f3d1976a700c203e78d49aafc0c2", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "c3c82162303c319991945e0a07391391d4b5f3d1976a700c203e78d49aafc0c2" + "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.", @@ -3640,15 +3640,15 @@ }, "functional_tests/test_m365_settings_ingress.py::test_concurrent_removal_cannot_be_undone_by_a_stale_settings_write.Container": { "boundary": { - "imports_sha256": "351b36f8b6a199f78871308200ed17f67bfa19dfdc08a6667342623569a67c48", - "inherited_bases": [ - "CosmosContainer" - ], - "kind": "class", + "sha256": "8bc5d5da6998091069223c362b921aec80958cd21b8cbc686a3ae80a00edb842", "methods": [ "replace_item" ], - "sha256": "8bc5d5da6998091069223c362b921aec80958cd21b8cbc686a3ae80a00edb842" + "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.", @@ -3658,12 +3658,12 @@ }, "functional_tests/test_m365_workflow_continuation_boundary.py::test_loader_does_not_translate_authorization_or_storage_failure_into_deletion::point-seam-1": { "boundary": { - "imports_sha256": "1421386a0144cb4d828af7085068c63a78bea5d8abe3730634a177abe7b60ab3", - "kind": "seam", + "sha256": "c911c24ca985dad5aa22384c32560fc985a8d70f10ef2ba061677aeddd306984", "methods": [ "read_item" ], - "sha256": "c911c24ca985dad5aa22384c32560fc985a8d70f10ef2ba061677aeddd306984" + "kind": "seam", + "imports_sha256": "1421386a0144cb4d828af7085068c63a78bea5d8abe3730634a177abe7b60ab3" }, "classification": "fault-injection", "contract": "Scoped point-read failure injection proves permission, throttling and storage-unavailable errors remain distinct from authoritative workflow deletion.", @@ -3673,12 +3673,12 @@ }, "functional_tests/test_m365_workflow_continuation_boundary.py::test_loader_rejects_a_response_for_a_different_scope::point-seam-1": { "boundary": { - "imports_sha256": "1421386a0144cb4d828af7085068c63a78bea5d8abe3730634a177abe7b60ab3", - "kind": "seam", + "sha256": "f2767071077fb8456111e2671a83d614820d07358fbd6c58bc8d8d05e4536ccf", "methods": [ "read_item" ], - "sha256": "f2767071077fb8456111e2671a83d614820d07358fbd6c58bc8d8d05e4536ccf" + "kind": "seam", + "imports_sha256": "1421386a0144cb4d828af7085068c63a78bea5d8abe3730634a177abe7b60ab3" }, "classification": "fault-injection", "contract": "Invalid personal/group point response scope injection proves the loader fails closed instead of treating another scope as the requested workflow.", @@ -3688,12 +3688,12 @@ }, "functional_tests/test_m365_workflow_continuation_boundary.py::test_loader_rejects_invalid_sdk_response_instead_of_classifying_it_as_missing::point-seam-1": { "boundary": { - "imports_sha256": "1421386a0144cb4d828af7085068c63a78bea5d8abe3730634a177abe7b60ab3", - "kind": "seam", + "sha256": "3712fdcdb9a897824dd3fb62e450d8a76b2589e3ca58c3dbde69a0ef262b5826", "methods": [ "read_item" ], - "sha256": "3712fdcdb9a897824dd3fb62e450d8a76b2589e3ca58c3dbde69a0ef262b5826" + "kind": "seam", + "imports_sha256": "1421386a0144cb4d828af7085068c63a78bea5d8abe3730634a177abe7b60ab3" }, "classification": "fault-injection", "contract": "A non-document point response explicitly fails normalization with TypeError; it never becomes a success-shaped empty document or authoritative deletion.", @@ -3703,12 +3703,12 @@ }, "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_global_save_propagates_lookup_failures_without_writes::point-seam-1": { "boundary": { - "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e", - "kind": "seam", + "sha256": "1653fa53442c2ff73063c907c6fa024d52aa8339e7694578a5f7f8a5995166fd", "methods": [ "read_item" ], - "sha256": "1653fa53442c2ff73063c907c6fa024d52aa8339e7694578a5f7f8a5995166fd" + "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.", @@ -3718,12 +3718,12 @@ }, "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_legacy_list_read_and_validation_failures_remain_visible::point-seam-1": { "boundary": { - "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e", - "kind": "seam", + "sha256": "da84de4ca53f69b25bde1785d35bdc81055597e3547cb29ed106babb167cb963", "methods": [ "read_item" ], - "sha256": "da84de4ca53f69b25bde1785d35bdc81055597e3547cb29ed106babb167cb963" + "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.", @@ -3733,12 +3733,12 @@ }, "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_legacy_list_read_and_validation_failures_remain_visible::point-seam-2": { "boundary": { - "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e", - "kind": "seam", + "sha256": "1abf3ee47780e06bd6f7e49db878beef651ec9885dafaab3ec442e18bfe98d10", "methods": [ "read_item" ], - "sha256": "1abf3ee47780e06bd6f7e49db878beef651ec9885dafaab3ec442e18bfe98d10" + "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.", @@ -3748,12 +3748,12 @@ }, "functional_tests/test_mcp_legacy_stdio_management.py::LegacyMcpManagementTests.test_route_settings_preflight_entry_point_preserves_sources_and_propagates_failures::point-seam-1": { "boundary": { - "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e", - "kind": "seam", + "sha256": "5f530b365d4d3744e34544bf00bb21285e9200e258fcd382e7a91354f8ba9f6f", "methods": [ "read_item" ], - "sha256": "5f530b365d4d3744e34544bf00bb21285e9200e258fcd382e7a91354f8ba9f6f" + "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.", @@ -3763,12 +3763,12 @@ }, "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": { - "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e", - "kind": "seam", + "sha256": "f44ad55f6ecb7b0f6866aa6fa5fcfdde3171c80eccd3021b6d28d65156d442b3", "methods": [ "read_item" ], - "sha256": "f44ad55f6ecb7b0f6866aa6fa5fcfdde3171c80eccd3021b6d28d65156d442b3" + "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.", @@ -3778,9 +3778,7 @@ }, "functional_tests/test_mcp_legacy_stdio_management.py::MemoryContainer": { "boundary": { - "imports_sha256": "83eb48c2e90b4120c18107569bbfa1612b58f5e7a5d53442b554aad7269dbc1e", - "inherited_bases": [], - "kind": "class", + "sha256": "96d08538b372cc602d8abe54349672e82674a98b1bb16c6f6cb3b9c056d84381", "methods": [ "create_item", "delete_item", @@ -3788,7 +3786,9 @@ "replace_item", "upsert_item" ], - "sha256": "96d08538b372cc602d8abe54349672e82674a98b1bb16c6f6cb3b9c056d84381" + "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.", @@ -3798,14 +3798,14 @@ }, "functional_tests/test_mixed_source_hardening.py::test_citation_artifact_cancellation_rolls_back_partial_publication.CitationContainer": { "boundary": { - "imports_sha256": "4408d89070f741e64540573015de52d1bdb6715a3f89edf109b0f12e1e7fd2e4", - "inherited_bases": [], - "kind": "class", + "sha256": "54735623f0241a478ad905f5ad5daaa819b237d5023a9e1b734d099dae84fdd2", "methods": [ "delete_item", "upsert_item" ], - "sha256": "54735623f0241a478ad905f5ad5daaa819b237d5023a9e1b734d099dae84fdd2" + "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.", @@ -3815,13 +3815,13 @@ }, "functional_tests/test_mixed_source_manifest_contracts.py::FakeItemContainer": { "boundary": { - "imports_sha256": "c66a388d4c4690dc7cd31255497ba8244b25cf70b6e9112659f709b5242b240e", - "inherited_bases": [], - "kind": "class", + "sha256": "24ba4aa7bf3c08c05cad242bfbfa4ae2d337171f6bf62f2b62acd8a995b769e2", "methods": [ "read_item" ], - "sha256": "24ba4aa7bf3c08c05cad242bfbfa4ae2d337171f6bf62f2b62acd8a995b769e2" + "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.", @@ -3831,15 +3831,15 @@ }, "functional_tests/test_native_tabular_compute_service.py::MemoryContainer": { "boundary": { - "imports_sha256": "c304baf9af95ebecdac3a41502792f66a171c78a4de7db32ba67c2970dd56cf2", - "inherited_bases": [], - "kind": "class", + "sha256": "51c108748e764ca77d9ee43629976687d3edcfec66d1607531a1f74fd92ac839", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "51c108748e764ca77d9ee43629976687d3edcfec66d1607531a1f74fd92ac839" + "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.", @@ -3849,12 +3849,12 @@ }, "functional_tests/test_native_tabular_compute_service.py::test_atomic_submission_race_preserves_one_owned_job::point-seam-1": { "boundary": { - "imports_sha256": "c304baf9af95ebecdac3a41502792f66a171c78a4de7db32ba67c2970dd56cf2", - "kind": "seam", + "sha256": "1bdaaaff6a7e22079eda405fe1a28a92da40ff2f67cf7b7f8450480a7525e2be", "methods": [ "create_item" ], - "sha256": "1bdaaaff6a7e22079eda405fe1a28a92da40ff2f67cf7b7f8450480a7525e2be" + "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.", @@ -3880,12 +3880,12 @@ }, "functional_tests/test_orchestration_checkpoint_error_mapping.py::_fail_read::point-seam-1": { "boundary": { - "imports_sha256": "c005a367ec556c21fb9709a8b38d3342ad75be556e6fd25d1f401b1032898230", - "kind": "seam", + "sha256": "3e35d79e181b545da041acce22846df169b8fd8cf8d40f4bf4d75385d6065423", "methods": [ "read_item" ], - "sha256": "3e35d79e181b545da041acce22846df169b8fd8cf8d40f4bf4d75385d6065423" + "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.", @@ -3895,12 +3895,12 @@ }, "functional_tests/test_orchestration_cleanup_bootstrap.py::test_root_cleanup_does_not_coerce_non_mapping_authority::point-seam-1": { "boundary": { - "imports_sha256": "01edeac6a183cb3c16f5194da8b41aaf635410556f1ce1c5a47a62a08bbb2083", - "kind": "seam", + "sha256": "d25477701a063b4ec9eb00ae5ae819dc49f2c2402a94223e37c2e565b29a978e", "methods": [ "read_item" ], - "sha256": "d25477701a063b4ec9eb00ae5ae819dc49f2c2402a94223e37c2e565b29a978e" + "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.", @@ -3910,12 +3910,12 @@ }, "functional_tests/test_orchestration_continuation.py::test_result_read_rechecks_epoch_after_the_control_point_read::point-seam-1": { "boundary": { - "imports_sha256": "4f2ae2302607b6cc425baba0619c61f61004eacb3f8ce785c0375fce7fd9606b", - "kind": "seam", + "sha256": "b9db7b512f12ea248e71f5592e102cb0a1b5a5196b4b8370985a55185f288d31", "methods": [ "read_item" ], - "sha256": "b9db7b512f12ea248e71f5592e102cb0a1b5a5196b4b8370985a55185f288d31" + "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.", @@ -3925,15 +3925,15 @@ }, "functional_tests/test_orchestration_conversation_sends.py::HandoffContainer": { "boundary": { - "imports_sha256": "8ee36f0b1d085023c9fd1f9a6163e72b83ca30e1163a66a64b0d5417aceaa6b5", - "inherited_bases": [ - "CosmosContainer" - ], - "kind": "class", + "sha256": "70538dbb381f10d29f774596106038dd20044172b7137803eb69b8bbf52e58ca", "methods": [ "execute_item_batch" ], - "sha256": "70538dbb381f10d29f774596106038dd20044172b7137803eb69b8bbf52e58ca" + "kind": "class", + "inherited_bases": [ + "CosmosContainer" + ], + "imports_sha256": "8ee36f0b1d085023c9fd1f9a6163e72b83ca30e1163a66a64b0d5417aceaa6b5" }, "classification": "sdk-default", "contract": "Inherits CosmosContainer SDK-default CosmosDict point responses and partition batch checks for orchestration conversation_send tests.", @@ -3943,12 +3943,12 @@ }, "functional_tests/test_orchestration_conversation_sources.py::test_shared_membership_is_rechecked_before_exact_message_reads::point-seam-1": { "boundary": { - "imports_sha256": "f0599840a873c4b2b7527f041707fee865cbb299475b843098f7e4dad8f30b5a", - "kind": "seam", + "sha256": "5bcc0ff1ff276e52a070e436c365264d75ca35b276a56f656a1a1d33f71f01ff", "methods": [ "read_item" ], - "sha256": "5bcc0ff1ff276e52a070e436c365264d75ca35b276a56f656a1a1d33f71f01ff" + "kind": "seam", + "imports_sha256": "f0599840a873c4b2b7527f041707fee865cbb299475b843098f7e4dad8f30b5a" }, "classification": "fault-injection", "contract": "A wrapping Mock observes the SDK-default message read without changing its return type; revoked shared membership must fail before any message point read. This authorization fault does not add a plain-response compatibility override.", @@ -3958,12 +3958,12 @@ }, "functional_tests/test_orchestration_cosmos_response_contract.py::test_output_read_does_not_coerce_non_mapping_documents::point-seam-1": { "boundary": { - "imports_sha256": "b5ef5089f52fd0efe406899e50214208bd5477cbeab34e3f5c72eb50a4124e80", - "kind": "seam", + "sha256": "ed77313ec6c261e459ef59076c389e757f9aaeb1372f5b76a997b1bb77b9687e", "methods": [ "read_item" ], - "sha256": "ed77313ec6c261e459ef59076c389e757f9aaeb1372f5b76a997b1bb77b9687e" + "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.", @@ -3973,12 +3973,12 @@ }, "functional_tests/test_orchestration_deletion_enrollment.py::test_cleanup_fences_and_enrolls_before_any_payload_sweep::point-seam-1": { "boundary": { - "imports_sha256": "018189e9e54312fbb6e46a4761370d31cfa70f78621b47056c854117de855b91", - "kind": "seam", + "sha256": "71d12a59427f8279ba5887fad289581fc7cc7c597d50672102c3253ac3deda29", "methods": [ "replace_item" ], - "sha256": "71d12a59427f8279ba5887fad289581fc7cc7c597d50672102c3253ac3deda29" + "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.", @@ -3988,12 +3988,12 @@ }, "functional_tests/test_orchestration_deletion_enrollment.py::test_lost_parent_ack_has_real_guard_proof_for_missing_conversation_replay::point-seam-1": { "boundary": { - "imports_sha256": "018189e9e54312fbb6e46a4761370d31cfa70f78621b47056c854117de855b91", - "kind": "seam", + "sha256": "dcc6542c722e5c4cda3d2e8c7fe32c243c2ce3428319734f1b8fe07243e3c5c4", "methods": [ "replace_item" ], - "sha256": "dcc6542c722e5c4cda3d2e8c7fe32c243c2ce3428319734f1b8fe07243e3c5c4" + "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.", @@ -4003,13 +4003,13 @@ }, "functional_tests/test_orchestration_deliverables.py::test_the_approval_route_never_pays_twice_for_a_planned_image.Messages": { "boundary": { - "imports_sha256": "5a172dca09372be6f191944f2ded71f1ffd21091325a2fc77a082de8eadb8daf", - "inherited_bases": [], - "kind": "class", + "sha256": "185603c419923e6a59ac652bf325f1d69e078281625d4eaa272ae673d45b1e15", "methods": [ "read_item" ], - "sha256": "185603c419923e6a59ac652bf325f1d69e078281625d4eaa272ae673d45b1e15" + "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.", @@ -4018,15 +4018,15 @@ ] }, "functional_tests/test_orchestration_elicitation_context.py::MemoryContainer": { - "boundary": { - "imports_sha256": "8cc6cf8f8f8a4f8c5df25a27861d1632c4160c046cfb3e48acb1e6c217d50c3a", - "inherited_bases": [], - "kind": "class", + "boundary": { + "sha256": "4c7512e8faa35eec8329abd247417a2c34ae132a19b3272256d833cc890d012c", "methods": [ "create_item", "read_item" ], - "sha256": "4c7512e8faa35eec8329abd247417a2c34ae132a19b3272256d833cc890d012c" + "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.", @@ -4036,15 +4036,15 @@ }, "functional_tests/test_orchestration_external_bootstrap.py::BoundedMemoryContainer": { "boundary": { - "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "d0b37f6c2d5e4054916b28f0a814f8db00c20d573ec485a79cf0843e57f8fbc9", "methods": [ "read_item" ], - "sha256": "d0b37f6c2d5e4054916b28f0a814f8db00c20d573ec485a79cf0843e57f8fbc9" + "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.", @@ -4054,12 +4054,12 @@ }, "functional_tests/test_orchestration_external_bootstrap.py::external_root::point-seam-1": { "boundary": { - "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914", - "kind": "seam", + "sha256": "128a6979b10f4d6646c651bff76cdbd7ca18c2dbe2cef02cb29284f3d1ca1006", "methods": [ "read_item" ], - "sha256": "128a6979b10f4d6646c651bff76cdbd7ca18c2dbe2cef02cb29284f3d1ca1006" + "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.", @@ -4069,12 +4069,12 @@ }, "functional_tests/test_orchestration_external_bootstrap.py::external_root::point-seam-2": { "boundary": { - "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914", - "kind": "seam", + "sha256": "8c3617de129777ab14269de13af1e1d0558e33c8dfa5f9d784ae2fd9ee90c481", "methods": [ "read_item" ], - "sha256": "8c3617de129777ab14269de13af1e1d0558e33c8dfa5f9d784ae2fd9ee90c481" + "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.", @@ -4084,12 +4084,12 @@ }, "functional_tests/test_orchestration_external_bootstrap.py::test_default_root_current_authority_storage_failures_are_operational::point-seam-1": { "boundary": { - "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914", - "kind": "seam", + "sha256": "d6f8a585739ade682a621237de116c855149affcafa4937bb7c4fed543191deb", "methods": [ "read_item" ], - "sha256": "d6f8a585739ade682a621237de116c855149affcafa4937bb7c4fed543191deb" + "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.", @@ -4099,12 +4099,12 @@ }, "functional_tests/test_orchestration_external_bootstrap.py::test_identity_does_not_coerce_non_mapping_settings_into_authority::point-seam-1": { "boundary": { - "imports_sha256": "61e1483b61cd32925ab4ee255b2cf88e9ee32b93721fceef418e75e6c5d8e914", - "kind": "seam", + "sha256": "90c7d666e3fefb7404a9a64b64320dec2b8a1e4f47035ffbbbe17e0813ccb7e7", "methods": [ "read_item" ], - "sha256": "90c7d666e3fefb7404a9a64b64320dec2b8a1e4f47035ffbbbe17e0813ccb7e7" + "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.", @@ -4114,15 +4114,15 @@ }, "functional_tests/test_orchestration_external_metadata.py::RecordedContainer": { "boundary": { - "imports_sha256": "7e8e91dfa03d0f51193b0efedea4151fc296b477a4f3f77a670846ad86f7abfd", - "inherited_bases": [ - "OfflineContainer" - ], - "kind": "class", + "sha256": "5aeae4f56eede4708fb864172f8da2aaee454efaa519f151c5541f266300481b", "methods": [ "read_item" ], - "sha256": "5aeae4f56eede4708fb864172f8da2aaee454efaa519f151c5541f266300481b" + "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.", @@ -4132,12 +4132,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_actual_preflight_preserves_current_metadata_failure_identity::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a", "methods": [ "read_item" ], - "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4147,12 +4147,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_authority_infrastructure_never_becomes_a_headless_denial::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "1fe9e7710f877436ea9b8870308cf12b359df33d11262d1a03649f831ce5b520", "methods": [ "read_item" ], - "sha256": "1fe9e7710f877436ea9b8870308cf12b359df33d11262d1a03649f831ce5b520" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4162,12 +4162,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_checkpoint_read_outage_preserves_the_committed_file_before_publication::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "3b69833d6a85255c0bb6eba7f71253a0577f994f89fc1aa1a99e6bd11946c711", "methods": [ "read_item" ], - "sha256": "3b69833d6a85255c0bb6eba7f71253a0577f994f89fc1aa1a99e6bd11946c711" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4177,12 +4177,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_citation_delivery_rechecks_exact_sources_and_preserves_storage_uncertainty.recheck_source::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "c7f8bb94a1a8c1eff60c08adc0840bbc505c6eb74377671754ebc18c55a79c67", "methods": [ "read_item" ], - "sha256": "c7f8bb94a1a8c1eff60c08adc0840bbc505c6eb74377671754ebc18c55a79c67" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4192,12 +4192,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_continuation_io_preserves_saved_work_for_retry::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "baaa4ce5df20663649b827a4920d91efda4cec0db088d1f5935d49ea361e9f95", "methods": [ "read_item" ], - "sha256": "baaa4ce5df20663649b827a4920d91efda4cec0db088d1f5935d49ea361e9f95" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4207,12 +4207,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_execution_publication_authority_failure_closes_without_a_success_frame::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "c4ddbf15fb364bad038ea13c721bcc2b536f2ee7fd65210299fd114f0a169e62", "methods": [ "execute_item_batch" ], - "sha256": "c4ddbf15fb364bad038ea13c721bcc2b536f2ee7fd65210299fd114f0a169e62" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4222,12 +4222,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_external_runtime_callbacks_keep_signature_return_and_shared_service_identity::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a", "methods": [ "read_item" ], - "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4237,12 +4237,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_external_runtime_callbacks_preserve_typed_failures_and_recheck_the_live_lease::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a", "methods": [ "read_item" ], - "sha256": "3b814f3d8d3b27b12b1d58c2073844f1c272cc1a1ae09c6e32800860539ae27a" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4252,12 +4252,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_harness_strict_source_io_failures_remain_fenced_at_the_real_model_boundary::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "37998590203a13263aa03e900474a29a0e752cef8d5b23ca5f3a08c8dab307b0", "methods": [ "read_item" ], - "sha256": "37998590203a13263aa03e900474a29a0e752cef8d5b23ca5f3a08c8dab307b0" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4267,12 +4267,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_initial_result_binding_outage_does_not_publish_a_terminal_outcome::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "c5ff4e5efcc4ad222aee835fc779775b80108c3b0b6cac7461bb47058894e15b", "methods": [ "read_item" ], - "sha256": "c5ff4e5efcc4ad222aee835fc779775b80108c3b0b6cac7461bb47058894e15b" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4282,12 +4282,12 @@ }, "functional_tests/test_orchestration_harness_execution.py::test_real_native_checkpoint_read_outage_does_not_poll_or_finalize::point-seam-1": { "boundary": { - "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2", - "kind": "seam", + "sha256": "3586a71ead022f24807de996cb19caf838d1c453238971017baff7e28a856ca9", "methods": [ "read_item" ], - "sha256": "3586a71ead022f24807de996cb19caf838d1c453238971017baff7e28a856ca9" + "kind": "seam", + "imports_sha256": "e2939a84d992c600671235caf974deab46a571ea211d79df7a91b64b583d53a2" }, "classification": "fault-injection", "contract": "Existing scoped failure/race override is implementation-unchanged; normal point operations delegate to the SDK-default shared container. The containing real-runtime test restores the override and verifies the named fault without changing the default CosmosDict response contract.", @@ -4297,12 +4297,12 @@ }, "functional_tests/test_orchestration_harness_routes.py::test_bootstrap_metadata_reader_rechecks_real_owner_and_preserves_storage_failure::point-seam-1": { "boundary": { - "imports_sha256": "3df15877fc29acdf499a97880365631c96c2e7f57a793ff641394de3f38f64ec", - "kind": "seam", + "sha256": "24b60080b3c3b0d12aef4e9eac73ea151d2e448b9b22775ccada900371586f9d", "methods": [ "read_item" ], - "sha256": "24b60080b3c3b0d12aef4e9eac73ea151d2e448b9b22775ccada900371586f9d" + "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.", @@ -4312,12 +4312,12 @@ }, "functional_tests/test_orchestration_harness_scheduler.py::test_enrollment_restarts_after_a_process_dies_between_exact_output_tombstones::point-seam-1": { "boundary": { - "imports_sha256": "111e3d3983d999c74da5dd9a09e82a4a89742653b0e383a2acd4a185a5b8bfb5", - "kind": "seam", + "sha256": "c2da4885e95daff94fd5ca52bcf4956bdc2a38b24bf329f9c30a92c1c192606c", "methods": [ "execute_item_batch" ], - "sha256": "c2da4885e95daff94fd5ca52bcf4956bdc2a38b24bf329f9c30a92c1c192606c" + "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.", @@ -4327,12 +4327,12 @@ }, "functional_tests/test_orchestration_harness_scheduler.py::test_scheduler_preserves_real_headless_authority_uncertainty::point-seam-1": { "boundary": { - "imports_sha256": "111e3d3983d999c74da5dd9a09e82a4a89742653b0e383a2acd4a185a5b8bfb5", - "kind": "seam", + "sha256": "7b6ade42ce0aaa3cf1f1eae9bd68d413ac227e58c37b5ab02f3efecb0d06dd3d", "methods": [ "execute_item_batch" ], - "sha256": "7b6ade42ce0aaa3cf1f1eae9bd68d413ac227e58c37b5ab02f3efecb0d06dd3d" + "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.", @@ -4342,12 +4342,12 @@ }, "functional_tests/test_orchestration_harness_scheduler.py::test_uncertain_admitted_output_preserves_minimal_step_wait_without_a_task::point-seam-1": { "boundary": { - "imports_sha256": "111e3d3983d999c74da5dd9a09e82a4a89742653b0e383a2acd4a185a5b8bfb5", - "kind": "seam", + "sha256": "f9180769f49b8530a83e518f0ab96f6337154baefeb9daec3690d3c24b9523b3", "methods": [ "read_item" ], - "sha256": "f9180769f49b8530a83e518f0ab96f6337154baefeb9daec3690d3c24b9523b3" + "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.", @@ -4357,13 +4357,13 @@ }, "functional_tests/test_orchestration_image_references.py::test_candidate_computation_images_only_and_conversation_mismatch.Messages": { "boundary": { - "imports_sha256": "5998a5c08f046abfc0fb031949b9999dd9cb866b6d81c1ae06156620090c6c95", - "inherited_bases": [], - "kind": "class", + "sha256": "cdc61713da164f274594bbae0126dfff963e94cbf56ed47ba5e8ddb6b2d1c47a", "methods": [ "read_item" ], - "sha256": "cdc61713da164f274594bbae0126dfff963e94cbf56ed47ba5e8ddb6b2d1c47a" + "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.", @@ -4373,13 +4373,13 @@ }, "functional_tests/test_orchestration_image_references.py::test_candidates_use_enriched_metadata_scopes_and_fold_uploads.Messages": { "boundary": { - "imports_sha256": "5998a5c08f046abfc0fb031949b9999dd9cb866b6d81c1ae06156620090c6c95", - "inherited_bases": [], - "kind": "class", + "sha256": "31043981f80bc924c4aeb73eeaf9dca056b89ef69ffc49790e49c99d8ae34dad", "methods": [ "read_item" ], - "sha256": "31043981f80bc924c4aeb73eeaf9dca056b89ef69ffc49790e49c99d8ae34dad" + "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.", @@ -4389,12 +4389,12 @@ }, "functional_tests/test_orchestration_initial_claim_recovery.py::test_first_binding_cas_cannot_overwrite_a_concurrent_owner_or_stop::point-seam-1": { "boundary": { - "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66", - "kind": "seam", + "sha256": "84116eaf3b5aa2bdd97132f173ab497926594348646d276191e795cba55e827a", "methods": [ "replace_item" ], - "sha256": "84116eaf3b5aa2bdd97132f173ab497926594348646d276191e795cba55e827a" + "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.", @@ -4404,12 +4404,12 @@ }, "functional_tests/test_orchestration_initial_claim_recovery.py::test_first_binding_reconciles_lost_acknowledgement_and_freezes_exact_value::point-seam-1": { "boundary": { - "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66", - "kind": "seam", + "sha256": "9bafdca7440ca65fa0feccbbfc8af88413e0e403ef0a4d6ce190cff1a5d1b13a", "methods": [ "replace_item" ], - "sha256": "9bafdca7440ca65fa0feccbbfc8af88413e0e403ef0a4d6ce190cff1a5d1b13a" + "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.", @@ -4419,12 +4419,12 @@ }, "functional_tests/test_orchestration_initial_claim_recovery.py::test_initial_claim_persists_the_deadline_in_its_own_conditional_write::point-seam-1": { "boundary": { - "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66", - "kind": "seam", + "sha256": "c74dd8d5b3ef150497d7929095733a5250ab34b2e170f7f957749111a4f507e2", "methods": [ "replace_item" ], - "sha256": "c74dd8d5b3ef150497d7929095733a5250ab34b2e170f7f957749111a4f507e2" + "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.", @@ -4434,12 +4434,12 @@ }, "functional_tests/test_orchestration_initial_claim_recovery.py::test_lost_first_binding_acknowledgement_cannot_adopt_a_successor_claim::point-seam-1": { "boundary": { - "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66", - "kind": "seam", + "sha256": "07c559448bfca122d4a1e4399e851023283cea7cd9d9da7deb016fb40793cc81", "methods": [ "replace_item" ], - "sha256": "07c559448bfca122d4a1e4399e851023283cea7cd9d9da7deb016fb40793cc81" + "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.", @@ -4449,12 +4449,12 @@ }, "functional_tests/test_orchestration_initial_claim_recovery.py::test_lost_initial_claim_acknowledgement_recovers_without_restarting_the_budget::point-seam-1": { "boundary": { - "imports_sha256": "a6531345e7a5720d3479b099c60ba5c119710925b7832915e0640f97def7bc66", - "kind": "seam", + "sha256": "9bafdca7440ca65fa0feccbbfc8af88413e0e403ef0a4d6ce190cff1a5d1b13a", "methods": [ "replace_item" ], - "sha256": "9bafdca7440ca65fa0feccbbfc8af88413e0e403ef0a4d6ce190cff1a5d1b13a" + "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.", @@ -4464,12 +4464,12 @@ }, "functional_tests/test_orchestration_m365_actions.py::stub_modules::point-seam-1": { "boundary": { - "imports_sha256": "02d76403106789948241c5a6c6f142ee9bc0887b7ed4d286cf975d7c9113cc5e", - "kind": "seam", + "sha256": "d91c96019afb7a1e76b21cde0832c2f483ce7eb6dd28756fe94d95ed70a1cf68", "methods": [ "read_item" ], - "sha256": "d91c96019afb7a1e76b21cde0832c2f483ce7eb6dd28756fe94d95ed70a1cf68" + "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.", @@ -4479,12 +4479,12 @@ }, "functional_tests/test_orchestration_native_infrastructure_failures.py::test_actual_pending_poll_transport_failure_preserves_original_wait::point-seam-1": { "boundary": { - "imports_sha256": "fcd841881f01b91299486edba1f759e7d28d3979aabd56e936c30c5c4df4e26c", - "kind": "seam", + "sha256": "c6dd5b6be3fe538094b93795e72dcea4021a494b9df81033ae5ad99c3c2f8d78", "methods": [ "read_item" ], - "sha256": "c6dd5b6be3fe538094b93795e72dcea4021a494b9df81033ae5ad99c3c2f8d78" + "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.", @@ -4494,12 +4494,12 @@ }, "functional_tests/test_orchestration_native_infrastructure_failures.py::test_receipt_transport_uncertainty_is_not_absence_or_replacement::point-seam-1": { "boundary": { - "imports_sha256": "fcd841881f01b91299486edba1f759e7d28d3979aabd56e936c30c5c4df4e26c", - "kind": "seam", + "sha256": "c2cf233ec239ea1cd9f42d83f61d73baa5673f7d2c9707092ac206dfea248212", "methods": [ "read_item" ], - "sha256": "c2cf233ec239ea1cd9f42d83f61d73baa5673f7d2c9707092ac206dfea248212" + "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.", @@ -4509,12 +4509,12 @@ }, "functional_tests/test_orchestration_native_infrastructure_runtime.py::test_native_wait_survives_transport_failure_and_finishes_the_original_job::point-seam-1": { "boundary": { - "imports_sha256": "2ba59f1ce008c81c038c08335e14644bf487899a15382a488864b4171938dada", - "kind": "seam", + "sha256": "ed54aa2d1661fe7c11af4d39268c4d21f1f4fa708b884fdf6d9c71ae3318d787", "methods": [ "read_item" ], - "sha256": "ed54aa2d1661fe7c11af4d39268c4d21f1f4fa708b884fdf6d9c71ae3318d787" + "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.", @@ -4524,12 +4524,12 @@ }, "functional_tests/test_orchestration_native_infrastructure_runtime.py::test_scheduler_preserves_native_wait_and_recovers_after_actual_transport_outage::point-seam-1": { "boundary": { - "imports_sha256": "2ba59f1ce008c81c038c08335e14644bf487899a15382a488864b4171938dada", - "kind": "seam", + "sha256": "ed54aa2d1661fe7c11af4d39268c4d21f1f4fa708b884fdf6d9c71ae3318d787", "methods": [ "read_item" ], - "sha256": "ed54aa2d1661fe7c11af4d39268c4d21f1f4fa708b884fdf6d9c71ae3318d787" + "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.", @@ -4539,12 +4539,12 @@ }, "functional_tests/test_orchestration_operation_runtime.py::test_receipt_conflict_retries_storage_not_the_effect::point-seam-1": { "boundary": { - "imports_sha256": "cb6a0d336340e15616df2de2d26a66d50a6a7e8e533bf47d1d7f01b56bc35617", - "kind": "seam", + "sha256": "2045c0d623d225c9038b7b7a1f3d072990e5af0612e8bdbafc891fed8daf594a", "methods": [ "replace_item" ], - "sha256": "2045c0d623d225c9038b7b7a1f3d072990e5af0612e8bdbafc891fed8daf594a" + "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.", @@ -4554,12 +4554,12 @@ }, "functional_tests/test_orchestration_operation_runtime.py::test_saved_manual_draft_reference_crosses_bridge_before_receipt_failure::point-seam-1": { "boundary": { - "imports_sha256": "cb6a0d336340e15616df2de2d26a66d50a6a7e8e533bf47d1d7f01b56bc35617", - "kind": "seam", + "sha256": "168061aa4c2b89f2593f679bfe73fc14cd2ff782856e101ae5b41895bb6d6034", "methods": [ "replace_item" ], - "sha256": "168061aa4c2b89f2593f679bfe73fc14cd2ff782856e101ae5b41895bb6d6034" + "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.", @@ -4569,12 +4569,12 @@ }, "functional_tests/test_orchestration_output_checkpoint_storage.py::checkpoint_failure::point-seam-1": { "boundary": { - "imports_sha256": "6e33912aef2fd2ab18756059dc3bd8654dc866ed6cb7d231a4c781d28706a860", - "kind": "seam", + "sha256": "7de322490bb38b83502e4804974792304c9f1d82e28d6f82925d6dcaf27e5a31", "methods": [ "read_item" ], - "sha256": "7de322490bb38b83502e4804974792304c9f1d82e28d6f82925d6dcaf27e5a31" + "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.", @@ -4584,12 +4584,12 @@ }, "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_finish_cas_preserves_uncertain_acknowledgements::point-seam-1": { "boundary": { - "imports_sha256": "c919bfc5309975b0ea94d1b025d461c9afe52043e846fb9090149359ce182640", - "kind": "seam", + "sha256": "50bd5bf58805c947653357cc0b956361e0bc6a3c1e5cb951574cf933d86d803e", "methods": [ "execute_item_batch" ], - "sha256": "50bd5bf58805c947653357cc0b956361e0bc6a3c1e5cb951574cf933d86d803e" + "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.", @@ -4599,12 +4599,12 @@ }, "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_message_delete_is_conditional_and_can_reconcile::point-seam-1": { "boundary": { - "imports_sha256": "c919bfc5309975b0ea94d1b025d461c9afe52043e846fb9090149359ce182640", - "kind": "seam", + "sha256": "48439c38770703ba79607d27a896fbc92a1e430f3ffb1903ef9f222609b0a43a", "methods": [ "delete_item" ], - "sha256": "48439c38770703ba79607d27a896fbc92a1e430f3ffb1903ef9f222609b0a43a" + "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.", @@ -4614,12 +4614,12 @@ }, "functional_tests/test_orchestration_output_cleanup.py::test_cleanup_rechecks_owner_before_deleting_bytes::point-seam-1": { "boundary": { - "imports_sha256": "c919bfc5309975b0ea94d1b025d461c9afe52043e846fb9090149359ce182640", - "kind": "seam", + "sha256": "4d98b4007b003fa25cd56538e007251cee606b3f5cf01dea62115892b26390ae", "methods": [ "read_item" ], - "sha256": "4d98b4007b003fa25cd56538e007251cee606b3f5cf01dea62115892b26390ae" + "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.", @@ -4629,12 +4629,12 @@ }, "functional_tests/test_orchestration_output_deletion_pipeline.py::deletion_runtime::point-seam-1": { "boundary": { - "imports_sha256": "f4240f0cb3140aac06864bd5788d2f1a1362ad435ce12004f89b6e264830328c", - "kind": "seam", + "sha256": "5ef121933122b1f6864820d2d82cfa18fdde0b679efdb101c6aaf4f6f6395b8e", "methods": [ "delete_item" ], - "sha256": "5ef121933122b1f6864820d2d82cfa18fdde0b679efdb101c6aaf4f6f6395b8e" + "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.", @@ -4644,12 +4644,12 @@ }, "functional_tests/test_orchestration_output_deletion_pipeline.py::deletion_runtime::point-seam-2": { "boundary": { - "imports_sha256": "f4240f0cb3140aac06864bd5788d2f1a1362ad435ce12004f89b6e264830328c", - "kind": "seam", + "sha256": "80f6898824794ba8e48185285f394c860b5b66592a28b3b32777a3be76a9bf28", "methods": [ "delete_item" ], - "sha256": "80f6898824794ba8e48185285f394c860b5b66592a28b3b32777a3be76a9bf28" + "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.", @@ -4659,12 +4659,12 @@ }, "functional_tests/test_orchestration_output_deletion_pipeline.py::test_interrupted_deletion_enrollment_is_replayed_without_another_delete_request::point-seam-1": { "boundary": { - "imports_sha256": "f4240f0cb3140aac06864bd5788d2f1a1362ad435ce12004f89b6e264830328c", - "kind": "seam", + "sha256": "dcc6542c722e5c4cda3d2e8c7fe32c243c2ce3428319734f1b8fe07243e3c5c4", "methods": [ "replace_item" ], - "sha256": "dcc6542c722e5c4cda3d2e8c7fe32c243c2ce3428319734f1b8fe07243e3c5c4" + "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.", @@ -4674,12 +4674,12 @@ }, "functional_tests/test_orchestration_output_deletion_pipeline.py::test_interrupted_deletion_enrollment_is_replayed_without_another_delete_request::point-seam-2": { "boundary": { - "imports_sha256": "f4240f0cb3140aac06864bd5788d2f1a1362ad435ce12004f89b6e264830328c", - "kind": "seam", + "sha256": "91dbd5d9070c4e7a41848f7646bfe0c884cc98e2d21428adb6f8eed347464ca5", "methods": [ "execute_item_batch" ], - "sha256": "91dbd5d9070c4e7a41848f7646bfe0c884cc98e2d21428adb6f8eed347464ca5" + "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.", @@ -4689,12 +4689,12 @@ }, "functional_tests/test_orchestration_output_enrollment.py::test_competing_enrollment_workers_keep_one_durable_fence_per_output::point-seam-1": { "boundary": { - "imports_sha256": "4c2d210c3961eafe6e5c0ea4c9cf57660dec8e4b604583c6e3d77b2bb25b57d2", - "kind": "seam", + "sha256": "f65df07b3fbe134cd4474630b5d7a4e3812a8179d6a2409e7d7fd81599274692", "methods": [ "execute_item_batch" ], - "sha256": "f65df07b3fbe134cd4474630b5d7a4e3812a8179d6a2409e7d7fd81599274692" + "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.", @@ -4704,12 +4704,12 @@ }, "functional_tests/test_orchestration_output_enrollment.py::test_completion_marker_requires_persistence_and_reconciles_uncertain_ack::point-seam-1": { "boundary": { - "imports_sha256": "4c2d210c3961eafe6e5c0ea4c9cf57660dec8e4b604583c6e3d77b2bb25b57d2", - "kind": "seam", + "sha256": "633c6c12e69eb3357e7a4b3a048d7082ea7aec4ad18afd83c92482749e7298db", "methods": [ "execute_item_batch" ], - "sha256": "633c6c12e69eb3357e7a4b3a048d7082ea7aec4ad18afd83c92482749e7298db" + "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.", @@ -4719,16 +4719,16 @@ }, "functional_tests/test_orchestration_output_lifecycle.py::MessageContainer": { "boundary": { - "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "eb73f468c9aebb99d9d03f5126c9c353d09ebd7744620e09eda7282eac1a8946", "methods": [ "create_item", "delete_item" ], - "sha256": "eb73f468c9aebb99d9d03f5126c9c353d09ebd7744620e09eda7282eac1a8946" + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501" }, "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.", @@ -4738,13 +4738,13 @@ }, "functional_tests/test_orchestration_output_lifecycle.py::OutputContainer": { "boundary": { - "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501", + "sha256": "688c05e3947507e7bde6564bc6edcf32d53037915fe56cc7e1c0961ac30eddad", + "methods": [], + "kind": "class", "inherited_bases": [ "AtomicMemoryContainer" ], - "kind": "class", - "methods": [], - "sha256": "688c05e3947507e7bde6564bc6edcf32d53037915fe56cc7e1c0961ac30eddad" + "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501" }, "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.", @@ -4754,12 +4754,12 @@ }, "functional_tests/test_orchestration_output_lifecycle.py::test_commit_ack_and_recovery_read_loss_does_not_admit_another_attempt::point-seam-1": { "boundary": { - "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501", - "kind": "seam", + "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23", "methods": [ "execute_item_batch" ], - "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23" + "kind": "seam", + "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501" }, "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.", @@ -4769,12 +4769,12 @@ }, "functional_tests/test_orchestration_output_lifecycle.py::test_persistent_manifest_failures_are_bounded_and_manual_reuses_exact_bytes::point-seam-1": { "boundary": { - "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501", - "kind": "seam", + "sha256": "d3f0c12bf16613f094081342f326c6fdf14272b9837710f34ed10854f71b3577", "methods": [ "execute_item_batch" ], - "sha256": "d3f0c12bf16613f094081342f326c6fdf14272b9837710f34ed10854f71b3577" + "kind": "seam", + "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501" }, "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.", @@ -4784,12 +4784,12 @@ }, "functional_tests/test_orchestration_output_lifecycle.py::test_persistent_manifest_failures_are_bounded_and_manual_reuses_exact_bytes::point-seam-2": { "boundary": { - "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501", - "kind": "seam", + "sha256": "36d32c437e29a3a901deb26febdfc2c276ea4b9c26da4868e4b020f4e907dceb", "methods": [ "execute_item_batch" ], - "sha256": "36d32c437e29a3a901deb26febdfc2c276ea4b9c26da4868e4b020f4e907dceb" + "kind": "seam", + "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501" }, "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.", @@ -4799,12 +4799,12 @@ }, "functional_tests/test_orchestration_output_lifecycle.py::test_process_loss_reconciles_intent_without_duplicate_visibility::point-seam-1": { "boundary": { - "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501", - "kind": "seam", + "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23", "methods": [ "execute_item_batch" ], - "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23" + "kind": "seam", + "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501" }, "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.", @@ -4814,12 +4814,12 @@ }, "functional_tests/test_orchestration_output_lifecycle.py::test_stop_fences_every_publication_boundary_and_cleans_staging::point-seam-1": { "boundary": { - "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501", - "kind": "seam", + "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23", "methods": [ "execute_item_batch" ], - "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23" + "kind": "seam", + "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501" }, "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.", @@ -4829,12 +4829,12 @@ }, "functional_tests/test_orchestration_output_lifecycle.py::test_uncertain_acknowledgements_are_success_only_after_authoritative_read::point-seam-1": { "boundary": { - "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501", - "kind": "seam", + "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23", "methods": [ "execute_item_batch" ], - "sha256": "0d575b3cdc8f2e2dc5a71ea5041fc0b20e548b5b8456d8db0e8cd203450a6c23" + "kind": "seam", + "imports_sha256": "30ab65a23c32b6e0c81316a1f9e101a1494d7347519d22d8956426c06ce9a501" }, "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.", @@ -4844,12 +4844,12 @@ }, "functional_tests/test_orchestration_plan_revision_routes.py::PlanRevisionRouteTests.test_storage_failure_does_not_publish_or_discard_previous_plan::point-seam-1": { "boundary": { - "imports_sha256": "6cd43b3e3802014fe852a9b7daa5f618e7c16cdb9f261b70522b907e24f322c2", - "kind": "seam", + "sha256": "4a31e910f226c3863439964a9c7d5030fa7f28a34872d685886a2cf2a56c55bc", "methods": [ "execute_item_batch" ], - "sha256": "4a31e910f226c3863439964a9c7d5030fa7f28a34872d685886a2cf2a56c55bc" + "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.", @@ -4859,15 +4859,15 @@ }, "functional_tests/test_orchestration_publication_policy.py::embedded-APPROVAL_PROBE::Messages": { "boundary": { - "embedded_source_sha256": "16d59c3efe36b5412dc98e128f4905e6870092ec9fb508ea905dc6c58d20a42a", - "imports_sha256": "ab3b82810e6404ef9b0af93003923b75264ea4feaed33404df1f4b9064605e2e", - "inherited_bases": [], - "kind": "class", + "sha256": "9d00efeed0a0618fe94171eea2d94791baef086a596bfc99cbab09b8bd21e30a", "methods": [ "read_item", "upsert_item" ], - "sha256": "9d00efeed0a0618fe94171eea2d94791baef086a596bfc99cbab09b8bd21e30a" + "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.", @@ -4877,12 +4877,12 @@ }, "functional_tests/test_orchestration_render_waiting_runtime.py::test_initial_render_read_outage_preserves_admitted_wait_without_a_task::point-seam-1": { "boundary": { - "imports_sha256": "3902ae6d69888dc1a63c08e5c5ab1f528df85f2346835d51e5f44ca69d3ac705", - "kind": "seam", + "sha256": "2545afafdf8fc320b2bd91ef95fee52b62023ba5a8104790f5f7afad290d025c", "methods": [ "read_item" ], - "sha256": "2545afafdf8fc320b2bd91ef95fee52b62023ba5a8104790f5f7afad290d025c" + "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.", @@ -4892,12 +4892,12 @@ }, "functional_tests/test_orchestration_render_waiting_runtime.py::test_waiting_render_passes_full_checkpoint_to_public_resumer.observe::point-seam-1": { "boundary": { - "imports_sha256": "3902ae6d69888dc1a63c08e5c5ab1f528df85f2346835d51e5f44ca69d3ac705", - "kind": "seam", + "sha256": "1cd995bf368b9ca03222758ada9076511e92f2bbba05b7ec7476aeae9745d1d0", "methods": [ "read_item" ], - "sha256": "1cd995bf368b9ca03222758ada9076511e92f2bbba05b7ec7476aeae9745d1d0" + "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.", @@ -4907,12 +4907,12 @@ }, "functional_tests/test_orchestration_result_read_amplification.py::citation_graph::point-seam-1": { "boundary": { - "imports_sha256": "d755058e74ed4a46ef01cfff893c86b34ce8455d08478b2b290cbcc93d472a42", - "kind": "seam", + "sha256": "f91bc035edbce0048e8e2e1f530c67961c5281af6214fbbe9db977491c9f4113", "methods": [ "read_item" ], - "sha256": "f91bc035edbce0048e8e2e1f530c67961c5281af6214fbbe9db977491c9f4113" + "kind": "seam", + "imports_sha256": "d755058e74ed4a46ef01cfff893c86b34ce8455d08478b2b290cbcc93d472a42" }, "classification": "fault-injection", "contract": "The scoped read_item wrapper only counts calls and forwards all arguments and the unchanged SDK-default CosmosDict response to ResultContainer. The shared transactional fake retains ETags, partition routing, atomic batches and failure injection; scope tests revoke producer/conversation/claim authority without normalizing storage responses.", @@ -4922,13 +4922,13 @@ }, "functional_tests/test_orchestration_run_hydration_routes.py::_load_projections.UncheckedReplyMessages": { "boundary": { - "imports_sha256": "2252a57ddf5c0a49498e46d69eddcc553511b699d1bc4de9a7475491d9f95f6a", - "inherited_bases": [], - "kind": "class", + "sha256": "1c3733546915c19b2f6ba6c528c908399ee466e421be921f5b1e94b9044cab9a", "methods": [ "read_item" ], - "sha256": "1c3733546915c19b2f6ba6c528c908399ee466e421be921f5b1e94b9044cab9a" + "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.", @@ -4938,13 +4938,13 @@ }, "functional_tests/test_orchestration_shared_conversations.py::CollaborationMessages": { "boundary": { - "imports_sha256": "b91d9d156c9c55cc819a7499feb9bd7b78933e3b0c653c91e4ab08450852c641", + "sha256": "a7543cd2cf454403af1dcfe82af86528cf11b1b36c26633926f27620bb03170a", + "methods": [], + "kind": "class", "inherited_bases": [ "AtomicMemoryContainer" ], - "kind": "class", - "methods": [], - "sha256": "a7543cd2cf454403af1dcfe82af86528cf11b1b36c26633926f27620bb03170a" + "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.", @@ -4954,13 +4954,13 @@ }, "functional_tests/test_orchestration_source_access.py::AuthorityContainer": { "boundary": { - "imports_sha256": "0c76311787e2e1b7601506a0379d82dd0480a1421c462bd930a99bf67db1e01f", - "inherited_bases": [], - "kind": "class", + "sha256": "9513400f9f280bccfbd4cae5a830d35bc4c121299e56a647492b2ccdbc7c6a5d", "methods": [ "read_item" ], - "sha256": "9513400f9f280bccfbd4cae5a830d35bc4c121299e56a647492b2ccdbc7c6a5d" + "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.", @@ -4970,12 +4970,12 @@ }, "functional_tests/test_orchestration_waiting_continuation.py::test_cancellation_after_run_cas_finishes_without_dispatch::point-seam-1": { "boundary": { - "imports_sha256": "a2fd3cdfd332347c4d487968a08d847dd8eaec6cf550eedadcb80ea9ae018f3b", - "kind": "seam", + "sha256": "9a42fab524b7ba5ca9dc1e67aad2ab2b2400d49ce11ebeb8482a1115d121b4f8", "methods": [ "replace_item" ], - "sha256": "9a42fab524b7ba5ca9dc1e67aad2ab2b2400d49ce11ebeb8482a1115d121b4f8" + "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.", @@ -4985,12 +4985,12 @@ }, "functional_tests/test_orchestration_waiting_continuation.py::test_lost_claim_acknowledgment_reconciles_exact_submission::point-seam-1": { "boundary": { - "imports_sha256": "a2fd3cdfd332347c4d487968a08d847dd8eaec6cf550eedadcb80ea9ae018f3b", - "kind": "seam", + "sha256": "c89f8a8bb3c4d8cd89a3273b9f48db1a19acb14d5f6d9962d8126ab0fedd5348", "methods": [ "replace_item" ], - "sha256": "c89f8a8bb3c4d8cd89a3273b9f48db1a19acb14d5f6d9962d8126ab0fedd5348" + "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.", @@ -5000,12 +5000,12 @@ }, "functional_tests/test_orchestration_waiting_continuation.py::test_racing_claims_have_one_cas_winner::point-seam-1": { "boundary": { - "imports_sha256": "a2fd3cdfd332347c4d487968a08d847dd8eaec6cf550eedadcb80ea9ae018f3b", - "kind": "seam", + "sha256": "b3425dd4bfb5772fdc9683f1b663d3f6c7c4047dd1bb198b3b478f467257d88f", "methods": [ "replace_item" ], - "sha256": "b3425dd4bfb5772fdc9683f1b663d3f6c7c4047dd1bb198b3b478f467257d88f" + "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.", @@ -5015,16 +5015,16 @@ }, "functional_tests/test_orchestration_workflow_handoff_routes.py::Items": { "boundary": { - "imports_sha256": "cd5e1c6a950561ef08c2232d14bb0bec24b383f0c14eba676c2053e588055bb9", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "640ab0341ce6e42cee219747ca95c5b1e72009921c90b9bb03d37853e243414e", "methods": [ "delete_item", "read_item" ], - "sha256": "640ab0341ce6e42cee219747ca95c5b1e72009921c90b9bb03d37853e243414e" + "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.", @@ -5034,15 +5034,15 @@ }, "functional_tests/test_orchestration_workflow_proposal_routes.py::RunStore": { "boundary": { - "imports_sha256": "70a0a1f2bdbe595501af7d20a94fe7b3c0915c04aade509b350a33bd1f2bf840", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "fa5d98bd4a3615005d4b7d77346ab748a785887a56b5112a93f49c90389b1724", "methods": [ "replace_item" ], - "sha256": "fa5d98bd4a3615005d4b7d77346ab748a785887a56b5112a93f49c90389b1724" + "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.", @@ -5052,13 +5052,13 @@ }, "functional_tests/test_orchestration_workflow_proposal_routes.py::WorkflowStore": { "boundary": { - "imports_sha256": "70a0a1f2bdbe595501af7d20a94fe7b3c0915c04aade509b350a33bd1f2bf840", + "sha256": "9b4096e65d001610a4d9520e5d4c8e2e88a68c15b9d09c39cbb5091450a42e24", + "methods": [], + "kind": "class", "inherited_bases": [ "AtomicMemoryContainer" ], - "kind": "class", - "methods": [], - "sha256": "9b4096e65d001610a4d9520e5d4c8e2e88a68c15b9d09c39cbb5091450a42e24" + "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.", @@ -5068,15 +5068,15 @@ }, "functional_tests/test_orchestration_workflow_results_answer.py::_RecordingThoughtsContainer": { "boundary": { - "imports_sha256": "1bfe2691b537fcee1935841aa1a62569b08ac1c1db2b98929ff5a12d418ccf46", - "inherited_bases": [], - "kind": "class", + "sha256": "aa616b7bb0cbbdb4311000d9ea49ead6d5cc7479afa3059e66c6c8802f9e0388", "methods": [ "create_item", "patch_item", "upsert_item" ], - "sha256": "aa616b7bb0cbbdb4311000d9ea49ead6d5cc7479afa3059e66c6c8802f9e0388" + "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.", @@ -5086,13 +5086,13 @@ }, "functional_tests/test_orchestration_workflow_results_reads.py::test_point_reads_raise_retryable_failure_for_cosmos_errors_and_not_found_is_none.FailingContainer": { "boundary": { - "imports_sha256": "f0a32fc88f104db9c6e88d416eceaf3acc4e9c835722ccdbbbeb95f439de4bab", - "inherited_bases": [], - "kind": "class", + "sha256": "5fefba32c62ccd7944513e02e91ef795414e75e8a143b27b968107c569cb825f", "methods": [ "read_item" ], - "sha256": "5fefba32c62ccd7944513e02e91ef795414e75e8a143b27b968107c569cb825f" + "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.", @@ -5102,16 +5102,16 @@ }, "functional_tests/test_orchestration_workflow_run_adapter.py::Items": { "boundary": { - "imports_sha256": "aa0f596827dcaf54819f20b0b8e247d5ae787abe2877d66e8fa953ab555435bb", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "ce586a8e335f2db2f238012bdee116df8e3874236b64cd01628b8c211b15cc78", "methods": [ "delete_item", "read_item" ], - "sha256": "ce586a8e335f2db2f238012bdee116df8e3874236b64cd01628b8c211b15cc78" + "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.", @@ -5121,15 +5121,15 @@ }, "functional_tests/test_orchestration_workflow_run_link_routes.py::Reads": { "boundary": { - "imports_sha256": "2106e2afa21601aa4996556171a1bc1934cc3e7b25c41e993f337a7b542bc1f7", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "2f95e9bf5d4d894bada0f68a7fb2d28e5aad633129d64284222b6a29fef5c371", "methods": [ "read_item" ], - "sha256": "2f95e9bf5d4d894bada0f68a7fb2d28e5aad633129d64284222b6a29fef5c371" + "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.", @@ -5139,14 +5139,14 @@ }, "functional_tests/test_orchestration_workflow_run_wait_delivery.py::_Interleaved": { "boundary": { - "imports_sha256": "94f024450e0625b75fc6507342279ef0e026bb698cafec9b456e906bbc1573ae", - "inherited_bases": [], - "kind": "class", + "sha256": "f6a8f88597c03c7ef95d385e7ca6507bdab90b4cf623fea1184011544af54178", "methods": [ "read_item", "replace_item" ], - "sha256": "f6a8f88597c03c7ef95d385e7ca6507bdab90b4cf623fea1184011544af54178" + "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.", @@ -5156,14 +5156,14 @@ }, "functional_tests/test_personal_conversation_followup_authorization.py::FakeConversationContainer": { "boundary": { - "imports_sha256": "86c4cca6541f56f0af6abb3052056ec171f4e6958298fe0c88e9c2d596411b8b", - "inherited_bases": [], - "kind": "class", + "sha256": "fe8a9189d10707e1bda8a15039b23465d5dba637b7586b0539c675bbac56c8ab", "methods": [ "delete_item", "read_item" ], - "sha256": "fe8a9189d10707e1bda8a15039b23465d5dba637b7586b0539c675bbac56c8ab" + "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.", @@ -5173,13 +5173,13 @@ }, "functional_tests/test_personal_conversation_followup_authorization.py::FakeMessageContainer": { "boundary": { - "imports_sha256": "86c4cca6541f56f0af6abb3052056ec171f4e6958298fe0c88e9c2d596411b8b", - "inherited_bases": [], - "kind": "class", + "sha256": "728fb97860424e1741a6de7e87635d9d602888fbbd483e4c4190ea9c578074a3", "methods": [ "delete_item" ], - "sha256": "728fb97860424e1741a6de7e87635d9d602888fbbd483e4c4190ea9c578074a3" + "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.", @@ -5189,12 +5189,12 @@ }, "functional_tests/test_personal_identity_apis.py::test_raw_provider_error_is_not_returned_or_logged::point-seam-1": { "boundary": { - "imports_sha256": "3e9ee2a38089b2422b2148860f5db37740cbe7d3e603249892c2b9c588d37b26", - "kind": "seam", + "sha256": "79b03a2de3e722274e2f07283f8c3d45a94577d208f4801cc962621b2d2919c0", "methods": [ "replace_item" ], - "sha256": "79b03a2de3e722274e2f07283f8c3d45a94577d208f4801cc962621b2d2919c0" + "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.", @@ -5204,16 +5204,16 @@ }, "functional_tests/test_personal_prompt_helper_user_id_fix.py::FakeContainer": { "boundary": { - "imports_sha256": "a5f4609d1c132f694da212a0d8a657ea8e4b744b47ed2857fc1cbda519125212", - "inherited_bases": [], - "kind": "class", + "sha256": "52a078239fcfe8a9904636f05b901bb13481277099f79b368b154b2b168e1ae5", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "52a078239fcfe8a9904636f05b901bb13481277099f79b368b154b2b168e1ae5" + "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.", @@ -5223,13 +5223,13 @@ }, "functional_tests/test_profile_last_login_activity_logs.py::FakeActivityLogsContainer": { "boundary": { - "imports_sha256": "caaaa1f705eaef457ac92192aac6b0031c130d745a018a6c2d97f2276c6e6612", - "inherited_bases": [], - "kind": "class", + "sha256": "1b69f35277fc478565867357358375a4720f594e39d2787d84b63d86f925ada8", "methods": [ "create_item" ], - "sha256": "1b69f35277fc478565867357358375a4720f594e39d2787d84b63d86f925ada8" + "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.", @@ -5239,12 +5239,12 @@ }, "functional_tests/test_prompt_variable_knowledge_fill.py::load_service::point-seam-1": { "boundary": { - "imports_sha256": "65918600cb8603b3684cd3e82b78d6eae50f236230ac7897f44750cc2684d74d", - "kind": "seam", + "sha256": "0ef107a271d121b886c1b860b73636be4bddaa481d5d65f26c4c1d5f07dea181", "methods": [ "read_item" ], - "sha256": "0ef107a271d121b886c1b860b73636be4bddaa481d5d65f26c4c1d5f07dea181" + "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.", @@ -5254,9 +5254,7 @@ }, "functional_tests/test_public_document_management.py::MutablePublicContainer": { "boundary": { - "imports_sha256": "553880db3d361da0fefbd82a9923ebaf754aa8bfcaeddd65ef080842b654a066", - "inherited_bases": [], - "kind": "class", + "sha256": "c8ac20b992a807a6cba029e75aae0dda69413daa1199afd44210e7fb258c2ed2", "methods": [ "create_item", "delete_item", @@ -5264,7 +5262,9 @@ "replace_item", "upsert_item" ], - "sha256": "c8ac20b992a807a6cba029e75aae0dda69413daa1199afd44210e7fb258c2ed2" + "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.", @@ -5274,13 +5274,13 @@ }, "functional_tests/test_public_document_publication.py::PublicReceiptStore": { "boundary": { - "imports_sha256": "3be037889ed7649e935c9f7a794bf8fb9b7d212c5c383592d9ef08420f4f2394", - "inherited_bases": [], - "kind": "class", + "sha256": "55d9a5c0dfa0859f9ced09bc1709dbae8fdeab62641f93a7022d27e4a34152b4", "methods": [ "read_item" ], - "sha256": "55d9a5c0dfa0859f9ced09bc1709dbae8fdeab62641f93a7022d27e4a34152b4" + "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.", @@ -5290,13 +5290,13 @@ }, "functional_tests/test_public_document_read_apis.py::PublicReadOnlyContainer": { "boundary": { - "imports_sha256": "fd60f38240bd02ed5628fe66a52f28316bb13d47de3c27d21d561428c726aee5", - "inherited_bases": [], - "kind": "class", + "sha256": "9c2b253f5898a7f60c62cdff69197ecd431386fd5e4e046a1067264fd67b7f7e", "methods": [ "read_item" ], - "sha256": "9c2b253f5898a7f60c62cdff69197ecd431386fd5e4e046a1067264fd67b7f7e" + "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.", @@ -5306,12 +5306,12 @@ }, "functional_tests/test_public_membership_apis.py::environment::point-seam-1": { "boundary": { - "imports_sha256": "29d3b45c4b554eed9e01366d594a64f81bcdda326b1d06d96c622ede62450aa5", - "kind": "seam", + "sha256": "e53281544bb8ce30cd861c5ef001c94eadbb432b24fa6188265495d82b35312f", "methods": [ "create_item" ], - "sha256": "e53281544bb8ce30cd861c5ef001c94eadbb432b24fa6188265495d82b35312f" + "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.", @@ -5321,12 +5321,12 @@ }, "functional_tests/test_public_settings_apis.py::test_a_storage_failure_mid_write_is_a_data_free_500::point-seam-1": { "boundary": { - "imports_sha256": "1de2ac45b23d24591878948507b46cdea5c3951030d36ec0685d667604bec7d2", - "kind": "seam", + "sha256": "876e334126568b88417f7e3caaa2ef3c511e83f0e411571723803d88242d5898", "methods": [ "replace_item" ], - "sha256": "876e334126568b88417f7e3caaa2ef3c511e83f0e411571723803d88242d5898" + "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.", @@ -5336,12 +5336,12 @@ }, "functional_tests/test_public_settings_apis.py::test_an_unexpected_failure_is_a_logged_data_free_500::point-seam-1": { "boundary": { - "imports_sha256": "1de2ac45b23d24591878948507b46cdea5c3951030d36ec0685d667604bec7d2", - "kind": "seam", + "sha256": "6cfd8b50869ba0e5b9445eecbb29c0cb71a5f07ec8aaac8d5c5a0c9a2664c4ca", "methods": [ "read_item" ], - "sha256": "6cfd8b50869ba0e5b9445eecbb29c0cb71a5f07ec8aaac8d5c5a0c9a2664c4ca" + "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.", @@ -5351,12 +5351,12 @@ }, "functional_tests/test_public_workspace_document_write_guard.py::test_a_lost_response_is_recognised_rather_than_retried::point-seam-1": { "boundary": { - "imports_sha256": "1cbff1f986cafff0175ca013ec8a12b85c3cbefc60b18d63a3e111dd0e7f737b", - "kind": "seam", + "sha256": "86dfbc50644298b9523ceee89c26457feab5d8e6a8eadfeff6afd2637a9ccd11", "methods": [ "replace_item" ], - "sha256": "86dfbc50644298b9523ceee89c26457feab5d8e6a8eadfeff6afd2637a9ccd11" + "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.", @@ -5365,10 +5365,8 @@ ] }, "functional_tests/test_retention_policy_conversation_scope_coverage.py::FakeContainer": { - "boundary": { - "imports_sha256": "52fe388cbbefd532e268c2c92c5563e4b1d0e3951d48ff2ca05882104b01a0d9", - "inherited_bases": [], - "kind": "class", + "boundary": { + "sha256": "bf0960d429edc9fb43de204a2634f5681c41ecababa729380eba6fb0d9c5bfc0", "methods": [ "create_item", "delete_item", @@ -5376,7 +5374,9 @@ "replace_item", "upsert_item" ], - "sha256": "bf0960d429edc9fb43de204a2634f5681c41ecababa729380eba6fb0d9c5bfc0" + "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.", @@ -5386,14 +5386,14 @@ }, "functional_tests/test_rocksdb_plugin.py::FakeConfigCosmosContainer": { "boundary": { - "imports_sha256": "5f129d82d468ad9058c1f26a0314edc0fe3260d85ce747ba22111117ac5bde5e", - "inherited_bases": [], - "kind": "class", + "sha256": "5b8cac6bb9f86d6868431c2d5e6d65b2a89a9aa4b34fa3d68e3668504409c964", "methods": [ "read_item", "upsert_item" ], - "sha256": "5b8cac6bb9f86d6868431c2d5e6d65b2a89a9aa4b34fa3d68e3668504409c964" + "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.", @@ -5403,15 +5403,15 @@ }, "functional_tests/test_saved_analysis_cosmos_owner_contract.py::SavedAnalysisContainer": { "boundary": { - "imports_sha256": "9bbee5f0045897f4c8843c25d067d33adb555ffaefababd2d1a7f4e840bf80dd", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "9b434f1b9d93dcbd94604ed770893039894f975d61897dc1ca4c9bb9202dd77f", "methods": [ "patch_item" ], - "sha256": "9b434f1b9d93dcbd94604ed770893039894f975d61897dc1ca4c9bb9202dd77f" + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "9bbee5f0045897f4c8843c25d067d33adb555ffaefababd2d1a7f4e840bf80dd" }, "classification": "sdk-default", "contract": "Inherits the shared SDK-default transactional container. Nested metadata set patches preserve partition/id, return installed-SDK CosmosDict, require matching ETags and IfNotModified, retain read/write fault flags, and reject concurrent updates atomically.", @@ -5423,13 +5423,13 @@ }, "functional_tests/test_security_authorization_hardening.py::test_chat_route_enforces_conversation_ownership_and_scope_canonicalization.DummyConversationContainer": { "boundary": { - "imports_sha256": "e69f9b80206b5eba6ef5545422ac1ff905224dfd4c479f7d81c794a3b612bf31", - "inherited_bases": [], - "kind": "class", + "sha256": "ed7161c569341d19501e2f90382864b167f7d20c7d0895f95d87639dd04ae38c", "methods": [ "read_item" ], - "sha256": "ed7161c569341d19501e2f90382864b167f7d20c7d0895f95d87639dd04ae38c" + "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.", @@ -5439,14 +5439,14 @@ }, "functional_tests/test_simplechat_conversation_messages.py::FakeConversationsContainer": { "boundary": { - "imports_sha256": "7c7abfdc44f1e5d4e8ced6c2a78c25822c15dd90c776e97f44c01ffc52f9335d", - "inherited_bases": [], - "kind": "class", + "sha256": "4c1886ca8ab93f6433e126fe90ba050ace06d3f41d7d54fb1ccf09397465d12f", "methods": [ "read_item", "upsert_item" ], - "sha256": "4c1886ca8ab93f6433e126fe90ba050ace06d3f41d7d54fb1ccf09397465d12f" + "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.", @@ -5456,13 +5456,13 @@ }, "functional_tests/test_simplechat_conversation_messages.py::FakeMessagesContainer": { "boundary": { - "imports_sha256": "7c7abfdc44f1e5d4e8ced6c2a78c25822c15dd90c776e97f44c01ffc52f9335d", - "inherited_bases": [], - "kind": "class", + "sha256": "48763810c271c509cd3b372047040dfec14d562a4ea9676fcab3dc5a8a7850a4", "methods": [ "upsert_item" ], - "sha256": "48763810c271c509cd3b372047040dfec14d562a4ea9676fcab3dc5a8a7850a4" + "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.", @@ -5472,13 +5472,13 @@ }, "functional_tests/test_simplechat_operation_notifications.py::StubContainer": { "boundary": { - "imports_sha256": "85e9373e33822927deb4e79332016dec63ff56525a97538e9503dfda24fd6b74", - "inherited_bases": [], - "kind": "class", + "sha256": "3f12a4bb38227ddaf2ceb5fd9e3d005b65fbadcf59f29c09bfc9348892031187", "methods": [ "upsert_item" ], - "sha256": "3f12a4bb38227ddaf2ceb5fd9e3d005b65fbadcf59f29c09bfc9348892031187" + "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.", @@ -5488,15 +5488,15 @@ }, "functional_tests/test_sql_plugin_key_vault_secret_storage.py::FakeActionContainer": { "boundary": { - "imports_sha256": "7b48f862c9a51e1e2b67dbe757522ef29a09e3a1940ef28adebb5c38a022ee44", - "inherited_bases": [], - "kind": "class", + "sha256": "a7023cb419a1bad1c04354738f7d957e762da185e598dece6e8d2a650f209fb4", "methods": [ "delete_item", "read_item", "upsert_item" ], - "sha256": "a7023cb419a1bad1c04354738f7d957e762da185e598dece6e8d2a650f209fb4" + "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.", @@ -5506,12 +5506,12 @@ }, "functional_tests/test_support/document_analysis.py::document_analysis_runtime.screening_container::point-seam-1": { "boundary": { - "imports_sha256": "107eb9066f1ecc0d67f3bc429d23d5e1fbe30a8dbed8caa641bd1f420a2caa3e", - "kind": "seam", + "sha256": "6c491bf2b0a1a366f5d9b29141d67eb4ac1a99d569278a4747e321e104eed41a", "methods": [ "read_item" ], - "sha256": "6c491bf2b0a1a366f5d9b29141d67eb4ac1a99d569278a4747e321e104eed41a" + "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.", @@ -5521,16 +5521,16 @@ }, "functional_tests/test_support/document_search_sync.py::FakeSettingsContainer": { "boundary": { - "imports_sha256": "a11a1fe22dc9d9b6530e0fa8fadb4b4995fd26a55c0f70c55896a91305cb51c2", - "inherited_bases": [], - "kind": "class", + "sha256": "09784ea857a5e2d05380363394b17e75c74f7c56871e118ce73ce2fa83852697", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "09784ea857a5e2d05380363394b17e75c74f7c56871e118ce73ce2fa83852697" + "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.", @@ -5540,16 +5540,16 @@ }, "functional_tests/test_support/group_action_harness.py::ActionContainer": { "boundary": { - "imports_sha256": "6139690a557838086e5fcd4909bbf4904599322dd4ed2e255fe6fb939243e6cd", - "inherited_bases": [], - "kind": "class", + "sha256": "a38b12dd9c634020c7253ffc0b1bf08e368885b8fe1f18ac8fcf41eff2ee8c70", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "a38b12dd9c634020c7253ffc0b1bf08e368885b8fe1f18ac8fcf41eff2ee8c70" + "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.", @@ -5559,16 +5559,16 @@ }, "functional_tests/test_support/group_agent_harness.py::AgentContainer": { "boundary": { - "imports_sha256": "5579b532fb4db1915447c75f44514aa0cb516b3c9b63e84144cd2b599d9bdfc7", - "inherited_bases": [], - "kind": "class", + "sha256": "00375cd2029ca0c29dc60acaaf80ade356e85624fec50007b9963d83fa33ffdd", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "00375cd2029ca0c29dc60acaaf80ade356e85624fec50007b9963d83fa33ffdd" + "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.", @@ -5578,9 +5578,7 @@ }, "functional_tests/test_support/group_file_source_harness.py::FileSyncContainer": { "boundary": { - "imports_sha256": "1cb31b7628867b66fe38d4b5739121e4eb762fa9e8d110f4e49e9f233e3b0636", - "inherited_bases": [], - "kind": "class", + "sha256": "1b712442ab84149d257040451581d28cf040afa3828cfa28f8ed349e1fa3cfe9", "methods": [ "create_item", "delete_item", @@ -5588,7 +5586,9 @@ "replace_item", "upsert_item" ], - "sha256": "1b712442ab84149d257040451581d28cf040afa3828cfa28f8ed349e1fa3cfe9" + "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.", @@ -5598,16 +5598,16 @@ }, "functional_tests/test_support/group_identity_harness.py::IdentityContainer": { "boundary": { - "imports_sha256": "ec843fa58efcd082613b8b331353601aca43ab626fc3fda586680b3081173beb", - "inherited_bases": [], - "kind": "class", + "sha256": "27bb18cf6cd6ce629205a801b70834ef1c64ac349c71f03a4eef4e044f85203a", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "27bb18cf6cd6ce629205a801b70834ef1c64ac349c71f03a4eef4e044f85203a" + "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.", @@ -5617,16 +5617,16 @@ }, "functional_tests/test_support/group_prompt_harness.py::PromptContainer": { "boundary": { - "imports_sha256": "f7b7919fafd58674149fd5cac11355b60cd598df81d755bc31025458b773bf5f", - "inherited_bases": [], - "kind": "class", + "sha256": "5bfd774bf5bb4ab2a1da9b500db00ab2710588d508fd95ec421bd8b4520914f7", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "5bfd774bf5bb4ab2a1da9b500db00ab2710588d508fd95ec421bd8b4520914f7" + "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.", @@ -5636,9 +5636,7 @@ }, "functional_tests/test_support/m365.py::CosmosContainer": { "boundary": { - "imports_sha256": "68f620cee64e569b0c5387f8114f6ca20494c69b57fd037fe7ca9e73125cae25", - "inherited_bases": [], - "kind": "class", + "sha256": "7c38b7ac9265915041a96e492f029b8df646b6263d93d93aebc7c26d647ca0ee", "methods": [ "create_item", "delete_item", @@ -5647,7 +5645,9 @@ "replace_item", "upsert_item" ], - "sha256": "7c38b7ac9265915041a96e492f029b8df646b6263d93d93aebc7c26d647ca0ee" + "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.", @@ -5657,16 +5657,16 @@ }, "functional_tests/test_support/offline_bootstrap.py::OfflineContainer": { "boundary": { - "imports_sha256": "6d2189887ce14a62f90f179bf6ccd1c74400274409dc19714881e17a260b8451", - "inherited_bases": [], - "kind": "class", + "sha256": "583afdd52a3113205d25c56ef90bac3f8a28f03643191106d267fd9b2d81e269", "methods": [ "delete_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "583afdd52a3113205d25c56ef90bac3f8a28f03643191106d267fd9b2d81e269" + "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.", @@ -5676,15 +5676,15 @@ }, "functional_tests/test_support/orchestration_harness_execution.py::HarnessMessageContainer": { "boundary": { - "imports_sha256": "a3f4db724e6cc526bb10845792fc319592a481900bd6080b31189b83ed7e9216", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "fa2cd4a633f53b75d52b1b2ae93b8da7d47f16b6c868e825d1759bbd2dcaa9e2", "methods": [ "delete_item" ], - "sha256": "fa2cd4a633f53b75d52b1b2ae93b8da7d47f16b6c868e825d1759bbd2dcaa9e2" + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "a3f4db724e6cc526bb10845792fc319592a481900bd6080b31189b83ed7e9216" }, "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.", @@ -5694,13 +5694,13 @@ }, "functional_tests/test_support/orchestration_reference_world.py::RecordingContainer": { "boundary": { - "imports_sha256": "6b2895674946ec70db1100414855624648fd8113beef19ba93efc15f24238551", - "inherited_bases": [], - "kind": "class", + "sha256": "e158b4650dd9517a107ef8e35825a2ebede8d6b118613f68dda48af706451530", "methods": [ "read_item" ], - "sha256": "e158b4650dd9517a107ef8e35825a2ebede8d6b118613f68dda48af706451530" + "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.", @@ -5710,15 +5710,15 @@ }, "functional_tests/test_support/orchestration_results.py::ResultContainer": { "boundary": { - "imports_sha256": "78f1d5e92309b5d6f03f958c10cbcef533bdd7a23fe0f3bde5b2bd2e701f3fce", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "e38fc732045dd1576c276eb13b62dcb03eca3cffd881b94d86d8d3f37992ea3e", "methods": [ "delete_item" ], - "sha256": "e38fc732045dd1576c276eb13b62dcb03eca3cffd881b94d86d8d3f37992ea3e" + "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.", @@ -5728,11 +5728,11 @@ }, "functional_tests/test_support/orchestration_results.py::ResultFixture": { "boundary": { - "imports_sha256": "78f1d5e92309b5d6f03f958c10cbcef533bdd7a23fe0f3bde5b2bd2e701f3fce", - "inherited_bases": [], - "kind": "domain", + "sha256": "63198c89a75bd78efc1200831688d5057a918da420ebd6dfb81132cf085b45e3", "methods": [], - "sha256": "63198c89a75bd78efc1200831688d5057a918da420ebd6dfb81132cf085b45e3" + "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.", @@ -5742,9 +5742,7 @@ }, "functional_tests/test_support/orchestration_revisions.py::AtomicMemoryContainer": { "boundary": { - "imports_sha256": "a5271c5eba30cd26978bd66b16ae2c89bba4de3c753911b4d9298133304773cc", - "inherited_bases": [], - "kind": "class", + "sha256": "45972adfa5bac7f069ae2a00047424aa5a208a8d14b6cc61afd1ab560397f5ee", "methods": [ "create_item", "delete_item", @@ -5753,7 +5751,9 @@ "replace_item", "upsert_item" ], - "sha256": "45972adfa5bac7f069ae2a00047424aa5a208a8d14b6cc61afd1ab560397f5ee" + "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.", @@ -5763,9 +5763,7 @@ }, "functional_tests/test_support/public_file_source_harness.py::FileSyncContainer": { "boundary": { - "imports_sha256": "f8de6c5a7b4aaf5b781b06a1e932326f107202a0da4dd67468f73d56c3a67613", - "inherited_bases": [], - "kind": "class", + "sha256": "1b712442ab84149d257040451581d28cf040afa3828cfa28f8ed349e1fa3cfe9", "methods": [ "create_item", "delete_item", @@ -5773,7 +5771,9 @@ "replace_item", "upsert_item" ], - "sha256": "1b712442ab84149d257040451581d28cf040afa3828cfa28f8ed349e1fa3cfe9" + "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.", @@ -5783,13 +5783,13 @@ }, "functional_tests/test_support/public_file_source_harness.py::WorkspaceContainer": { "boundary": { - "imports_sha256": "f8de6c5a7b4aaf5b781b06a1e932326f107202a0da4dd67468f73d56c3a67613", - "inherited_bases": [], - "kind": "class", + "sha256": "f49b606b75592181a2f901ecfce862d1047aa9b648d5cc714ee71b698b848429", "methods": [ "read_item" ], - "sha256": "f49b606b75592181a2f901ecfce862d1047aa9b648d5cc714ee71b698b848429" + "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.", @@ -5799,16 +5799,16 @@ }, "functional_tests/test_support/public_identity_harness.py::IdentityContainer": { "boundary": { - "imports_sha256": "f8de6c5a7b4aaf5b781b06a1e932326f107202a0da4dd67468f73d56c3a67613", - "inherited_bases": [], - "kind": "class", + "sha256": "3d3c6048c1720e28a6cdae906ffe9e1cc77fd4e726e40d1265de1491389a784b", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "3d3c6048c1720e28a6cdae906ffe9e1cc77fd4e726e40d1265de1491389a784b" + "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.", @@ -5818,13 +5818,13 @@ }, "functional_tests/test_support/public_identity_harness.py::WorkspaceContainer": { "boundary": { - "imports_sha256": "f8de6c5a7b4aaf5b781b06a1e932326f107202a0da4dd67468f73d56c3a67613", - "inherited_bases": [], - "kind": "class", + "sha256": "651c07a289cca91f8a16a9c54a931c1d1b8bc9fe8a71b3743f91247a31ae9b01", "methods": [ "read_item" ], - "sha256": "651c07a289cca91f8a16a9c54a931c1d1b8bc9fe8a71b3743f91247a31ae9b01" + "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.", @@ -5834,16 +5834,16 @@ }, "functional_tests/test_support/public_prompt_harness.py::PromptContainer": { "boundary": { - "imports_sha256": "c6040f96ae2999e496048f391440367724e765c87af77bf33257e75312a6da84", - "inherited_bases": [], - "kind": "class", + "sha256": "5bfd774bf5bb4ab2a1da9b500db00ab2710588d508fd95ec421bd8b4520914f7", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "5bfd774bf5bb4ab2a1da9b500db00ab2710588d508fd95ec421bd8b4520914f7" + "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.", @@ -5853,13 +5853,13 @@ }, "functional_tests/test_support/public_prompt_harness.py::WorkspaceContainer": { "boundary": { - "imports_sha256": "c6040f96ae2999e496048f391440367724e765c87af77bf33257e75312a6da84", - "inherited_bases": [], - "kind": "class", + "sha256": "651c07a289cca91f8a16a9c54a931c1d1b8bc9fe8a71b3743f91247a31ae9b01", "methods": [ "read_item" ], - "sha256": "651c07a289cca91f8a16a9c54a931c1d1b8bc9fe8a71b3743f91247a31ae9b01" + "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.", @@ -5869,15 +5869,15 @@ }, "functional_tests/test_support/safety_review_harness.py::FakeApprovalsContainer": { "boundary": { - "imports_sha256": "7529235ac187fcb5cabb2aad66ee14a2f94cd7a69d682b8a569226095092e73a", - "inherited_bases": [], - "kind": "class", + "sha256": "144428ee093881f8396a5807dc3f3c523e0b07f9f6e2c8344e23f0559ef0cff1", "methods": [ "read_item", "replace_item", "upsert_item" ], - "sha256": "144428ee093881f8396a5807dc3f3c523e0b07f9f6e2c8344e23f0559ef0cff1" + "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.", @@ -5887,16 +5887,16 @@ }, "functional_tests/test_support/safety_review_harness.py::FakeSafetyContainer": { "boundary": { - "imports_sha256": "7529235ac187fcb5cabb2aad66ee14a2f94cd7a69d682b8a569226095092e73a", - "inherited_bases": [], - "kind": "class", + "sha256": "cb67a49db3261b30123e591318a0706316b595831592378ad3b42d0d69ac6d34", "methods": [ "delete_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "cb67a49db3261b30123e591318a0706316b595831592378ad3b42d0d69ac6d34" + "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.", @@ -5906,9 +5906,7 @@ }, "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeContainer": { "boundary": { - "imports_sha256": "ef38d1defac54b7f18c32d421b4d29994b5d854786f6ad0641ec34f3b2d96eff", - "inherited_bases": [], - "kind": "class", + "sha256": "8454999fc4a0ea33fb3932eab0e16d1649d7a31220b8e0c3191cfe31409bc6bc", "methods": [ "create_item", "delete_item", @@ -5916,7 +5914,9 @@ "replace_item", "upsert_item" ], - "sha256": "8454999fc4a0ea33fb3932eab0e16d1649d7a31220b8e0c3191cfe31409bc6bc" + "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.", @@ -5926,11 +5926,11 @@ }, "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeResultReader": { "boundary": { - "imports_sha256": "ef38d1defac54b7f18c32d421b4d29994b5d854786f6ad0641ec34f3b2d96eff", - "inherited_bases": [], - "kind": "domain", + "sha256": "f797ef7c33618013ece0d4fc09c3826ddcedd5e340b612c8a44c7ec451f7ec8e", "methods": [], - "sha256": "f797ef7c33618013ece0d4fc09c3826ddcedd5e340b612c8a44c7ec451f7ec8e" + "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.", @@ -5940,11 +5940,11 @@ }, "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeRuntime": { "boundary": { - "imports_sha256": "ef38d1defac54b7f18c32d421b4d29994b5d854786f6ad0641ec34f3b2d96eff", - "inherited_bases": [], - "kind": "domain", + "sha256": "ec5ab6b0c85b83361271b913dab9f08c6cb13f083783f63af558fd0acb20e982", "methods": [], - "sha256": "ec5ab6b0c85b83361271b913dab9f08c6cb13f083783f63af558fd0acb20e982" + "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.", @@ -5954,11 +5954,11 @@ }, "functional_tests/test_support/workflow_chat_delivery_fakes.py::FakeRuntime.factory._Store": { "boundary": { - "imports_sha256": "ef38d1defac54b7f18c32d421b4d29994b5d854786f6ad0641ec34f3b2d96eff", - "inherited_bases": [], - "kind": "domain", + "sha256": "dd59a6bd3a96e8435a52cd9357d9dcc8212528b04c43d1f0d7662a8538052683", "methods": [], - "sha256": "dd59a6bd3a96e8435a52cd9357d9dcc8212528b04c43d1f0d7662a8538052683" + "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.", @@ -5968,13 +5968,13 @@ }, "functional_tests/test_support/workflow_result_chat.py::FakeContainer": { "boundary": { - "imports_sha256": "3858d9cce55c112e0d1f610c8e73b814066fcdc2107140e3c11b8d795532cfd3", - "inherited_bases": [], - "kind": "class", + "sha256": "455a123da3ff64f7b33030fa8e83df420360bdcbea33516897eadee353f4edf7", "methods": [ "read_item" ], - "sha256": "455a123da3ff64f7b33030fa8e83df420360bdcbea33516897eadee353f4edf7" + "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.", @@ -5984,16 +5984,16 @@ }, "functional_tests/test_support/workflow_result_offline_app.py::Container": { "boundary": { - "imports_sha256": "d4cad5f55715280599e379353d012730a382650d793076829c17f33ca762d89e", - "inherited_bases": [ - "OfflineContainer" - ], - "kind": "class", + "sha256": "ebf204f6808ba3aa25766d2466c4518feec3a1b7eb28cbf22e4829baeb724ed6", "methods": [ "read_item", "replace_item" ], - "sha256": "ebf204f6808ba3aa25766d2466c4518feec3a1b7eb28cbf22e4829baeb724ed6" + "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.", @@ -6003,14 +6003,14 @@ }, "functional_tests/test_tableau_action_plugin.py::FakeConfigCosmosContainer": { "boundary": { - "imports_sha256": "bf685435a91b4b88b84e9dcb47ef4f0860c6faa5f09ad75b9050b3617f47ced8", - "inherited_bases": [], - "kind": "class", + "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558", "methods": [ "read_item", "upsert_item" ], - "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558" + "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.", @@ -6020,13 +6020,13 @@ }, "functional_tests/test_tabular_queue_run_output_schema_end_to_end.py::_FakeCosmosContainer": { "boundary": { - "imports_sha256": "f76480f3218706bf5a95c4b26e5cf730bd2af6f0024cd3f2e5e892b48b6711ec", - "inherited_bases": [], - "kind": "class", + "sha256": "a6fca6a663cd503746df9209bbe986637c9b339f8b0de77355116b77080d750e", "methods": [ "create_item" ], - "sha256": "a6fca6a663cd503746df9209bbe986637c9b339f8b0de77355116b77080d750e" + "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.", @@ -6036,61 +6036,61 @@ }, "functional_tests/test_tabular_row_orchestration_scale.py::_load_authorization_helper.ConversationContainer": { "boundary": { - "imports_sha256": "1b3486a678ce86b217c2d0984b5f1c5282175a7e46794a311f51e5d9ddd9abaf", - "inherited_bases": [], - "kind": "class", + "sha256": "354ad9c7632aaca0de50389f2097fc278368c12c68628e2cef378b6744363159", "methods": [ "read_item" ], - "sha256": "9e3f33f299a94a67c8d37b54e0b6a5d7832bc7dccb3a11a1f9e500d63b9a08f6" + "kind": "class", + "inherited_bases": [], + "imports_sha256": "d0ecc00fea7e0f993ed5b80616e34bd0e626d4b80854f46622aaddadef386fca" }, "classification": "sdk-default", - "contract": "Authorization fixture point reads return the installed SDK CosmosDict by default, preserving the existing owner fields and conversation partition assertion.", + "contract": "Installed-SDK CosmosDict point reads preserve ownership and ETags, isolate returned mutations, and reject a wrong partition with SDK 404.", "tests": [ - "functional_tests/test_export_evidence_cosmos_contract.py::test_changed_tabular_test_containers_now_return_sdk_points_by_default" + "functional_tests/test_tabular_row_orchestration_scale.py::test_sdk_default_authorization_conversation_points_preserve_owner_etag_and_partition" ] }, "functional_tests/test_tabular_row_orchestration_scale.py::_load_idempotent_artifact_helper.ConversationContainer": { "boundary": { - "imports_sha256": "1b3486a678ce86b217c2d0984b5f1c5282175a7e46794a311f51e5d9ddd9abaf", - "inherited_bases": [], - "kind": "class", + "sha256": "d6e6085c092ae42161772dedadf34e69ef73eaed809d917beed0b264838949ee", "methods": [ "read_item" ], - "sha256": "e7602052cff10d7c40e3d936520a8aef3e9f7d58082bb786bbfab8d7191a3315" + "kind": "class", + "inherited_bases": [], + "imports_sha256": "d0ecc00fea7e0f993ed5b80616e34bd0e626d4b80854f46622aaddadef386fca" }, "classification": "sdk-default", - "contract": "Artifact-upload fixture conversation reads return the installed SDK CosmosDict by default without changing the owner identity supplied to the real upload helper.", + "contract": "Installed-SDK CosmosDict conversation reads preserve ownership and ETags, isolate returned mutations, and reject wrong partitions with SDK 404.", "tests": [ - "functional_tests/test_export_evidence_cosmos_contract.py::test_changed_tabular_test_containers_now_return_sdk_points_by_default" + "functional_tests/test_tabular_row_orchestration_scale.py::test_sdk_default_artifact_conversation_points_preserve_owner_etag_and_partition" ] }, "functional_tests/test_tabular_row_orchestration_scale.py::_load_idempotent_artifact_helper.MessageContainer": { "boundary": { - "imports_sha256": "1b3486a678ce86b217c2d0984b5f1c5282175a7e46794a311f51e5d9ddd9abaf", - "inherited_bases": [], - "kind": "class", + "sha256": "dc02ff09ef6ba766d597d847dcd0d8f1f3072b897324821d574b21c526385678", "methods": [ "read_item", "upsert_item" ], - "sha256": "38864b1c2e1ceb96592fdcb4071ff480ed6d2f5030f8c1284393f885de82aa83" + "kind": "class", + "inherited_bases": [], + "imports_sha256": "d0ecc00fea7e0f993ed5b80616e34bd0e626d4b80854f46622aaddadef386fca" }, "classification": "sdk-default", - "contract": "Artifact fixture read/upsert results default to the installed SDK CosmosDict. Stored JSON fields, supplied ETags, not-found behavior and upsert counting remain unchanged.", + "contract": "Installed-SDK CosmosDict message reads and upserts preserve versioned ETags and partition routing; stale or missing conditional writes reject atomically with SDK 412.", "tests": [ - "functional_tests/test_export_evidence_cosmos_contract.py::test_changed_tabular_test_containers_now_return_sdk_points_by_default" + "functional_tests/test_tabular_row_orchestration_scale.py::test_sdk_default_artifact_message_points_preserve_versions_partitions_and_atomic_failures" ] }, "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": { - "imports_sha256": "30c41490fef19beb45c043ba7cfc836d1a1316d111c12455e66a929cd99f40e4", - "kind": "seam", + "sha256": "213031f1dc7d7bc9429878c86bd0f96a0354073136644a91f854986c2833600d", "methods": [ "read_item" ], - "sha256": "213031f1dc7d7bc9429878c86bd0f96a0354073136644a91f854986c2833600d" + "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.", @@ -6100,12 +6100,12 @@ }, "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": { - "imports_sha256": "30c41490fef19beb45c043ba7cfc836d1a1316d111c12455e66a929cd99f40e4", - "kind": "seam", + "sha256": "213031f1dc7d7bc9429878c86bd0f96a0354073136644a91f854986c2833600d", "methods": [ "read_item" ], - "sha256": "213031f1dc7d7bc9429878c86bd0f96a0354073136644a91f854986c2833600d" + "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.", @@ -6115,13 +6115,13 @@ }, "functional_tests/test_user_profile_idor_authorization.py::FakeCollaborationStateContainer": { "boundary": { - "imports_sha256": "52a1c67bbbf2112e7bd8c132bc6fc02842692c4c91a3eea489b6c9445ebab05f", - "inherited_bases": [], - "kind": "class", + "sha256": "a329a9283868db39d91646deadaed6d1d82bbd45aa3fa92fdc7f0605c3734f1e", "methods": [ "read_item" ], - "sha256": "a329a9283868db39d91646deadaed6d1d82bbd45aa3fa92fdc7f0605c3734f1e" + "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.", @@ -6131,13 +6131,13 @@ }, "functional_tests/test_user_profile_idor_authorization.py::FakeUserSettingsContainer": { "boundary": { - "imports_sha256": "52a1c67bbbf2112e7bd8c132bc6fc02842692c4c91a3eea489b6c9445ebab05f", - "inherited_bases": [], - "kind": "class", + "sha256": "aaf17c1fad63a1cbc086c03af5e1f4885976385db5f5d36428c41a1340ac91a2", "methods": [ "read_item" ], - "sha256": "aaf17c1fad63a1cbc086c03af5e1f4885976385db5f5d36428c41a1340ac91a2" + "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.", @@ -6147,16 +6147,16 @@ }, "functional_tests/test_v2_admin_global_editor_backend.py::FakeContainer": { "boundary": { - "imports_sha256": "ebfd6076aac71e8b0a86469a0bc0360ab0bb0ce472e6011270b27e04ab0fda80", - "inherited_bases": [], - "kind": "class", + "sha256": "8a18e563f259b24982d9d376f5b1b62b3f3991c680b00336df6f219197bb45f7", "methods": [ "create_item", "delete_item", "read_item", "replace_item" ], - "sha256": "8a18e563f259b24982d9d376f5b1b62b3f3991c680b00336df6f219197bb45f7" + "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.", @@ -6166,14 +6166,14 @@ }, "functional_tests/test_v2_collaboration_visual_style_fix.py::_FakeMessageContainer": { "boundary": { - "imports_sha256": "8b4ca01eb97401ef4a0808851b58fc24c56bc5ece1d729320bae3b71cd04883c", - "inherited_bases": [], - "kind": "class", + "sha256": "7ed6f533c1b4f7a0666448c9088cb25a5398ebf7faca1c1fafbb27b8fa7152cd", "methods": [ "read_item", "upsert_item" ], - "sha256": "7ed6f533c1b4f7a0666448c9088cb25a5398ebf7faca1c1fafbb27b8fa7152cd" + "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.", @@ -6183,13 +6183,13 @@ }, "functional_tests/test_v2_collaboration_visual_style_fix.py::_get_conversation_kind._PersonalContainer": { "boundary": { - "imports_sha256": "8b4ca01eb97401ef4a0808851b58fc24c56bc5ece1d729320bae3b71cd04883c", - "inherited_bases": [], - "kind": "class", + "sha256": "9f8bcecc2673289fa2f0699c415871f97d0f0355c3cbc285ac3d1e7a5aef24d9", "methods": [ "read_item" ], - "sha256": "9f8bcecc2673289fa2f0699c415871f97d0f0355c3cbc285ac3d1e7a5aef24d9" + "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.", @@ -6199,13 +6199,13 @@ }, "functional_tests/test_v2_control_center_action.py::ReadOnlyContainer": { "boundary": { - "imports_sha256": "b7a9494603b7a946ce16f34b3c95e734abb3bbd73b5c3e1771e80a0625f53157", - "inherited_bases": [], - "kind": "class", + "sha256": "7d0d527d78b9c9473ad3e677c08da38f3bb3dcff18e57eccf0e8af1363647005", "methods": [ "read_item" ], - "sha256": "7d0d527d78b9c9473ad3e677c08da38f3bb3dcff18e57eccf0e8af1363647005" + "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.", @@ -6215,13 +6215,13 @@ }, "functional_tests/test_v2_control_center_dashboard.py::GuardedContainer": { "boundary": { - "imports_sha256": "c29f8cc17c8423139ab1a21ce838113b0bbef1f4e88ac4bc45171c5c08018945", - "inherited_bases": [], - "kind": "class", + "sha256": "f9b8382d33afbfc0da09c13903b8d594d515045bb23350f6dbb496b6a9698413", "methods": [ "read_item" ], - "sha256": "f9b8382d33afbfc0da09c13903b8d594d515045bb23350f6dbb496b6a9698413" + "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.", @@ -6231,13 +6231,13 @@ }, "functional_tests/test_v2_control_center_groups.py::InventoryGroups": { "boundary": { - "imports_sha256": "729f134ef8f677932a9806e061fcebdaeb726749bebc785ff85d9498fa32142b", - "inherited_bases": [], - "kind": "class", + "sha256": "12d5e47dfce596cb4efb500a5592f87cdfcaaa978e3bab3ce03325adcdb88c5d", "methods": [ "read_item" ], - "sha256": "12d5e47dfce596cb4efb500a5592f87cdfcaaa978e3bab3ce03325adcdb88c5d" + "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.", @@ -6247,13 +6247,13 @@ }, "functional_tests/test_v2_control_center_public_workspaces.py::Activity": { "boundary": { - "imports_sha256": "b0be7393816a11d5bcaf8c60aa9bc0f8635618fcc8098c158bf8e21099442044", - "inherited_bases": [], - "kind": "class", + "sha256": "f08ef79d3cc5d5947ee69598873482d9b0eef0c373d88d226e840751144bd79f", "methods": [ "create_item" ], - "sha256": "f08ef79d3cc5d5947ee69598873482d9b0eef0c373d88d226e840751144bd79f" + "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.", @@ -6263,13 +6263,13 @@ }, "functional_tests/test_v2_control_center_public_workspaces.py::WorkspaceQueries": { "boundary": { - "imports_sha256": "b0be7393816a11d5bcaf8c60aa9bc0f8635618fcc8098c158bf8e21099442044", - "inherited_bases": [], - "kind": "class", + "sha256": "71f20d3205f2498135ec002acae340041e3ac29d9cfd5605ece54ca6c1d8d4fe", "methods": [ "read_item" ], - "sha256": "71f20d3205f2498135ec002acae340041e3ac29d9cfd5605ece54ca6c1d8d4fe" + "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.", @@ -6301,14 +6301,14 @@ }, "functional_tests/test_v2_prompt_attachment_persistence.py::MemoryContainer": { "boundary": { - "imports_sha256": "88a9b01c59258447569e3e3bf72a05a3a1ec0664a7e52d50e13702c63470a748", - "inherited_bases": [], - "kind": "class", + "sha256": "f93430525a16921d70dcf172593288b5d2a4fc29619d52609706ea0785af8559", "methods": [ "read_item", "upsert_item" ], - "sha256": "f93430525a16921d70dcf172593288b5d2a4fc29619d52609706ea0785af8559" + "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.", @@ -6318,13 +6318,13 @@ }, "functional_tests/test_v2_public_source_owner_sdk.py::OwnerContainer": { "boundary": { - "imports_sha256": "5705eccae8c0947e5b7f6bf19038cd49964fefd4e7d81124cb6230aafb5933a7", + "sha256": "598d5b9ddc97381fc579b2b5fc4549463adb80296b08d93cb4d07304f0a2eea1", + "methods": [], + "kind": "class", "inherited_bases": [ "AtomicMemoryContainer" ], - "kind": "class", - "methods": [], - "sha256": "598d5b9ddc97381fc579b2b5fc4549463adb80296b08d93cb4d07304f0a2eea1" + "imports_sha256": "5705eccae8c0947e5b7f6bf19038cd49964fefd4e7d81124cb6230aafb5933a7" }, "classification": "sdk-default", "contract": "SDK-default points, conditional ETags, partition routing and failure semantics are inherited unchanged from AtomicMemoryContainer. Only bounded query predicates are added; query rows remain plain dictionaries. Representative real-owner regressions assert SDK point/write types and plain query shapes.", @@ -6334,14 +6334,14 @@ }, "functional_tests/test_workflow_alert_acknowledgment.py::FakeContainer": { "boundary": { - "imports_sha256": "cbb43631c791f9a30f45caab035849574ceb86918565f23511dbe8204c0e02ad", - "inherited_bases": [], - "kind": "class", + "sha256": "b499cbc2c7af40718a1dca29632e5fbb8a1d5c90c0fbd72a2d6b4332c8565889", "methods": [ "replace_item", "upsert_item" ], - "sha256": "b499cbc2c7af40718a1dca29632e5fbb8a1d5c90c0fbd72a2d6b4332c8565889" + "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.", @@ -6351,13 +6351,13 @@ }, "functional_tests/test_workflow_assist_dry_run_parity.py::test_a_store_outage_is_a_503_never_a_missing_workflow.Failing": { "boundary": { - "imports_sha256": "8d858efc9fd7424f21698e3bb47cb5be807002316da7c28bd047e02fffd966be", - "inherited_bases": [], - "kind": "class", + "sha256": "5ec6e8adae198f392a26146e8bafa4f05211c5f2e5d91b5d4b4a90bc3765ecca", "methods": [ "read_item" ], - "sha256": "5ec6e8adae198f392a26146e8bafa4f05211c5f2e5d91b5d4b4a90bc3765ecca" + "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.", @@ -6367,15 +6367,15 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::LimitContainer": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "inherited_bases": [], - "kind": "class", + "sha256": "89d9f0fe5fb8f133ed3d402ffbfd702708713b879dc803ee9ade6cc58401759c", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "89d9f0fe5fb8f133ed3d402ffbfd702708713b879dc803ee9ade6cc58401759c" + "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.", @@ -6385,13 +6385,13 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::ReadOnlyContainer": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "inherited_bases": [], - "kind": "class", + "sha256": "300b20b8d364afb276133ddeb0eba0180b98871ece6186b646aabdf098891849", "methods": [ "read_item" ], - "sha256": "300b20b8d364afb276133ddeb0eba0180b98871ece6186b646aabdf098891849" + "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.", @@ -6401,15 +6401,15 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::ScriptedContainer": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "inherited_bases": [], - "kind": "class", + "sha256": "2ae1de9e90a65a00d7bfd2aa2c178507be6ba08a5d9a6d027ddf9cf36fd43feb", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "2ae1de9e90a65a00d7bfd2aa2c178507be6ba08a5d9a6d027ddf9cf36fd43feb" + "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.", @@ -6419,12 +6419,12 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::test_a_create_that_fails_otherwise_is_the_store_being_down::point-seam-1": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "kind": "seam", + "sha256": "8f7cb89055d77297a0a20f53739c62a4b97598a84454eab6ae5dcd43ccd3374c", "methods": [ "create_item" ], - "sha256": "8f7cb89055d77297a0a20f53739c62a4b97598a84454eab6ae5dcd43ccd3374c" + "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.", @@ -6434,12 +6434,12 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::test_a_create_that_finds_the_document_lost_a_race::point-seam-1": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "kind": "seam", + "sha256": "146e5d7a517044d78b1c8a0de5f7a4916bd415a173178a073f28f4b655e4f231", "methods": [ "create_item" ], - "sha256": "146e5d7a517044d78b1c8a0de5f7a4916bd415a173178a073f28f4b655e4f231" + "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.", @@ -6449,12 +6449,12 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::test_a_replace_that_fails_otherwise_is_the_store_being_down::point-seam-1": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "kind": "seam", + "sha256": "ba8e5303562bb824dc89501de3ee7140ad4597343492f61ab757526f76a8283f", "methods": [ "replace_item" ], - "sha256": "ba8e5303562bb824dc89501de3ee7140ad4597343492f61ab757526f76a8283f" + "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.", @@ -6464,12 +6464,12 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::test_a_replace_that_finds_another_write_lost_a_race::point-seam-1": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "kind": "seam", + "sha256": "33d15ef637120178faac825ae93b3ca68da301769de95dd41f7e99a4e396faca", "methods": [ "replace_item" ], - "sha256": "33d15ef637120178faac825ae93b3ca68da301769de95dd41f7e99a4e396faca" + "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.", @@ -6479,12 +6479,12 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::test_a_store_that_cannot_be_read_is_down::point-seam-1": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "kind": "seam", + "sha256": "515891896b3fb6be0b962075132c4811f6300dd779848157a719c95e48a77fc4", "methods": [ "read_item" ], - "sha256": "515891896b3fb6be0b962075132c4811f6300dd779848157a719c95e48a77fc4" + "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.", @@ -6494,12 +6494,12 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::test_the_store_reads_a_document_in_its_own_partition::point-seam-1": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "kind": "seam", + "sha256": "01796adcaab17e27767db173c476d7b65e0e551c084728a2c6fd02d495fb4048", "methods": [ "read_item" ], - "sha256": "01796adcaab17e27767db173c476d7b65e0e551c084728a2c6fd02d495fb4048" + "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.", @@ -6509,12 +6509,12 @@ }, "functional_tests/test_workflow_assist_limits_runtime.py::test_the_store_reads_a_document_in_its_own_partition::point-seam-2": { "boundary": { - "imports_sha256": "4fba4ea8ab6973672c0b712db9aeeb70c90fd2d0df3552393942316f30ffeb7e", - "kind": "seam", + "sha256": "ff700980fe829bb9446ae752ada44ef208083e24d6cb18ab1fabfc15e2220b02", "methods": [ "read_item" ], - "sha256": "ff700980fe829bb9446ae752ada44ef208083e24d6cb18ab1fabfc15e2220b02" + "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.", @@ -6524,13 +6524,13 @@ }, "functional_tests/test_workflow_authoring_sdk_boundaries.py::WorkflowQueryContainer": { "boundary": { - "imports_sha256": "4fa114d17c35a836e12f7b82114df98cc74ac75079da58ff5bd6a778ad7c1721", + "sha256": "1f22d1ffa4e54388b1a9824b2567c38ad831e2b4187bd49e330f84d5b0f1e05a", + "methods": [], + "kind": "class", "inherited_bases": [ "AtomicMemoryContainer" ], - "kind": "class", - "methods": [], - "sha256": "1f22d1ffa4e54388b1a9824b2567c38ad831e2b4187bd49e330f84d5b0f1e05a" + "imports_sha256": "4fa114d17c35a836e12f7b82114df98cc74ac75079da58ff5bd6a778ad7c1721" }, "classification": "sdk-default", "contract": "Inherits AtomicMemoryContainer SDK-default CosmosDict point/write responses, SDK exceptions, partition and conditional-ETag behavior; implements only the bounded personal workflow query subset with plain JSON rows and scalar COUNT results.", @@ -6540,14 +6540,14 @@ }, "functional_tests/test_workflow_background_identity.py::UserSettingsContainer": { "boundary": { - "imports_sha256": "b9e0c0a864e1daa5e1228d87e8d77d50aab75f84d636337446a3c570c1cd632a", - "inherited_bases": [], - "kind": "class", + "sha256": "b4351853b0bb2a1c8e1a9e63dbd4bad226a6628e37a5b02287effe8b1e0b6bc2", "methods": [ "read_item", "upsert_item" ], - "sha256": "b4351853b0bb2a1c8e1a9e63dbd4bad226a6628e37a5b02287effe8b1e0b6bc2" + "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.", @@ -6557,12 +6557,12 @@ }, "functional_tests/test_workflow_chat_delivery_concurrency.py::_barrier_first_run_reads::point-seam-1": { "boundary": { - "imports_sha256": "2fa623188ead79cd93344530e21b8b9c46f51d862bfb0e31bd41ef7b6bc52b60", - "kind": "seam", + "sha256": "b8812329490aaacfc5917dad8e0a6e83bd661e38f23a53d5ae6674d6623d8e25", "methods": [ "read_item" ], - "sha256": "b8812329490aaacfc5917dad8e0a6e83bd661e38f23a53d5ae6674d6623d8e25" + "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.", @@ -6572,17 +6572,17 @@ }, "functional_tests/test_workflow_chat_delivery_imports.py::embedded-PROBE::OfflineContainer": { "boundary": { - "embedded_source_sha256": "30c96313d86b231a68225fa7f6ad5418dab3101d5bdd02bbf9b148e8b915650d", - "imports_sha256": "c1b9e78b8e586d8131ac392959bc67d29d5a828caca291cd5384816f3164b844", - "inherited_bases": [], - "kind": "class", + "sha256": "2ced1cb8515091d014b91a2d9d9a25ab47b38f6e2feb4b2225ca02448a526ec5", "methods": [ "delete_item", "read_item", "replace_item", "upsert_item" ], - "sha256": "2ced1cb8515091d014b91a2d9d9a25ab47b38f6e2feb4b2225ca02448a526ec5" + "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.", @@ -6592,12 +6592,12 @@ }, "functional_tests/test_workflow_chat_delivery_off_golden.py::_capture::point-seam-1": { "boundary": { - "imports_sha256": "e666ba8178673d9a34345318c56b116a192a45a501d605863c1ebac4586ff837", - "kind": "seam", + "sha256": "cc1e17e979336948070072f1ba5398afc1dceb8a8886f2d45269c4f55cb2186d", "methods": [ "create_item" ], - "sha256": "cc1e17e979336948070072f1ba5398afc1dceb8a8886f2d45269c4f55cb2186d" + "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.", @@ -6607,15 +6607,15 @@ }, "functional_tests/test_workflow_chat_execution.py::BoundedReadContainer": { "boundary": { - "imports_sha256": "9f986b7a74eaff811e289fcf0e92a6a98a3654a9e304aad8a49d11a8ecea1a08", - "inherited_bases": [ - "AtomicMemoryContainer" - ], - "kind": "class", + "sha256": "dbb3f09d0556efeb03c66b72ffd229b4d227f2fb48d26eb51d4bdaa503dda1aa", "methods": [ "read_item" ], - "sha256": "dbb3f09d0556efeb03c66b72ffd229b4d227f2fb48d26eb51d4bdaa503dda1aa" + "kind": "class", + "inherited_bases": [ + "AtomicMemoryContainer" + ], + "imports_sha256": "9f986b7a74eaff811e289fcf0e92a6a98a3654a9e304aad8a49d11a8ecea1a08" }, "classification": "sdk-default", "contract": "Inherits the installed-SDK CosmosDict point/write defaults, ETag/CAS, transaction and plain-query behavior from AtomicMemoryContainer; only accepts SDK read timeout keyword arguments.", @@ -6625,14 +6625,14 @@ }, "functional_tests/test_workflow_definition_concurrency.py::Container": { "boundary": { - "imports_sha256": "21c9f4676f46cc28b1b5f6780c041177a914ac396ec1701436ce8b9339e2a658", - "inherited_bases": [], - "kind": "class", + "sha256": "90990ab76f9d8303a91ed42fccdaaa171f176826f7a9d8f089246cb651ed599d", "methods": [ "read_item", "replace_item" ], - "sha256": "90990ab76f9d8303a91ed42fccdaaa171f176826f7a9d8f089246cb651ed599d" + "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.", @@ -6642,15 +6642,15 @@ }, "functional_tests/test_workflow_definition_store_integration.py::WorkflowContainer": { "boundary": { - "imports_sha256": "97ed2d984bec77c1f515cfda166a6d6388dbe17011de595616da6c48b4e65c18", - "inherited_bases": [], - "kind": "class", + "sha256": "372d6981fa4a40a3f65876a57bca6f9a92cd1272508d520468271723998c3f6d", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "372d6981fa4a40a3f65876a57bca6f9a92cd1272508d520468271723998c3f6d" + "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.", @@ -6660,12 +6660,12 @@ }, "functional_tests/test_workflow_draft_service.py::test_a_failed_orchestration_count_fails_closed_wherever_the_cap_is_checked::point-seam-1": { "boundary": { - "imports_sha256": "6287d944e84245244686bbfb6273ae87b4e26a6a3f81d4d66170f540b90bde39", - "kind": "seam", + "sha256": "8e9f032b660c6a86ec2b45645f105082e3389402993d1edb694b186a161ac6ee", "methods": [ "upsert_item" ], - "sha256": "8e9f032b660c6a86ec2b45645f105082e3389402993d1edb694b186a161ac6ee" + "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.", @@ -6675,12 +6675,12 @@ }, "functional_tests/test_workflow_durable_analysis.py::test_run_deletion_fences_never_prepared_and_existing_analyze_work::point-seam-1": { "boundary": { - "imports_sha256": "230f9f7f5bb87187d9b693a5a90fb9369d9228744c2219534812cb6a73bdc1c7", - "kind": "seam", + "sha256": "19506aac88f28a7097cf6ddf7314214013d73d409c40ff8ac99f39eafa76127c", "methods": [ "execute_item_batch" ], - "sha256": "19506aac88f28a7097cf6ddf7314214013d73d409c40ff8ac99f39eafa76127c" + "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.", @@ -6690,16 +6690,16 @@ }, "functional_tests/test_workflow_durable_execution.py::RuntimeContainer": { "boundary": { - "imports_sha256": "d383d01c3eb7d59a65a932bbc66a9c5c1267e879d65fe3e78e13c050b9b28be0", - "inherited_bases": [], - "kind": "class", + "sha256": "d453ac096807c6d57f558e7d10d0da3cb95b918a2383b8535dc7af190d9d1a2b", "methods": [ "create_item", "execute_item_batch", "read_item", "replace_item" ], - "sha256": "d453ac096807c6d57f558e7d10d0da3cb95b918a2383b8535dc7af190d9d1a2b" + "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.", @@ -6709,13 +6709,13 @@ }, "functional_tests/test_workflow_for_each_execution.py::LoopJournalContainer": { "boundary": { - "imports_sha256": "d219351506bf861959b49538dfaca850e487b37839427dc51a2594057597118b", - "inherited_bases": [], - "kind": "class", + "sha256": "4a6a066abde7e9c8d168437020c752db50a467742b3d105a8ad6b10d8e42ed1c", "methods": [ "execute_item_batch" ], - "sha256": "4a6a066abde7e9c8d168437020c752db50a467742b3d105a8ad6b10d8e42ed1c" + "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.", @@ -6725,13 +6725,13 @@ }, "functional_tests/test_workflow_handoff_end_to_end.py::e2e::point-seam-1": { "boundary": { - "imports_sha256": "5c190ba958ce7ab245b1311ceda3ff4188e5ff764b0508cb3c3303fcdc0962e5", - "kind": "seam", + "sha256": "5f2a0c606bcd0689cac7cfa0007d7c9b8199d52d5d0d4ad8e836cb391d63d97a", "methods": [ "read_item", "upsert_item" ], - "sha256": "5f2a0c606bcd0689cac7cfa0007d7c9b8199d52d5d0d4ad8e836cb391d63d97a" + "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.", @@ -6741,13 +6741,13 @@ }, "functional_tests/test_workflow_loop_inputs.py::Container": { "boundary": { - "imports_sha256": "63f11121d5874fb7d1ce566835672c58373e395aea349525048fdda857777618", - "inherited_bases": [], - "kind": "class", + "sha256": "d5707e097bcdc17aef8dac6729e92f495bad81597d0eb1eeb277073a11094fb5", "methods": [ "read_item" ], - "sha256": "d5707e097bcdc17aef8dac6729e92f495bad81597d0eb1eeb277073a11094fb5" + "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.", @@ -6757,15 +6757,15 @@ }, "functional_tests/test_workflow_plan_replay_execution.py::RuntimeContainer": { "boundary": { - "imports_sha256": "975f1a19080aa9f4e0f57fc5542be8f09725fdba1d60fd80f5533aa85884b731", - "inherited_bases": [], - "kind": "class", + "sha256": "b3e84347ac22ff216726d85acbbefb3c890d325f191ae81eae9a8a4ee5aec729", "methods": [ "create_item", "read_item", "replace_item" ], - "sha256": "b3e84347ac22ff216726d85acbbefb3c890d325f191ae81eae9a8a4ee5aec729" + "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.", @@ -6775,13 +6775,13 @@ }, "functional_tests/test_workflow_plan_replay_routes.py::WorkflowStore": { "boundary": { - "imports_sha256": "017f7cbc10254614ffda8feea31ab921b6e54b2166e26cdbc4c3a33b6fcd5a01", + "sha256": "f7f998efe192e093fa73d6945ef05dc8ebe167e72fec2279ea0e1d5a4d9f8ccb", + "methods": [], + "kind": "class", "inherited_bases": [ "AtomicMemoryContainer" ], - "kind": "class", - "methods": [], - "sha256": "f7f998efe192e093fa73d6945ef05dc8ebe167e72fec2279ea0e1d5a4d9f8ccb" + "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.", @@ -6791,12 +6791,12 @@ }, "functional_tests/test_workflow_plan_replay_routes.py::test_a_store_failure_is_a_fixed_error_without_detail::point-seam-1": { "boundary": { - "imports_sha256": "017f7cbc10254614ffda8feea31ab921b6e54b2166e26cdbc4c3a33b6fcd5a01", - "kind": "seam", + "sha256": "a24bdb745cd5313beeb0ec09c6d5a5473a26df1951e989af03f250985de96b60", "methods": [ "create_item" ], - "sha256": "a24bdb745cd5313beeb0ec09c6d5a5473a26df1951e989af03f250985de96b60" + "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.", @@ -6806,14 +6806,14 @@ }, "functional_tests/test_workflow_private_analysis_records.py::Items": { "boundary": { - "imports_sha256": "f806a6edf408a96e39ca0c4f1ec16a0615608f06db05b86c9517d118b96b241f", - "inherited_bases": [], - "kind": "class", + "sha256": "46ab13715088760b2c98584ff5775c251d099d68d3ae68ef06fd9b40840b368c", "methods": [ "delete_item", "read_item" ], - "sha256": "46ab13715088760b2c98584ff5775c251d099d68d3ae68ef06fd9b40840b368c" + "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.", @@ -6823,12 +6823,12 @@ }, "functional_tests/test_workflow_repeat_recovery.py::test_lost_acknowledgement_does_not_duplicate_transitions_or_grants::point-seam-1": { "boundary": { - "imports_sha256": "ee797e9a3cc2dbea12bfe42d6c2cc96a0f527e697b9d6bf55d8358165a05372f", - "kind": "seam", + "sha256": "34120c4d3fa4b52e4d18a9f5335db563e1c2258be45aeb464bfa54562627abc6", "methods": [ "execute_item_batch" ], - "sha256": "34120c4d3fa4b52e4d18a9f5335db563e1c2258be45aeb464bfa54562627abc6" + "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.", @@ -6838,14 +6838,14 @@ }, "functional_tests/test_workflow_reply_replaces_agent_posted_message.py::FakeContainer": { "boundary": { - "imports_sha256": "4e5bdb498c9bbd6ef72c205986af9dbfb8d4e68f726b7bdcdbc402b24b630119", - "inherited_bases": [], - "kind": "class", + "sha256": "c3b916df13bfea644be4f03a68eecab3ce723c46de0e1edf85d3481386c8c43f", "methods": [ "read_item", "upsert_item" ], - "sha256": "c3b916df13bfea644be4f03a68eecab3ce723c46de0e1edf85d3481386c8c43f" + "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.", @@ -6855,14 +6855,14 @@ }, "functional_tests/test_workflow_result_followup.py::Messages": { "boundary": { - "imports_sha256": "309de0e9b44636c618819f3fe1e59b3584c2ca456b5c5e747f42290d730e06de", - "inherited_bases": [], - "kind": "class", + "sha256": "5c9d9857711e0f7f092acfd767ffc90faa6c65399a95c932a87bbec96e9867cf", "methods": [ "delete_item", "upsert_item" ], - "sha256": "5c9d9857711e0f7f092acfd767ffc90faa6c65399a95c932a87bbec96e9867cf" + "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.", @@ -6872,15 +6872,15 @@ }, "functional_tests/test_workflow_result_store.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "d98517ba1cdf0c474561f926607eb6e8e8cc41455038e48496df17ef25700f9d", - "inherited_bases": [], - "kind": "class", + "sha256": "134cf9be5f9422b71512c5092bbb46e0b73d41ddbaa0757cbe333e51c1c8c4d6", "methods": [ "create_item", "delete_item", "read_item" ], - "sha256": "134cf9be5f9422b71512c5092bbb46e0b73d41ddbaa0757cbe333e51c1c8c4d6" + "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.", @@ -6890,12 +6890,12 @@ }, "functional_tests/test_workflow_results_delivery.py::test_retry_repairs_conversation_summary_after_message_only_write::point-seam-1": { "boundary": { - "imports_sha256": "5fa53556bc9b6b5309847067685376d89a8026ebb1f1b14db05c33b354a7f07b", - "kind": "seam", + "sha256": "4701ce56314711ed921134a0c1fa473723aed3d09899858aacc85ede68b68fdd", "methods": [ "upsert_item" ], - "sha256": "4701ce56314711ed921134a0c1fa473723aed3d09899858aacc85ede68b68fdd" + "kind": "seam", + "imports_sha256": "5fa53556bc9b6b5309847067685376d89a8026ebb1f1b14db05c33b354a7f07b" }, "classification": "fault-injection", "contract": "Interrupts the first conversation summary upsert after a message has persisted, otherwise delegates to the existing SDK-default AtomicMemoryContainer. The real owner retries and repairs its summary without duplicate messages.", @@ -6905,15 +6905,15 @@ }, "functional_tests/test_workflow_runtime_integration.py::ServiceContainer": { "boundary": { - "imports_sha256": "7ecf456dc7fe3d8c91c650bc09e43f8cb3551a9fa62e18d457800b0e79c1aad9", - "inherited_bases": [], - "kind": "class", + "sha256": "cf6b60969a853df82d4c46e03f98b8c17ea513eb53f1458a156eb01a97d03ac7", "methods": [ "create_item", "replace_item", "upsert_item" ], - "sha256": "cf6b60969a853df82d4c46e03f98b8c17ea513eb53f1458a156eb01a97d03ac7" + "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.", @@ -6923,16 +6923,16 @@ }, "functional_tests/test_workflow_runtime_store.py::FakeCosmosContainer": { "boundary": { - "imports_sha256": "c3cb22a3e4db31cecd8c5058f9ac3ac6d5632bb72bbd2aa572f8b5860f1af372", - "inherited_bases": [], - "kind": "class", + "sha256": "5bebc7079a8a0e7a9d83626b44e2446392dd25e50ede4a5b00a3618fb048e500", "methods": [ "create_item", "execute_item_batch", "read_item", "replace_item" ], - "sha256": "5bebc7079a8a0e7a9d83626b44e2446392dd25e50ede4a5b00a3618fb048e500" + "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.", @@ -6942,12 +6942,12 @@ }, "functional_tests/test_workflow_saved_output_artifacts.py::artifact_services::point-seam-1": { "boundary": { - "imports_sha256": "d9b500c558082888ff2b1402d4ee41f1d5c4a4cc312a0242abe44f4c17a81e53", - "kind": "seam", + "sha256": "88e323862b49245a57a65c78d457bc54742113f456dadb842d15a567e7ed8cfe", "methods": [ "create_item" ], - "sha256": "88e323862b49245a57a65c78d457bc54742113f456dadb842d15a567e7ed8cfe" + "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.", @@ -6957,12 +6957,12 @@ }, "functional_tests/test_workflow_saved_output_artifacts.py::test_lost_acknowledgements_reuse_the_prepared_bytes_and_address.lose_message_ack::point-seam-1": { "boundary": { - "imports_sha256": "d9b500c558082888ff2b1402d4ee41f1d5c4a4cc312a0242abe44f4c17a81e53", - "kind": "seam", + "sha256": "f37c0f95b9d4d4e01b58f1e4c30503ef75ee760dc9924b88c074a6c7bcc2a99b", "methods": [ "create_item" ], - "sha256": "f37c0f95b9d4d4e01b58f1e4c30503ef75ee760dc9924b88c074a6c7bcc2a99b" + "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.", @@ -6972,12 +6972,12 @@ }, "functional_tests/test_workflow_saved_output_artifacts.py::test_lost_acknowledgements_reuse_the_prepared_bytes_and_address::point-seam-1": { "boundary": { - "imports_sha256": "d9b500c558082888ff2b1402d4ee41f1d5c4a4cc312a0242abe44f4c17a81e53", - "kind": "seam", + "sha256": "3677403bbadd3109fc734b2e8e284b2f2fe716fc3e7bd0a657f1f60336ce8365", "methods": [ "create_item" ], - "sha256": "3677403bbadd3109fc734b2e8e284b2f2fe716fc3e7bd0a657f1f60336ce8365" + "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.", @@ -6987,12 +6987,12 @@ }, "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_delete_during_the_save_is_the_same_409::point-seam-1": { "boundary": { - "imports_sha256": "8db98064e1188c3c58aa730d8baae6731ae083eef71d64ff7313d22126f73686", - "kind": "seam", + "sha256": "391b0532e53023d7867d4d155574f3be7f7bc37a5766bf94bd23f3ae6107df69", "methods": [ "read_item" ], - "sha256": "391b0532e53023d7867d4d155574f3be7f7bc37a5766bf94bd23f3ae6107df69" + "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.", @@ -7002,12 +7002,12 @@ }, "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_lookup_that_fails_once_keeps_the_existing_conflict::point-seam-1": { "boundary": { - "imports_sha256": "8db98064e1188c3c58aa730d8baae6731ae083eef71d64ff7313d22126f73686", - "kind": "seam", + "sha256": "0f68eb7720083ca755f15be2079b1936a946a01f2b48ba93defd2a5c51297bb9", "methods": [ "read_item" ], - "sha256": "0f68eb7720083ca755f15be2079b1936a946a01f2b48ba93defd2a5c51297bb9" + "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.", @@ -7017,12 +7017,12 @@ }, "functional_tests/test_workflow_settings_reviewed_messages.py::test_a_transient_read_failure_is_never_reported_as_a_deletion::point-seam-1": { "boundary": { - "imports_sha256": "8db98064e1188c3c58aa730d8baae6731ae083eef71d64ff7313d22126f73686", - "kind": "seam", + "sha256": "ae7494c17a0c289cf186712d7d00626e5c235d776b17014dc30f45c2043cba49", "methods": [ "read_item" ], - "sha256": "ae7494c17a0c289cf186712d7d00626e5c235d776b17014dc30f45c2043cba49" + "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.", @@ -7032,13 +7032,13 @@ }, "functional_tests/test_workflow_structured_flow.py::JournalContainer": { "boundary": { - "imports_sha256": "d71c9069216784edf8fad46ad7a2520586855ede132dc4320e8a15e34f055000", - "inherited_bases": [], - "kind": "class", + "sha256": "01514881bead31139c1161bba38877149579962b4833c64181670728455e676a", "methods": [ "delete_item" ], - "sha256": "01514881bead31139c1161bba38877149579962b4833c64181670728455e676a" + "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.", @@ -7048,12 +7048,12 @@ }, "functional_tests/test_workflow_structured_flow.py::test_lost_decision_acknowledgement_does_not_double_admit_or_change_choice::point-seam-1": { "boundary": { - "imports_sha256": "d71c9069216784edf8fad46ad7a2520586855ede132dc4320e8a15e34f055000", - "kind": "seam", + "sha256": "34120c4d3fa4b52e4d18a9f5335db563e1c2258be45aeb464bfa54562627abc6", "methods": [ "execute_item_batch" ], - "sha256": "34120c4d3fa4b52e4d18a9f5335db563e1c2258be45aeb464bfa54562627abc6" + "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.", @@ -7063,12 +7063,12 @@ }, "functional_tests/test_workflow_structured_flow.py::test_v3_analyze_writes_retain_workflow_and_native_guard_fences::point-seam-1": { "boundary": { - "imports_sha256": "d71c9069216784edf8fad46ad7a2520586855ede132dc4320e8a15e34f055000", - "kind": "seam", + "sha256": "ee44424b34bde7b46437ffac6a6590206318d575d52008cda37352d88607444e", "methods": [ "execute_item_batch" ], - "sha256": "ee44424b34bde7b46437ffac6a6590206318d575d52008cda37352d88607444e" + "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.", @@ -7078,15 +7078,15 @@ }, "functional_tests/test_workflow_task_result_handoff.py::RunItemsContainer": { "boundary": { - "imports_sha256": "ca9c2487b2e6b72466f2d1051dec21df6ac06b425abd2c945c786f8514700cba", - "inherited_bases": [ - "FakeCosmosContainer" - ], - "kind": "class", + "sha256": "651e8a567626bd17cfdc301dbaf50c49c28557940d444fab2522211c8eafdfcc", "methods": [ "upsert_item" ], - "sha256": "651e8a567626bd17cfdc301dbaf50c49c28557940d444fab2522211c8eafdfcc" + "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.", @@ -7117,14 +7117,14 @@ }, "functional_tests/test_yamcs_action_plugin.py::FakeConfigCosmosContainer": { "boundary": { - "imports_sha256": "c627a61e49bf8d17af74ea2e167c6ee7539348e10ea5cffa9c46b26610908c10", - "inherited_bases": [], - "kind": "class", + "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558", "methods": [ "read_item", "upsert_item" ], - "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558" + "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.", @@ -7134,14 +7134,14 @@ }, "functional_tests/test_yamcs_basic_auth.py::FakeConfigCosmosContainer": { "boundary": { - "imports_sha256": "f117480d3a78090c5ace2f23e79f1303a1bdc7b0fca5cb570ce9eb9cffa2c0a5", - "inherited_bases": [], - "kind": "class", + "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558", "methods": [ "read_item", "upsert_item" ], - "sha256": "4018e342fac645ac62a882cfc9e1c46c2102e9ad98f53bc5c6d115bf958f8558" + "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.", @@ -7373,8 +7373,7 @@ "owners": { "application/single_app/app_settings_cache.py::_append_stream_session_event_fallback": { "boundary": { - "batches": [], - "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e", + "sha256": "2fc56697c3fb9c7afeee564bc4af2ea7e4ef1895f8509334e11c316fe6b82939", "points": [ { "method": "read_item", @@ -7393,7 +7392,8 @@ } ], "queries": [], - "sha256": "2fc56697c3fb9c7afeee564bc4af2ea7e4ef1895f8509334e11c316fe6b82939" + "batches": [], + "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e" }, "classification": "sdk-compatible", "contract": "_append_stream_session_event_fallback: read_item CosmosDict is accessed as a Mapping for payload list and _etag before conditional IfNotModified replace_item; replace_item and create_item responses are discarded.", @@ -7405,8 +7405,7 @@ }, "application/single_app/app_settings_cache.py::_bump_cosmos_cache_version": { "boundary": { - "batches": [], - "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e", + "sha256": "94fb0eb8a5eee38d044e6ed3f7db37c3fbf2cea2db3f829fc53d063bbde6de16", "points": [ { "method": "upsert_item", @@ -7415,7 +7414,8 @@ } ], "queries": [], - "sha256": "94fb0eb8a5eee38d044e6ed3f7db37c3fbf2cea2db3f829fc53d063bbde6de16" + "batches": [], + "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e" }, "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.", @@ -7424,8 +7424,7 @@ }, "application/single_app/app_settings_cache.py::_delete_cosmos_cache_entry": { "boundary": { - "batches": [], - "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e", + "sha256": "c7470f5d5ecc0525f11daaa1b6e2acf5a4a1ddd302a2dfe27d67830404cb8e34", "points": [ { "method": "delete_item", @@ -7434,7 +7433,8 @@ } ], "queries": [], - "sha256": "c7470f5d5ecc0525f11daaa1b6e2acf5a4a1ddd302a2dfe27d67830404cb8e34" + "batches": [], + "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e" }, "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.", @@ -7443,8 +7443,7 @@ }, "application/single_app/app_settings_cache.py::_get_cosmos_cache_entry": { "boundary": { - "batches": [], - "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e", + "sha256": "d41e20b1a45eaae5cd9d8288f398ac59ec6796f671457f4b6f7d35e7b535a018", "points": [ { "method": "read_item", @@ -7453,7 +7452,8 @@ } ], "queries": [], - "sha256": "d41e20b1a45eaae5cd9d8288f398ac59ec6796f671457f4b6f7d35e7b535a018" + "batches": [], + "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e" }, "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.", @@ -7464,8 +7464,7 @@ }, "application/single_app/app_settings_cache.py::_initialize_stream_session_cache_fallback": { "boundary": { - "batches": [], - "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e", + "sha256": "2cfd9858f7115d531fc4baa0a25726ad27525259f5330e482626cafb6f0e7156", "points": [ { "method": "create_item", @@ -7474,7 +7473,8 @@ } ], "queries": [], - "sha256": "2cfd9858f7115d531fc4baa0a25726ad27525259f5330e482626cafb6f0e7156" + "batches": [], + "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e" }, "classification": "response-unused", "contract": "_initialize_stream_session_cache_fallback: create_item response is discarded when seeding the empty stream-event list; existing metadata/events entries are written through _set_cosmos_cache_entry.", @@ -7483,8 +7483,7 @@ }, "application/single_app/app_settings_cache.py::_read_cosmos_cache_version": { "boundary": { - "batches": [], - "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e", + "sha256": "ee8d7a9b4f1e28bcb5e92a7079a51a38a58985900c62778a5557ce1f4dcc728d", "points": [ { "method": "read_item", @@ -7493,7 +7492,8 @@ } ], "queries": [], - "sha256": "ee8d7a9b4f1e28bcb5e92a7079a51a38a58985900c62778a5557ce1f4dcc728d" + "batches": [], + "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e" }, "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.", @@ -7504,8 +7504,7 @@ }, "application/single_app/app_settings_cache.py::_set_cosmos_cache_entry": { "boundary": { - "batches": [], - "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e", + "sha256": "64c1263f1410ca12ff48600ebc167a6e33588a2148b5c7c8033e3ccff6dfd7a6", "points": [ { "method": "upsert_item", @@ -7514,7 +7513,8 @@ } ], "queries": [], - "sha256": "64c1263f1410ca12ff48600ebc167a6e33588a2148b5c7c8033e3ccff6dfd7a6" + "batches": [], + "module_sha256": "20fc93bec7731b05bc685c03329690e16902e77c15b383e060fd65098045051e" }, "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.", @@ -7523,8 +7523,7 @@ }, "application/single_app/app_settings_store.py::AppSettingsStore._read_cosmos": { "boundary": { - "batches": [], - "module_sha256": "5001ed2aff39810164525a95297eb373816d653959c2589a161ecf2039ac6277", + "sha256": "36aed858c8e90028d1d8ceb2f78f2e373d463d6fa8f7f6f257fd523582c1f09e", "points": [ { "method": "read_item", @@ -7533,7 +7532,8 @@ } ], "queries": [], - "sha256": "36aed858c8e90028d1d8ceb2f78f2e373d463d6fa8f7f6f257fd523582c1f09e" + "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.", @@ -7544,8 +7544,7 @@ }, "application/single_app/app_settings_store.py::AppSettingsStore._write": { "boundary": { - "batches": [], - "module_sha256": "5001ed2aff39810164525a95297eb373816d653959c2589a161ecf2039ac6277", + "sha256": "2d33863c40cf1154b7ee36b48349a1f5d95922756f99658071f8565a66c1c164", "points": [ { "method": "replace_item", @@ -7559,7 +7558,8 @@ } ], "queries": [], - "sha256": "2d33863c40cf1154b7ee36b48349a1f5d95922756f99658071f8565a66c1c164" + "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.", @@ -7570,8 +7570,7 @@ }, "application/single_app/background_tasks.py::acquire_distributed_task_lock": { "boundary": { - "batches": [], - "module_sha256": "48da4da09bfa2996fab51aa9a50a5ee6915758a16b50443c29291ee227f910e7", + "sha256": "a6fb81a6f542346f77124dde4190a8a52a13aabc0e6f7f1f60d5aac6013d3170", "points": [ { "method": "create_item", @@ -7590,7 +7589,8 @@ } ], "queries": [], - "sha256": "a6fb81a6f542346f77124dde4190a8a52a13aabc0e6f7f1f60d5aac6013d3170" + "batches": [], + "module_sha256": "48da4da09bfa2996fab51aa9a50a5ee6915758a16b50443c29291ee227f910e7" }, "classification": "sdk-compatible", "contract": "Lock takeover field-reads the SDK mapping and builds a plain replacement with its original ETag; create/replace responses are unused. Real SDK regression exercises expired takeover and refusal of a live lease.", @@ -7601,8 +7601,7 @@ }, "application/single_app/background_tasks.py::release_distributed_task_lock": { "boundary": { - "batches": [], - "module_sha256": "48da4da09bfa2996fab51aa9a50a5ee6915758a16b50443c29291ee227f910e7", + "sha256": "db34f1f61e312fbe0f21f5f67348acc052e0836093aba6cc31e76bd716bbda52", "points": [ { "method": "read_item", @@ -7616,7 +7615,8 @@ } ], "queries": [], - "sha256": "db34f1f61e312fbe0f21f5f67348acc052e0836093aba6cc31e76bd716bbda52" + "batches": [], + "module_sha256": "48da4da09bfa2996fab51aa9a50a5ee6915758a16b50443c29291ee227f910e7" }, "classification": "sdk-compatible", "contract": "Lock release compares current holder fields from the SDK point mapping and conditionally deletes with its ETag. Real SDK regression verifies holder isolation, partition routing and If-Match.", @@ -7637,10 +7637,10 @@ ], "queries": [], "batches": [], - "module_sha256": "0371337955a69c822cbb5c5fadb0a8d858022a8ee6fe68deecc063d8c1a011fd" + "module_sha256": "039d3c3ae084862d761feb203f9f774377d60cc29b1ff7e31e0b0e6bc7322ba2" }, "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. Review 0.261.395: SDK-shaped current document/release-proof reads and plain blob/native query locators are executed through the real owners; canonical source scope is enforced before document consumption.", + "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. Review 0.261.395: SDK-shaped current document/release-proof reads and plain blob/native query locators are executed through the real owners; canonical source scope is enforced before document consumption. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_document_source_runtime.py::test_real_source_owners_keep_sdk_points_release_proofs_and_plain_query_rows" @@ -7658,10 +7658,10 @@ ], "queries": [], "batches": [], - "module_sha256": "0371337955a69c822cbb5c5fadb0a8d858022a8ee6fe68deecc063d8c1a011fd" + "module_sha256": "039d3c3ae084862d761feb203f9f774377d60cc29b1ff7e31e0b0e6bc7322ba2" }, "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. Review 0.261.395: SDK-shaped current document/release-proof reads and plain blob/native query locators are executed through the real owners; canonical source scope is enforced before document consumption.", + "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. Review 0.261.395: SDK-shaped current document/release-proof reads and plain blob/native query locators are executed through the real owners; canonical source scope is enforced before document consumption. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_document_source_runtime.py::test_real_source_owners_keep_sdk_points_release_proofs_and_plain_query_rows" @@ -7690,10 +7690,10 @@ } ], "batches": [], - "module_sha256": "0371337955a69c822cbb5c5fadb0a8d858022a8ee6fe68deecc063d8c1a011fd" + "module_sha256": "039d3c3ae084862d761feb203f9f774377d60cc29b1ff7e31e0b0e6bc7322ba2" }, "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. Review 0.261.395: SDK-shaped current document/release-proof reads and plain blob/native query locators are executed through the real owners; canonical source scope is enforced before document consumption.", + "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. Review 0.261.395: SDK-shaped current document/release-proof reads and plain blob/native query locators are executed through the real owners; canonical source scope is enforced before document consumption. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_document_source_runtime.py::test_real_source_owners_keep_sdk_points_release_proofs_and_plain_query_rows" @@ -7711,10 +7711,10 @@ } ], "batches": [], - "module_sha256": "0371337955a69c822cbb5c5fadb0a8d858022a8ee6fe68deecc063d8c1a011fd" + "module_sha256": "039d3c3ae084862d761feb203f9f774377d60cc29b1ff7e31e0b0e6bc7322ba2" }, "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. Review 0.261.395: SDK-shaped current document/release-proof reads and plain blob/native query locators are executed through the real owners; canonical source scope is enforced before document consumption.", + "contract": "_resolve_native_evidence: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair. Review 0.261.395: SDK-shaped current document/release-proof reads and plain blob/native query locators are executed through the real owners; canonical source scope is enforced before document consumption. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_document_source_runtime.py::test_real_source_owners_keep_sdk_points_release_proofs_and_plain_query_rows" @@ -7722,8 +7722,7 @@ }, "application/single_app/content_screening/model.py::_resolve_settings": { "boundary": { - "batches": [], - "module_sha256": "0753ee6a859407c3479383b007b2f59f50ebad5902d4f8c9c8349795f44764cd", + "sha256": "ee0774d0a9d6b22f2f39503b1f9a905ce5cadae3ca01159ebe344ec3821f8af1", "points": [ { "method": "read_item", @@ -7732,7 +7731,8 @@ } ], "queries": [], - "sha256": "ee0774d0a9d6b22f2f39503b1f9a905ce5cadae3ca01159ebe344ec3821f8af1" + "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.", @@ -7743,8 +7743,7 @@ }, "application/single_app/content_screening/repository.py::ScreeningRepository.count": { "boundary": { - "batches": [], - "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278", + "sha256": "d0530e1cdbccdc9ee1e8e616e5ddce014222d33c6f59e8bc1dc161fbccb18c54", "points": [], "queries": [ { @@ -7753,7 +7752,8 @@ "response": "consumed" } ], - "sha256": "d0530e1cdbccdc9ee1e8e616e5ddce014222d33c6f59e8bc1dc161fbccb18c54" + "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.", @@ -7764,8 +7764,7 @@ }, "application/single_app/content_screening/repository.py::ScreeningRepository.create": { "boundary": { - "batches": [], - "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278", + "sha256": "3d89633464263004b1e4731d6f25e3344eeaaf5f6aff9a0915ab2cf4419fdacf", "points": [ { "method": "create_item", @@ -7774,7 +7773,8 @@ } ], "queries": [], - "sha256": "3d89633464263004b1e4731d6f25e3344eeaaf5f6aff9a0915ab2cf4419fdacf" + "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.", @@ -7785,8 +7785,7 @@ }, "application/single_app/content_screening/repository.py::ScreeningRepository.get": { "boundary": { - "batches": [], - "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278", + "sha256": "ad6769e0f5acae4ddca09f65adee24bc38445b5ad25c26a343054c74d47e5ee2", "points": [ { "method": "read_item", @@ -7795,7 +7794,8 @@ } ], "queries": [], - "sha256": "ad6769e0f5acae4ddca09f65adee24bc38445b5ad25c26a343054c74d47e5ee2" + "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.", @@ -7806,8 +7806,7 @@ }, "application/single_app/content_screening/repository.py::ScreeningRepository.read_document": { "boundary": { - "batches": [], - "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278", + "sha256": "23fe4d666c1b7dab21443083c78b504edf24390c168632ce1aac634f8fc8dae3", "points": [ { "method": "read_item", @@ -7816,7 +7815,8 @@ } ], "queries": [], - "sha256": "23fe4d666c1b7dab21443083c78b504edf24390c168632ce1aac634f8fc8dae3" + "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.", @@ -7827,8 +7827,7 @@ }, "application/single_app/content_screening/repository.py::ScreeningRepository.replace": { "boundary": { - "batches": [], - "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278", + "sha256": "8c6747d482d4d5fa4c3cc15b489cea95f1014b1f21f4f68b9f79260374e9b0d3", "points": [ { "method": "replace_item", @@ -7837,7 +7836,8 @@ } ], "queries": [], - "sha256": "8c6747d482d4d5fa4c3cc15b489cea95f1014b1f21f4f68b9f79260374e9b0d3" + "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.", @@ -7848,8 +7848,7 @@ }, "application/single_app/content_screening/repository.py::ScreeningRepository.update_document": { "boundary": { - "batches": [], - "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278", + "sha256": "4ce03bb70596c2f36b9dceb56d3549ca172da87c21185c90f6330e478657f97a", "points": [ { "method": "replace_item", @@ -7858,7 +7857,8 @@ } ], "queries": [], - "sha256": "4ce03bb70596c2f36b9dceb56d3549ca172da87c21185c90f6330e478657f97a" + "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.", @@ -7869,8 +7869,7 @@ }, "application/single_app/content_screening/repository.py::_read_page": { "boundary": { - "batches": [], - "module_sha256": "c18109a0973592ee0de15ba51cf0fcabd515fecd0c2d2bf4e5bfbbb355ede278", + "sha256": "8eb3ea6d318a228d144499e0ae860048b29b575b77b9311c732baa878fa05cc5", "points": [], "queries": [ { @@ -7879,7 +7878,8 @@ "response": "consumed" } ], - "sha256": "8eb3ea6d318a228d144499e0ae860048b29b575b77b9311c732baa878fa05cc5" + "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.", @@ -7890,8 +7890,7 @@ }, "application/single_app/conversation_memory_runtime.py::register_memory_artifact": { "boundary": { - "batches": [], - "module_sha256": "5e9da644ef7c8aedcd45f11d0cc44a315e69bcd6ee2bdc026da10ee91db40201", + "sha256": "6c699ba7f4ed701eda5e93d8009f2106784be7426a25d3e277a108503a12a0fc", "points": [ { "method": "upsert_item", @@ -7900,7 +7899,8 @@ } ], "queries": [], - "sha256": "6c699ba7f4ed701eda5e93d8009f2106784be7426a25d3e277a108503a12a0fc" + "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.", @@ -7909,8 +7909,7 @@ }, "application/single_app/conversation_memory_runtime.py::resolve_m365_memory": { "boundary": { - "batches": [], - "module_sha256": "5e9da644ef7c8aedcd45f11d0cc44a315e69bcd6ee2bdc026da10ee91db40201", + "sha256": "ea6bc48a41c8be5c3e4957b1515891506ec7435e75f0a07c125926a9236f007f", "points": [ { "method": "read_item", @@ -7924,7 +7923,8 @@ } ], "queries": [], - "sha256": "ea6bc48a41c8be5c3e4957b1515891506ec7435e75f0a07c125926a9236f007f" + "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.", @@ -7935,8 +7935,7 @@ }, "application/single_app/conversation_memory_runtime.py::resolve_memory_context": { "boundary": { - "batches": [], - "module_sha256": "5e9da644ef7c8aedcd45f11d0cc44a315e69bcd6ee2bdc026da10ee91db40201", + "sha256": "1ef346ae3abbebf2650c76a61cb86d9ae9924bf443e8679ff9c2a7f344917af7", "points": [ { "method": "read_item", @@ -7945,7 +7944,8 @@ } ], "queries": [], - "sha256": "1ef346ae3abbebf2650c76a61cb86d9ae9924bf443e8679ff9c2a7f344917af7" + "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.", @@ -7956,8 +7956,7 @@ }, "application/single_app/foundry_agent_runtime.py::_collect_recent_chat_upload_file_inputs": { "boundary": { - "batches": [], - "module_sha256": "fea01ed862f8a6f1cd0e148a29ae8c8577469264f24640350727f5d90099b60d", + "sha256": "a29b57f7e4c84fbc8d598d0dcaba8727634debb59967609cf454a35a7e570c9f", "points": [], "queries": [ { @@ -7966,7 +7965,8 @@ "response": "consumed" } ], - "sha256": "a29b57f7e4c84fbc8d598d0dcaba8727634debb59967609cf454a35a7e570c9f" + "batches": [], + "module_sha256": "fea01ed862f8a6f1cd0e148a29ae8c8577469264f24640350727f5d90099b60d" }, "classification": "sdk-compatible", "contract": "The unchanged upload reader consumes plain query rows via mapping field access; the real helper regression verifies SDK-default point wrappers/query rows, upload filtering, size limits and deduplication with blob I/O isolated. Foundry invocation controls do not alter this storage consumer.", @@ -7977,8 +7977,7 @@ }, "application/single_app/functions_action_catalog.py::_stored_actions": { "boundary": { - "batches": [], - "module_sha256": "7ac0b85cba780b4f7101876cf5b3615f7cefbe62aea97fc933c00268d03f39b6", + "sha256": "58b88c32f9ed67dbe2ccf5e93216b98f417600f1a5793438fe712e5e7e959f87", "points": [], "queries": [ { @@ -7992,7 +7991,8 @@ "response": "returned" } ], - "sha256": "58b88c32f9ed67dbe2ccf5e93216b98f417600f1a5793438fe712e5e7e959f87" + "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.", @@ -8003,8 +8003,7 @@ }, "application/single_app/functions_action_catalog.py::resolve_action_manifest": { "boundary": { - "batches": [], - "module_sha256": "7ac0b85cba780b4f7101876cf5b3615f7cefbe62aea97fc933c00268d03f39b6", + "sha256": "b782347ae9ed41b1e30fe8d8bf70124cc9692c38918845e121023d468a2c9144", "points": [ { "method": "read_item", @@ -8013,7 +8012,8 @@ } ], "queries": [], - "sha256": "b782347ae9ed41b1e30fe8d8bf70124cc9692c38918845e121023d468a2c9144" + "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.", @@ -8024,8 +8024,7 @@ }, "application/single_app/functions_action_credential_conversations.py::CredentialConversations._read": { "boundary": { - "batches": [], - "module_sha256": "95d6755194e6e9bcb1f2cf5090788555147b0734479993867536d6c880a24901", + "sha256": "3e86d17a7e5aaabed5761966c9c83b2ad42c031fa45121eb750d645d8624b441", "points": [ { "method": "read_item", @@ -8034,20 +8033,20 @@ } ], "queries": [], - "sha256": "3e86d17a7e5aaabed5761966c9c83b2ad42c031fa45121eb750d645d8624b441" + "batches": [], + "module_sha256": "95d6755194e6e9bcb1f2cf5090788555147b0734479993867536d6c880a24901" }, "classification": "normalized-strict", "contract": "SDK CosmosDict point responses normalize to a plain dictionary with ETag before credential context/origin validation. Not-found remains distinct from invalid response/storage failure; no writes. Real Flask shared recovery and continuation use SDK-default points.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_credentials_shared_conversations.py", - "functional_tests/test_action_credentials_chat_reconstruction.py::test_shared_chat_private_prompt_and_exact_continuation" + "functional_tests/test_action_credentials_chat_reconstruction.py::test_shared_chat_private_prompt_and_exact_continuation", + "functional_tests/test_action_credentials_shared_conversations.py" ] }, "application/single_app/functions_action_credential_state.py::create": { "boundary": { - "batches": [], - "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c", + "sha256": "c9a4a6aaf7031f06328e2b44fbd323c06d692e3933eb08236c94eb4fd18e8cee", "points": [ { "method": "create_item", @@ -8056,20 +8055,20 @@ } ], "queries": [], - "sha256": "c9a4a6aaf7031f06328e2b44fbd323c06d692e3933eb08236c94eb4fd18e8cee" + "batches": [], + "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c" }, "classification": "normalized-strict", "contract": "Normalizes the SDK create response before strict private JSON consumers; retains the actor partition and ETag for submission/checkpoint updates.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_personal_credentials.py", - "functional_tests/test_action_credentials_bootstrap.py" + "functional_tests/test_action_credentials_bootstrap.py", + "functional_tests/test_action_personal_credentials.py" ] }, "application/single_app/functions_action_credential_state.py::delete_private_state": { "boundary": { - "batches": [], - "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c", + "sha256": "150a694b28f93c81ebe2781565610e857887829533dc513f2e1069851040c65c", "points": [ { "method": "delete_item", @@ -8084,20 +8083,20 @@ "response": "consumed" } ], - "sha256": "150a694b28f93c81ebe2781565610e857887829533dc513f2e1069851040c65c" + "batches": [], + "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c" }, "classification": "response-unused", "contract": "Owned query rows supply id/ETag for conditional deletion; response bodies are unused. Concurrent not-found is idempotent; all other failures propagate and conversation cleanup retains persistent bindings.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_personal_credentials.py", - "functional_tests/test_action_credentials_bootstrap.py" + "functional_tests/test_action_credentials_bootstrap.py", + "functional_tests/test_action_personal_credentials.py" ] }, "application/single_app/functions_action_credential_state.py::invalidate_identity": { "boundary": { - "batches": [], - "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c", + "sha256": "085b6bf2d3405a4b0caef746001cc944c2604efb10c010d816ad3410b5c539b2", "points": [], "queries": [ { @@ -8106,20 +8105,20 @@ "response": "consumed" } ], - "sha256": "085b6bf2d3405a4b0caef746001cc944c2604efb10c010d816ad3410b5c539b2" + "batches": [], + "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c" }, "classification": "sdk-compatible", "contract": "Plain query rows are rebound through owned normalized read/replace helpers before conditional invalidation of the deleted actor identity bindings.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_personal_credentials.py", - "functional_tests/test_action_credentials_bootstrap.py" + "functional_tests/test_action_credentials_bootstrap.py", + "functional_tests/test_action_personal_credentials.py" ] }, "application/single_app/functions_action_credential_state.py::pending": { "boundary": { - "batches": [], - "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c", + "sha256": "b475bdb558c62ec9453003be1b7f5b0fbef9bdc0bd72e7ba014be76231f6d3f9", "points": [], "queries": [ { @@ -8128,20 +8127,20 @@ "response": "consumed" } ], - "sha256": "b475bdb558c62ec9453003be1b7f5b0fbef9bdc0bd72e7ba014be76231f6d3f9" + "batches": [], + "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c" }, "classification": "sdk-compatible", "contract": "Partition-bound query rows are plain JSON, copied to dictionaries and reauthorized before safe request projection.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_personal_credentials.py", - "functional_tests/test_action_credentials_bootstrap.py" + "functional_tests/test_action_credentials_bootstrap.py", + "functional_tests/test_action_personal_credentials.py" ] }, "application/single_app/functions_action_credential_state.py::read": { "boundary": { - "batches": [], - "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c", + "sha256": "f56da19f655b3a5dea4dcfd360004f754a5d0ebd783cf877bab9af58c2949c29", "points": [ { "method": "read_item", @@ -8150,20 +8149,20 @@ } ], "queries": [], - "sha256": "f56da19f655b3a5dea4dcfd360004f754a5d0ebd783cf877bab9af58c2949c29" + "batches": [], + "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c" }, "classification": "normalized-strict", "contract": "Normalizes the SDK point response before record/expiry validation and strict request, binding and checkpoint consumers; retains actor ownership and ETags.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_personal_credentials.py", - "functional_tests/test_action_credentials_bootstrap.py" + "functional_tests/test_action_credentials_bootstrap.py", + "functional_tests/test_action_personal_credentials.py" ] }, "application/single_app/functions_action_credential_state.py::replace": { "boundary": { - "batches": [], - "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c", + "sha256": "8f5de29af218a33f1fc366aa5174fc44479e7d762be73e1248a113614507c9b9", "points": [ { "method": "replace_item", @@ -8172,20 +8171,20 @@ } ], "queries": [], - "sha256": "8f5de29af218a33f1fc366aa5174fc44479e7d762be73e1248a113614507c9b9" + "batches": [], + "module_sha256": "c07a22361be9feb149558f219a35d5f1acfbb51c5326fc3e00f10a561770da5c" }, "classification": "normalized-strict", "contract": "Normalizes the IfNotModified SDK replace response before strict request/binding/checkpoint consumers; preserves ETag conflicts and owned partition checks.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_personal_credentials.py", - "functional_tests/test_action_credentials_bootstrap.py" + "functional_tests/test_action_credentials_bootstrap.py", + "functional_tests/test_action_personal_credentials.py" ] }, "application/single_app/functions_activity_logging.py::_create_activity_record": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "5fa92ae61ade75abfcf12fb6e4217a86bcfcdafee5130cb26aa835ddc195bbaf", "points": [ { "method": "create_item", @@ -8199,7 +8198,8 @@ } ], "queries": [], - "sha256": "5fa92ae61ade75abfcf12fb6e4217a86bcfcdafee5130cb26aa835ddc195bbaf" + "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.", @@ -8210,8 +8210,7 @@ }, "application/single_app/functions_activity_logging.py::_log_agent_template_activity": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "064a2913eaeed0b13b289d431ed72d006237f8c785a59de545a274407e37fb77", "points": [ { "method": "create_item", @@ -8220,7 +8219,8 @@ } ], "queries": [], - "sha256": "064a2913eaeed0b13b289d431ed72d006237f8c785a59de545a274407e37fb77" + "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.", @@ -8229,8 +8229,7 @@ }, "application/single_app/functions_activity_logging.py::get_user_login_activity_summary": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "bda6607b4d6a540d7d953d7475a0a43216249a44972097138ea10bdeaf7b43a6", "points": [], "queries": [ { @@ -8244,7 +8243,8 @@ "response": "consumed" } ], - "sha256": "bda6607b4d6a540d7d953d7475a0a43216249a44972097138ea10bdeaf7b43a6" + "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.", @@ -8255,8 +8255,7 @@ }, "application/single_app/functions_activity_logging.py::has_user_accepted_agreement_today": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "bb99b5974cbcc9a36a6709afc8a7d83d08042184b35369e1252afd8aec577353", "points": [], "queries": [ { @@ -8265,7 +8264,8 @@ "response": "consumed" } ], - "sha256": "bb99b5974cbcc9a36a6709afc8a7d83d08042184b35369e1252afd8aec577353" + "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.", @@ -8276,8 +8276,7 @@ }, "application/single_app/functions_activity_logging.py::log_action_creation": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "f7509c3a12d75c2ff1bd08cbbf47d72e95ddfe58998b625ed4b0d9d76b9d27e4", "points": [ { "method": "create_item", @@ -8286,7 +8285,8 @@ } ], "queries": [], - "sha256": "f7509c3a12d75c2ff1bd08cbbf47d72e95ddfe58998b625ed4b0d9d76b9d27e4" + "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.", @@ -8295,8 +8295,7 @@ }, "application/single_app/functions_activity_logging.py::log_action_deletion": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "4d0bb19751c686a01c5d8f917d2fa9463e2d203c3e98c58a50f5f0a085243f2f", "points": [ { "method": "create_item", @@ -8305,7 +8304,8 @@ } ], "queries": [], - "sha256": "4d0bb19751c686a01c5d8f917d2fa9463e2d203c3e98c58a50f5f0a085243f2f" + "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.", @@ -8314,8 +8314,7 @@ }, "application/single_app/functions_activity_logging.py::log_action_update": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "5551a2a36a51eed0f49588c65a45ecfb0d3b2aabc775b3094de835b49a378c58", "points": [ { "method": "create_item", @@ -8324,7 +8323,8 @@ } ], "queries": [], - "sha256": "5551a2a36a51eed0f49588c65a45ecfb0d3b2aabc775b3094de835b49a378c58" + "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.", @@ -8333,8 +8333,7 @@ }, "application/single_app/functions_activity_logging.py::log_admin_feedback_email_submission": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "01a51c586b4ad56f5b572b7c1efba5661a26b0d0b329b0dfbcbb6d9c5c34efb4", "points": [ { "method": "create_item", @@ -8343,7 +8342,8 @@ } ], "queries": [], - "sha256": "01a51c586b4ad56f5b572b7c1efba5661a26b0d0b329b0dfbcbb6d9c5c34efb4" + "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.", @@ -8352,8 +8352,7 @@ }, "application/single_app/functions_activity_logging.py::log_admin_release_notifications_registration": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "1153617683df3b617615a6e471928502ba7a28c69ae4bc76bad0abf24da093d4", "points": [ { "method": "create_item", @@ -8362,7 +8361,8 @@ } ], "queries": [], - "sha256": "1153617683df3b617615a6e471928502ba7a28c69ae4bc76bad0abf24da093d4" + "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.", @@ -8371,8 +8371,7 @@ }, "application/single_app/functions_activity_logging.py::log_agent_creation": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "ece1631f9bbab9ef08c1767afa34ffeeaedbc5d9600b10179d0f0bb1eb493552", "points": [ { "method": "create_item", @@ -8381,7 +8380,8 @@ } ], "queries": [], - "sha256": "ece1631f9bbab9ef08c1767afa34ffeeaedbc5d9600b10179d0f0bb1eb493552" + "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.", @@ -8390,8 +8390,7 @@ }, "application/single_app/functions_activity_logging.py::log_agent_deletion": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "ad261ce51845333df17afb50b73f86a78b934bb1b9351f57b58736b775a99464", "points": [ { "method": "create_item", @@ -8400,7 +8399,8 @@ } ], "queries": [], - "sha256": "ad261ce51845333df17afb50b73f86a78b934bb1b9351f57b58736b775a99464" + "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.", @@ -8409,8 +8409,7 @@ }, "application/single_app/functions_activity_logging.py::log_agent_run": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "7c02f9d9e6e1fb82b4579d6e9fe218e5b8d7e8e312b4ae9488cb0e3a83bfdc5f", "points": [ { "method": "create_item", @@ -8419,7 +8418,8 @@ } ], "queries": [], - "sha256": "7c02f9d9e6e1fb82b4579d6e9fe218e5b8d7e8e312b4ae9488cb0e3a83bfdc5f" + "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.", @@ -8428,8 +8428,7 @@ }, "application/single_app/functions_activity_logging.py::log_agent_update": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "6aad74f57312a5559c8784fb563d4d8f7494b5ed1caa5da8fffc9707c2c05d95", "points": [ { "method": "create_item", @@ -8438,7 +8437,8 @@ } ], "queries": [], - "sha256": "6aad74f57312a5559c8784fb563d4d8f7494b5ed1caa5da8fffc9707c2c05d95" + "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.", @@ -8447,8 +8447,7 @@ }, "application/single_app/functions_activity_logging.py::log_chat_activity": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "418794b6666375c40c9fd6354ef8bb47e9b57f8dd0dd9527c4a74d268df2d611", "points": [ { "method": "create_item", @@ -8457,7 +8456,8 @@ } ], "queries": [], - "sha256": "418794b6666375c40c9fd6354ef8bb47e9b57f8dd0dd9527c4a74d268df2d611" + "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.", @@ -8466,8 +8466,7 @@ }, "application/single_app/functions_activity_logging.py::log_conversation_archival": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "418cb1b61e079e2e8ac58c4c68fb0c523b5afc023dcb7b833bb7f9081bd01d71", "points": [ { "method": "upsert_item", @@ -8476,7 +8475,8 @@ } ], "queries": [], - "sha256": "418cb1b61e079e2e8ac58c4c68fb0c523b5afc023dcb7b833bb7f9081bd01d71" + "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.", @@ -8485,8 +8485,7 @@ }, "application/single_app/functions_activity_logging.py::log_conversation_creation": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "a74f817a011cdcef8977b8624c961dbe92928c27939a6b78e9c2a9c21f4985fd", "points": [ { "method": "upsert_item", @@ -8495,7 +8494,8 @@ } ], "queries": [], - "sha256": "a74f817a011cdcef8977b8624c961dbe92928c27939a6b78e9c2a9c21f4985fd" + "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.", @@ -8504,8 +8504,7 @@ }, "application/single_app/functions_activity_logging.py::log_conversation_deletion": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "fd6bf4b4850c9da90e7aac3f682c8538cc6facd9e8b90548858f2177203e4477", "points": [ { "method": "upsert_item", @@ -8514,7 +8513,8 @@ } ], "queries": [], - "sha256": "fd6bf4b4850c9da90e7aac3f682c8538cc6facd9e8b90548858f2177203e4477" + "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.", @@ -8523,8 +8523,7 @@ }, "application/single_app/functions_activity_logging.py::log_document_deletion_transaction": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "50b62b92d002934bbe9af4856f2e6e110df1f313ed507f6d8448a918bfdc857e", "points": [ { "method": "create_item", @@ -8533,7 +8532,8 @@ } ], "queries": [], - "sha256": "50b62b92d002934bbe9af4856f2e6e110df1f313ed507f6d8448a918bfdc857e" + "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.", @@ -8542,8 +8542,7 @@ }, "application/single_app/functions_activity_logging.py::log_document_metadata_update_transaction": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "70cd109f60c39637c5de2292dc9f36b88bc58cc3e331dfbb11eff1ee5c7991b5", "points": [ { "method": "create_item", @@ -8552,7 +8551,8 @@ } ], "queries": [], - "sha256": "70cd109f60c39637c5de2292dc9f36b88bc58cc3e331dfbb11eff1ee5c7991b5" + "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.", @@ -8561,8 +8561,7 @@ }, "application/single_app/functions_activity_logging.py::log_file_sync_activity": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "211209999492109f1a26866ed38f6538ce0f957b6593955291164222116a25db", "points": [ { "method": "create_item", @@ -8571,7 +8570,8 @@ } ], "queries": [], - "sha256": "211209999492109f1a26866ed38f6538ce0f957b6593955291164222116a25db" + "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.", @@ -8580,8 +8580,7 @@ }, "application/single_app/functions_activity_logging.py::log_general_admin_action": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "4c8f035a0f99c6f7e9ee144bc984af87c67d7bd47bae97eafafd91361b45cea0", "points": [ { "method": "create_item", @@ -8590,7 +8589,8 @@ } ], "queries": [], - "sha256": "4c8f035a0f99c6f7e9ee144bc984af87c67d7bd47bae97eafafd91361b45cea0" + "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.", @@ -8599,8 +8599,7 @@ }, "application/single_app/functions_activity_logging.py::log_governance_change": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "62cd4f9f8b279eb1f0d861506ffbfa933027158d810955d734b7fb50d61848a7", "points": [ { "method": "create_item", @@ -8609,7 +8608,8 @@ } ], "queries": [], - "sha256": "62cd4f9f8b279eb1f0d861506ffbfa933027158d810955d734b7fb50d61848a7" + "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.", @@ -8618,8 +8618,7 @@ }, "application/single_app/functions_activity_logging.py::log_group_member_deleted": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "74635f98bfc4fcea754013d59b21970b32ba413e18db8aee26fb7a178d77a9f8", "points": [ { "method": "create_item", @@ -8628,7 +8627,8 @@ } ], "queries": [], - "sha256": "74635f98bfc4fcea754013d59b21970b32ba413e18db8aee26fb7a178d77a9f8" + "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.", @@ -8637,8 +8637,7 @@ }, "application/single_app/functions_activity_logging.py::log_group_status_change": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "9590ede98bdbf35417ffb1aa00947318682cfb1d67ad94cfc8944d419d9a9e9f", "points": [ { "method": "create_item", @@ -8647,7 +8646,8 @@ } ], "queries": [], - "sha256": "9590ede98bdbf35417ffb1aa00947318682cfb1d67ad94cfc8944d419d9a9e9f" + "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.", @@ -8656,8 +8656,7 @@ }, "application/single_app/functions_activity_logging.py::log_index_auto_fix": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "ba78c7f212b1c46f70f21ec76f4b551162a6f4e857a5da32df7d5a865b73e570", "points": [ { "method": "create_item", @@ -8666,7 +8665,8 @@ } ], "queries": [], - "sha256": "ba78c7f212b1c46f70f21ec76f4b551162a6f4e857a5da32df7d5a865b73e570" + "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.", @@ -8675,8 +8675,7 @@ }, "application/single_app/functions_activity_logging.py::log_public_workspace_status_change": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "5f6730fa511d00cc3b1f78ceddef9e962c2460c616404b2673e9123426b3911f", "points": [ { "method": "create_item", @@ -8685,7 +8684,8 @@ } ], "queries": [], - "sha256": "5f6730fa511d00cc3b1f78ceddef9e962c2460c616404b2673e9123426b3911f" + "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.", @@ -8694,8 +8694,7 @@ }, "application/single_app/functions_activity_logging.py::log_retention_policy_force_push": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "99487bf0657f926bd3591aa2d0c65285bafe3caf3fb18cf87d5f7c55b0cd66bd", "points": [ { "method": "create_item", @@ -8704,7 +8703,8 @@ } ], "queries": [], - "sha256": "99487bf0657f926bd3591aa2d0c65285bafe3caf3fb18cf87d5f7c55b0cd66bd" + "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.", @@ -8713,8 +8713,7 @@ }, "application/single_app/functions_activity_logging.py::log_terms_of_use_accepted": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "9d513d3ecfea9a53d0d3e0a267cd9e5d4070030c63ecfc536ee902fd3dac560f", "points": [ { "method": "create_item", @@ -8723,7 +8722,8 @@ } ], "queries": [], - "sha256": "9d513d3ecfea9a53d0d3e0a267cd9e5d4070030c63ecfc536ee902fd3dac560f" + "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.", @@ -8732,8 +8732,7 @@ }, "application/single_app/functions_activity_logging.py::log_terms_of_use_declined": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "70a89bf7cd9d23a50a32b297e275639504800e67cb61797df64030450c74d08e", "points": [ { "method": "create_item", @@ -8742,7 +8741,8 @@ } ], "queries": [], - "sha256": "70a89bf7cd9d23a50a32b297e275639504800e67cb61797df64030450c74d08e" + "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.", @@ -8751,8 +8751,7 @@ }, "application/single_app/functions_activity_logging.py::log_user_agreement_accepted": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "19de27d0d6a1d9d0ce516cb569a517cc88ceb238816a0ce16c5a9cf8d897c44b", "points": [ { "method": "create_item", @@ -8761,7 +8760,8 @@ } ], "queries": [], - "sha256": "19de27d0d6a1d9d0ce516cb569a517cc88ceb238816a0ce16c5a9cf8d897c44b" + "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.", @@ -8770,8 +8770,7 @@ }, "application/single_app/functions_activity_logging.py::log_user_login": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "d9343dd1deb514e24b360c991cee62ddb60cc5cb6a54d68cf269109bf14b70b7", "points": [ { "method": "create_item", @@ -8780,7 +8779,8 @@ } ], "queries": [], - "sha256": "d9343dd1deb514e24b360c991cee62ddb60cc5cb6a54d68cf269109bf14b70b7" + "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.", @@ -8789,8 +8789,7 @@ }, "application/single_app/functions_activity_logging.py::log_user_support_feedback_email_submission": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "9d6b753d72476feeb9435464956e314ff82e9b32c092414554b802f522d3770d", "points": [ { "method": "create_item", @@ -8799,7 +8798,8 @@ } ], "queries": [], - "sha256": "9d6b753d72476feeb9435464956e314ff82e9b32c092414554b802f522d3770d" + "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.", @@ -8808,8 +8808,7 @@ }, "application/single_app/functions_activity_logging.py::log_web_search_consent_acceptance": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "38c7b0d811a036c41aa3ec34707ab64b9956b6fbdfa4dd1cea5f7fd8b51bbef5", "points": [ { "method": "create_item", @@ -8818,7 +8817,8 @@ } ], "queries": [], - "sha256": "38c7b0d811a036c41aa3ec34707ab64b9956b6fbdfa4dd1cea5f7fd8b51bbef5" + "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.", @@ -8827,8 +8827,7 @@ }, "application/single_app/functions_activity_logging.py::log_workflow_creation": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "ce0748f41b0fa9b962dc858e544559c2e5d25969264276a0eaca176d8a7e235e", "points": [ { "method": "create_item", @@ -8837,7 +8836,8 @@ } ], "queries": [], - "sha256": "ce0748f41b0fa9b962dc858e544559c2e5d25969264276a0eaca176d8a7e235e" + "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.", @@ -8846,8 +8846,7 @@ }, "application/single_app/functions_activity_logging.py::log_workflow_deletion": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "ff317caa457224efa7cfe476e789f72f4c36b191cc6e0a1c7c5b28b0e22d6dca", "points": [ { "method": "create_item", @@ -8856,7 +8855,8 @@ } ], "queries": [], - "sha256": "ff317caa457224efa7cfe476e789f72f4c36b191cc6e0a1c7c5b28b0e22d6dca" + "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.", @@ -8865,8 +8865,7 @@ }, "application/single_app/functions_activity_logging.py::log_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "ad8356b5641fcd6a0c656a9789bbc56d5d388d6e1752a90ebb1ead7a215658a8", "points": [ { "method": "create_item", @@ -8875,7 +8874,8 @@ } ], "queries": [], - "sha256": "ad8356b5641fcd6a0c656a9789bbc56d5d388d6e1752a90ebb1ead7a215658a8" + "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.", @@ -8884,8 +8884,7 @@ }, "application/single_app/functions_activity_logging.py::log_workflow_update": { "boundary": { - "batches": [], - "module_sha256": "da1a1648098f0e7a3d1f4afeef6f028ed750f37830d795b6f301ec24e91d23d3", + "sha256": "80948206132be2c56d8f9ae1c462c5bcacd0e821ead3f975248b2bdaada06873", "points": [ { "method": "create_item", @@ -8894,7 +8893,8 @@ } ], "queries": [], - "sha256": "80948206132be2c56d8f9ae1c462c5bcacd0e821ead3f975248b2bdaada06873" + "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.", @@ -8903,8 +8903,7 @@ }, "application/single_app/functions_agent_catalog.py::_load_agent_usage_counts": { "boundary": { - "batches": [], - "module_sha256": "9678f137bd6af3c521cd0ca363a4530dce54ea4c5b6dc6e0ea29cf6b200aab25", + "sha256": "bae2950c9dc21db667dfdea85821650fae621e65cc669bb682ea42787379237d", "points": [], "queries": [ { @@ -8913,7 +8912,8 @@ "response": "consumed" } ], - "sha256": "bae2950c9dc21db667dfdea85821650fae621e65cc669bb682ea42787379237d" + "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.", @@ -8924,8 +8924,7 @@ }, "application/single_app/functions_agent_delegation.py::_list_records": { "boundary": { - "batches": [], - "module_sha256": "645b282bbc371329db329ec0d8abd53331ac0a652751e6e462fb040435a558e0", + "sha256": "cdb5cc89f851bc5315804dfbb05517071982e4b634dbd300dcce0200bdb5825c", "points": [], "queries": [ { @@ -8934,7 +8933,8 @@ "response": "consumed" } ], - "sha256": "cdb5cc89f851bc5315804dfbb05517071982e4b634dbd300dcce0200bdb5825c" + "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.", @@ -8945,8 +8945,7 @@ }, "application/single_app/functions_agent_delegation.py::_read_agent": { "boundary": { - "batches": [], - "module_sha256": "645b282bbc371329db329ec0d8abd53331ac0a652751e6e462fb040435a558e0", + "sha256": "806d2c2c3ed46ec36ce4dd5a2e8e81c8a979c8d81f7663c85dd1a7cf7a4962e8", "points": [ { "method": "read_item", @@ -8955,7 +8954,8 @@ } ], "queries": [], - "sha256": "806d2c2c3ed46ec36ce4dd5a2e8e81c8a979c8d81f7663c85dd1a7cf7a4962e8" + "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.", @@ -8966,8 +8966,7 @@ }, "application/single_app/functions_agent_delegation.py::update_agent_delegation_bindings": { "boundary": { - "batches": [], - "module_sha256": "645b282bbc371329db329ec0d8abd53331ac0a652751e6e462fb040435a558e0", + "sha256": "89fb1ac1f40caea22e8db416d1ad0beac93ef1bb1ea16b2322c077ddf10ace39", "points": [ { "method": "patch_item", @@ -8976,7 +8975,8 @@ } ], "queries": [], - "sha256": "89fb1ac1f40caea22e8db416d1ad0beac93ef1bb1ea16b2322c077ddf10ace39" + "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.", @@ -8985,8 +8985,7 @@ }, "application/single_app/functions_agent_templates.py::approve_agent_template": { "boundary": { - "batches": [], - "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf", + "sha256": "cfc7197efbeccd890654d7851f1bcb52f14e3987fefe6d1e466aea8ca928f9a0", "points": [ { "method": "upsert_item", @@ -8995,7 +8994,8 @@ } ], "queries": [], - "sha256": "cfc7197efbeccd890654d7851f1bcb52f14e3987fefe6d1e466aea8ca928f9a0" + "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.", @@ -9004,8 +9004,7 @@ }, "application/single_app/functions_agent_templates.py::create_agent_template": { "boundary": { - "batches": [], - "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf", + "sha256": "e18ca916cd75ff9403bd688a6a2842e23872022025637fad24125474880837ce", "points": [ { "method": "upsert_item", @@ -9014,7 +9013,8 @@ } ], "queries": [], - "sha256": "e18ca916cd75ff9403bd688a6a2842e23872022025637fad24125474880837ce" + "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.", @@ -9023,8 +9023,7 @@ }, "application/single_app/functions_agent_templates.py::delete_agent_template": { "boundary": { - "batches": [], - "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf", + "sha256": "fd966e009cdf9786a135116294e273533486a4f186b7014d7ed86284251f06fa", "points": [ { "method": "delete_item", @@ -9033,7 +9032,8 @@ } ], "queries": [], - "sha256": "fd966e009cdf9786a135116294e273533486a4f186b7014d7ed86284251f06fa" + "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.", @@ -9042,8 +9042,7 @@ }, "application/single_app/functions_agent_templates.py::get_agent_template": { "boundary": { - "batches": [], - "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf", + "sha256": "af4c8e63c0c57481c222e3989ccfa530180affa20177e57e68ca77c73f3c468e", "points": [ { "method": "read_item", @@ -9052,7 +9051,8 @@ } ], "queries": [], - "sha256": "af4c8e63c0c57481c222e3989ccfa530180affa20177e57e68ca77c73f3c468e" + "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.", @@ -9063,8 +9063,7 @@ }, "application/single_app/functions_agent_templates.py::list_agent_templates": { "boundary": { - "batches": [], - "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf", + "sha256": "ae2334b5c0589b308d082a1e1f2b9193d092c590e0d868b938b146e2e5a201ac", "points": [], "queries": [ { @@ -9073,7 +9072,8 @@ "response": "consumed" } ], - "sha256": "ae2334b5c0589b308d082a1e1f2b9193d092c590e0d868b938b146e2e5a201ac" + "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.", @@ -9084,8 +9084,7 @@ }, "application/single_app/functions_agent_templates.py::reject_agent_template": { "boundary": { - "batches": [], - "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf", + "sha256": "62de76d12a5e226e804e3485d5d4860f9c29aafd15e395ab7b4ce8a51d1c959b", "points": [ { "method": "upsert_item", @@ -9094,7 +9093,8 @@ } ], "queries": [], - "sha256": "62de76d12a5e226e804e3485d5d4860f9c29aafd15e395ab7b4ce8a51d1c959b" + "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.", @@ -9103,8 +9103,7 @@ }, "application/single_app/functions_agent_templates.py::update_agent_template": { "boundary": { - "batches": [], - "module_sha256": "ae10248e1f11b20f94342f01b6658dfc7b1af0eea3db3f4fa92c648386332faf", + "sha256": "7854fd3f17c229e9d5959bae8d9b6dd2c47db9f1bcda31a64b0b6b30b3ac1453", "points": [ { "method": "upsert_item", @@ -9113,7 +9112,8 @@ } ], "queries": [], - "sha256": "7854fd3f17c229e9d5959bae8d9b6dd2c47db9f1bcda31a64b0b6b30b3ac1453" + "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.", @@ -9122,8 +9122,7 @@ }, "application/single_app/functions_app_maintenance.py::_read_maintenance_state": { "boundary": { - "batches": [], - "module_sha256": "2130a2e4d854c54ecf3a2a977238b15bf82fc1f61e2f38c4e153dd5fb8575292", + "sha256": "d4270a918fbf1f6410e2be7e3ff0c1a9ac4a0d774f167c2cdf6abb8f6af77bc8", "points": [ { "method": "read_item", @@ -9132,7 +9131,8 @@ } ], "queries": [], - "sha256": "d4270a918fbf1f6410e2be7e3ff0c1a9ac4a0d774f167c2cdf6abb8f6af77bc8" + "batches": [], + "module_sha256": "2130a2e4d854c54ecf3a2a977238b15bf82fc1f61e2f38c4e153dd5fb8575292" }, "classification": "sdk-compatible", "contract": "Maintenance state point reads remain SDK CosmosDict mappings. Real owner runs retain run identity, nested step results and durable apply diagnostics across writes and read-only refreshes.", @@ -9143,8 +9143,7 @@ }, "application/single_app/functions_app_maintenance.py::_write_maintenance_state": { "boundary": { - "batches": [], - "module_sha256": "2130a2e4d854c54ecf3a2a977238b15bf82fc1f61e2f38c4e153dd5fb8575292", + "sha256": "0fc03da1b6f10943d827558424ea61781e7f74a4cb7ee66a679b835b19c4d89b", "points": [ { "method": "upsert_item", @@ -9153,7 +9152,8 @@ } ], "queries": [], - "sha256": "0fc03da1b6f10943d827558424ea61781e7f74a4cb7ee66a679b835b19c4d89b" + "batches": [], + "module_sha256": "2130a2e4d854c54ecf3a2a977238b15bf82fc1f61e2f38c4e153dd5fb8575292" }, "classification": "response-unused", "contract": "Maintenance state upsert responses are discarded; the constructed plain state dictionary is returned, and write errors propagate.", @@ -9164,8 +9164,7 @@ }, "application/single_app/functions_approvals.py::approve_request": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "6ff0ed48b581e0afa7176cd6e8e6d7855b7d856fe6da6fefbdfd7e076ad05a1c", "points": [ { "method": "read_item", @@ -9179,7 +9178,8 @@ } ], "queries": [], - "sha256": "6ff0ed48b581e0afa7176cd6e8e6d7855b7d856fe6da6fefbdfd7e076ad05a1c" + "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.", @@ -9190,8 +9190,7 @@ }, "application/single_app/functions_approvals.py::auto_deny_expired_approvals": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "d361e352eb4f02e117d7b693dcce03d4c5d8c520f3b0f7306a9cd28e09f6ad07", "points": [], "queries": [ { @@ -9200,7 +9199,8 @@ "response": "consumed" } ], - "sha256": "d361e352eb4f02e117d7b693dcce03d4c5d8c520f3b0f7306a9cd28e09f6ad07" + "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.", @@ -9211,8 +9211,7 @@ }, "application/single_app/functions_approvals.py::create_approval_request": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "2fb8626f9686447742b3d4e4f83dfa8f4ad3d421d8c5e12ff1666768645036bc", "points": [ { "method": "read_item", @@ -9226,7 +9225,8 @@ } ], "queries": [], - "sha256": "2fb8626f9686447742b3d4e4f83dfa8f4ad3d421d8c5e12ff1666768645036bc" + "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.", @@ -9237,8 +9237,7 @@ }, "application/single_app/functions_approvals.py::create_content_screening_approval": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "af564c4ea7852e2381468bb86854ceadadcf01d8ae7fa4b2267600816ce36f84", "points": [ { "method": "create_item", @@ -9252,7 +9251,8 @@ } ], "queries": [], - "sha256": "af564c4ea7852e2381468bb86854ceadadcf01d8ae7fa4b2267600816ce36f84" + "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.", @@ -9263,8 +9263,7 @@ }, "application/single_app/functions_approvals.py::deny_request": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "e267b913fe0d81f735f2835ab740efa0e37cbd97840fba0aa1119e299984c1f3", "points": [ { "method": "read_item", @@ -9278,7 +9277,8 @@ } ], "queries": [], - "sha256": "e267b913fe0d81f735f2835ab740efa0e37cbd97840fba0aa1119e299984c1f3" + "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.", @@ -9289,8 +9289,7 @@ }, "application/single_app/functions_approvals.py::get_approval_by_id": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "fd174ad502b79e10da257b235f4fe78e576d27bc59220a1122b60b4e6ad06458", "points": [ { "method": "read_item", @@ -9299,7 +9298,8 @@ } ], "queries": [], - "sha256": "fd174ad502b79e10da257b235f4fe78e576d27bc59220a1122b60b4e6ad06458" + "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.", @@ -9310,8 +9310,7 @@ }, "application/single_app/functions_approvals.py::get_pending_approvals": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "0926f7e86a2f632d4c56f9b38865bac1448b6d7b5374550ca7664bc3bac1894b", "points": [], "queries": [ { @@ -9320,7 +9319,8 @@ "response": "consumed" } ], - "sha256": "0926f7e86a2f632d4c56f9b38865bac1448b6d7b5374550ca7664bc3bac1894b" + "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.", @@ -9331,8 +9331,7 @@ }, "application/single_app/functions_approvals.py::mark_approval_executed": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "61c9fa792af2d74bcd477b90cff174d283d66f341fb94dd6bc96862eb7b9c7f8", "points": [ { "method": "read_item", @@ -9346,7 +9345,8 @@ } ], "queries": [], - "sha256": "61c9fa792af2d74bcd477b90cff174d283d66f341fb94dd6bc96862eb7b9c7f8" + "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.", @@ -9357,8 +9357,7 @@ }, "application/single_app/functions_approvals.py::resolve_content_screening_approval": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "f31f134c31cab43376b320f1dd6c74bb3cd3c103956eccb4885434c8897b07bc", "points": [ { "method": "read_item", @@ -9372,7 +9371,8 @@ } ], "queries": [], - "sha256": "f31f134c31cab43376b320f1dd6c74bb3cd3c103956eccb4885434c8897b07bc" + "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.", @@ -9383,8 +9383,7 @@ }, "application/single_app/functions_approvals.py::withdraw_approval_request": { "boundary": { - "batches": [], - "module_sha256": "dc22d2fe1dca2e9d712ec9a68382d5ded5c7caac0ff4991caabcd8f91e93f968", + "sha256": "fa8ec6484fffd0abcdbc5f4d51f2928cca4c627d47ada7b748c3b98df5a266c7", "points": [ { "method": "read_item", @@ -9403,7 +9402,8 @@ } ], "queries": [], - "sha256": "fa8ec6484fffd0abcdbc5f4d51f2928cca4c627d47ada7b748c3b98df5a266c7" + "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.", @@ -9414,8 +9414,7 @@ }, "application/single_app/functions_artifact_publication.py::_authorize_artifact": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "5719bffa176b3c26365f2f6105da071b77088d898e158b0c132c5273dbcd6c3b", "points": [ { "method": "read_item", @@ -9429,7 +9428,8 @@ } ], "queries": [], - "sha256": "5719bffa176b3c26365f2f6105da071b77088d898e158b0c132c5273dbcd6c3b" + "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.", @@ -9440,8 +9440,7 @@ }, "application/single_app/functions_artifact_publication.py::_decide_artifact_publication_with_content": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "ee71a54d40fee7288220587959506fa7d83ecbaaf6074368c9036732952daad2", "points": [ { "method": "read_item", @@ -9450,7 +9449,8 @@ } ], "queries": [], - "sha256": "ee71a54d40fee7288220587959506fa7d83ecbaaf6074368c9036732952daad2" + "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.", @@ -9461,8 +9461,7 @@ }, "application/single_app/functions_artifact_publication.py::_destination_document": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "610e561c365659a78180ec3aa9418740f20c12779e8c48b840c461d93c690ad5", "points": [ { "method": "read_item", @@ -9471,7 +9470,8 @@ } ], "queries": [], - "sha256": "610e561c365659a78180ec3aa9418740f20c12779e8c48b840c461d93c690ad5" + "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.", @@ -9482,8 +9482,7 @@ }, "application/single_app/functions_artifact_publication.py::_notification_exists": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "5869e8e8ba01518297e3d5e88b9a8cf816aeb3b09ebf1b3c14c09d4e45e990d0", "points": [], "queries": [ { @@ -9492,7 +9491,8 @@ "response": "consumed" } ], - "sha256": "5869e8e8ba01518297e3d5e88b9a8cf816aeb3b09ebf1b3c14c09d4e45e990d0" + "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.", @@ -9503,8 +9503,7 @@ }, "application/single_app/functions_artifact_publication.py::_receipt_change": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "a9c242d16faf07289edb76c44d0a18130bbdc5fe8eb54527b6f48176a496b170", "points": [ { "method": "read_item", @@ -9518,7 +9517,8 @@ } ], "queries": [], - "sha256": "a9c242d16faf07289edb76c44d0a18130bbdc5fe8eb54527b6f48176a496b170" + "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.", @@ -9529,8 +9529,7 @@ }, "application/single_app/functions_artifact_publication.py::_replace_publication_destination": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "3facb3956ed614bf624ce87a6ebf31ff5689ed76e9d78d3f0bd5c7526853a458", "points": [ { "method": "replace_item", @@ -9539,7 +9538,8 @@ } ], "queries": [], - "sha256": "3facb3956ed614bf624ce87a6ebf31ff5689ed76e9d78d3f0bd5c7526853a458" + "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.", @@ -9548,8 +9548,7 @@ }, "application/single_app/functions_artifact_publication.py::authorize_publication_status_read": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "3793a005eca85a5ce73fabe9b1fbc595fb716e78ec46de85741ebf4d0a1f8a75", "points": [ { "method": "read_item", @@ -9558,7 +9557,8 @@ } ], "queries": [], - "sha256": "3793a005eca85a5ce73fabe9b1fbc595fb716e78ec46de85741ebf4d0a1f8a75" + "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.", @@ -9569,8 +9569,7 @@ }, "application/single_app/functions_artifact_publication.py::enroll_legacy_artifact_publication": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "0ec2fb07f2a589e45843282f1f6894113b84a465227cc75cd0d79ca5ddcf9756", "points": [ { "method": "replace_item", @@ -9579,7 +9578,8 @@ } ], "queries": [], - "sha256": "0ec2fb07f2a589e45843282f1f6894113b84a465227cc75cd0d79ca5ddcf9756" + "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.", @@ -9590,8 +9590,7 @@ }, "application/single_app/functions_artifact_publication.py::read_artifact_publication_request": { "boundary": { - "batches": [], - "module_sha256": "cbd2173353205e618b1cd0169d3a7321f9b9ee72cacdf2bc0985e0c88d66649b", + "sha256": "5986fb92cd3f09a2591cdaa77b534d8881f3eef8d2c1945d694d3c6c7384e1b0", "points": [ { "method": "read_item", @@ -9600,7 +9599,8 @@ } ], "queries": [], - "sha256": "5986fb92cd3f09a2591cdaa77b534d8881f3eef8d2c1945d694d3c6c7384e1b0" + "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.", @@ -9611,8 +9611,7 @@ }, "application/single_app/functions_artifact_publication_readiness.py::_processing_change": { "boundary": { - "batches": [], - "module_sha256": "d1a482cdeeba15ff9fc408c8fffd8095bfaec64c51d4362b48e6dbe3d21eeb75", + "sha256": "c5d6e4320bd7775761dd791f9f55d12c0e6c741402af27e7ec262c99d3c553bd", "points": [ { "method": "read_item", @@ -9626,7 +9625,8 @@ } ], "queries": [], - "sha256": "c5d6e4320bd7775761dd791f9f55d12c0e6c741402af27e7ec262c99d3c553bd" + "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.", @@ -9657,15 +9657,14 @@ "classification": "sdk-compatible", "contract": "Scoped source queries consume plain query dictionaries, using DAI IDs only as candidate narrowing. Source selection still uses current source metadata, owner-qualified families and public projection; query failure raises the catalog error rather than returning an empty success.", "tests": [ - "functional_tests/test_v2_document_index_coverage.py::test_runtime_inventory_resolves_beyond_editor_window", - "functional_tests/test_v2_document_index_coverage.py::test_catalog_source_failure_is_not_empty_success" + "functional_tests/test_v2_document_index_coverage.py::test_catalog_source_failure_is_not_empty_success", + "functional_tests/test_v2_document_index_coverage.py::test_runtime_inventory_resolves_beyond_editor_window" ], "evidence_scope": "owner-runtime" }, "application/single_app/functions_chat_content_review.py::_clear_conversation_projection": { "boundary": { - "batches": [], - "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58", + "sha256": "4e30e4949334e4e6b84adf43440484dca2d5e3fb79c58b975968170d517cdce0", "points": [ { "method": "read_item", @@ -9679,7 +9678,8 @@ } ], "queries": [], - "sha256": "4e30e4949334e4e6b84adf43440484dca2d5e3fb79c58b975968170d517cdce0" + "batches": [], + "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58" }, "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.", @@ -9690,8 +9690,7 @@ }, "application/single_app/functions_chat_content_review.py::count_unchecked_chat_content": { "boundary": { - "batches": [], - "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58", + "sha256": "5ffe66db196286c6b5ad6b1156d9d7d1034d5a6d3fcb274c8140f6dddfa08194", "points": [], "queries": [ { @@ -9700,7 +9699,8 @@ "response": "consumed" } ], - "sha256": "5ffe66db196286c6b5ad6b1156d9d7d1034d5a6d3fcb274c8140f6dddfa08194" + "batches": [], + "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58" }, "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.", @@ -9711,8 +9711,7 @@ }, "application/single_app/functions_chat_content_review.py::persist_chat_reply": { "boundary": { - "batches": [], - "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58", + "sha256": "69754dde20720b25e3379003b04878aa335d3c1f345dff88d4799102d1679bc2", "points": [ { "method": "read_item", @@ -9736,7 +9735,8 @@ } ], "queries": [], - "sha256": "69754dde20720b25e3379003b04878aa335d3c1f345dff88d4799102d1679bc2" + "batches": [], + "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58" }, "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.", @@ -9747,8 +9747,7 @@ }, "application/single_app/functions_chat_content_review.py::propagate_chat_retraction": { "boundary": { - "batches": [], - "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58", + "sha256": "f9d6ab9ea38b46c8aa1fb7d80cd786ef03809174540fa7a89c65fb87a725a46f", "points": [ { "method": "replace_item", @@ -9773,7 +9772,8 @@ "response": "consumed" } ], - "sha256": "f9d6ab9ea38b46c8aa1fb7d80cd786ef03809174540fa7a89c65fb87a725a46f" + "batches": [], + "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58" }, "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.", @@ -9784,8 +9784,7 @@ }, "application/single_app/functions_chat_content_review.py::recheck_chat_message": { "boundary": { - "batches": [], - "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58", + "sha256": "dc330f66b8488a179f6ba9b2efb2981512e3213ea064c949254f6f59a0d23b7e", "points": [ { "method": "read_item", @@ -9804,7 +9803,8 @@ } ], "queries": [], - "sha256": "dc330f66b8488a179f6ba9b2efb2981512e3213ea064c949254f6f59a0d23b7e" + "batches": [], + "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58" }, "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.", @@ -9815,8 +9815,7 @@ }, "application/single_app/functions_chat_content_review.py::record_chat_content_incident": { "boundary": { - "batches": [], - "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58", + "sha256": "4350269f9235196eecfe8b286a9a27080f6354f4a30d4fdc42e067274ceed221", "points": [ { "method": "create_item", @@ -9825,7 +9824,8 @@ } ], "queries": [], - "sha256": "4350269f9235196eecfe8b286a9a27080f6354f4a30d4fdc42e067274ceed221" + "batches": [], + "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58" }, "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.", @@ -9834,8 +9834,7 @@ }, "application/single_app/functions_chat_content_review.py::refresh_checked_message": { "boundary": { - "batches": [], - "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58", + "sha256": "1d330973c1e3fe407dd8f87b48a03010e276844a9264612329f8b62920a1a3c4", "points": [ { "method": "read_item", @@ -9844,7 +9843,8 @@ } ], "queries": [], - "sha256": "1d330973c1e3fe407dd8f87b48a03010e276844a9264612329f8b62920a1a3c4" + "batches": [], + "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58" }, "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.", @@ -9855,8 +9855,7 @@ }, "application/single_app/functions_chat_content_review.py::retracted_stream_payload": { "boundary": { - "batches": [], - "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58", + "sha256": "3fcda556833af5c0f58dd44ff29127ee7fa203143fc6787cb50f5241764660d7", "points": [ { "method": "read_item", @@ -9865,7 +9864,8 @@ } ], "queries": [], - "sha256": "3fcda556833af5c0f58dd44ff29127ee7fa203143fc6787cb50f5241764660d7" + "batches": [], + "module_sha256": "8f927f3acc938d86289c7f70fd7fbeb8bae47f288bf26d5aa528ddc400ecde58" }, "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.", @@ -9876,8 +9876,7 @@ }, "application/single_app/functions_chat_message_metadata.py::patch_message_metadata": { "boundary": { - "batches": [], - "module_sha256": "b7a4ef66ad104ea9e69e48a6dd27ac36c41c77da286cfcaaba3c7ad88ddda0b4", + "sha256": "dfe08559e3f224b68702bee6fda2faac510e7c397e266f3cea938e563e16eb0b", "points": [ { "method": "read_item", @@ -9891,7 +9890,8 @@ } ], "queries": [], - "sha256": "dfe08559e3f224b68702bee6fda2faac510e7c397e266f3cea938e563e16eb0b" + "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.", @@ -9902,8 +9902,7 @@ }, "application/single_app/functions_chat_retry.py::_publish_retry_attempt": { "boundary": { - "batches": [], - "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0", + "sha256": "f390eea6e9384a64239f384046225facb7b30f8f7760e9c631b745b82d3f3383", "points": [ { "method": "read_item", @@ -9922,7 +9921,8 @@ } ], "queries": [], - "sha256": "f390eea6e9384a64239f384046225facb7b30f8f7760e9c631b745b82d3f3383" + "batches": [], + "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0" }, "classification": "sdk-compatible", "contract": "Conversation point mappings supply nested retry counters and ETags; deepcopy retains the SDK mapping for conditional replacement. Replace responses are discarded and the caller question is returned unchanged.", @@ -9933,8 +9933,7 @@ }, "application/single_app/functions_chat_retry.py::claim_retry_attempt": { "boundary": { - "batches": [], - "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0", + "sha256": "8c920b34063e7ddf57233d64c86b2043ba843e64e58c29428453dfa78c4fa8cd", "points": [ { "method": "read_item", @@ -9958,7 +9957,8 @@ } ], "queries": [], - "sha256": "8c920b34063e7ddf57233d64c86b2043ba843e64e58c29428453dfa78c4fa8cd" + "batches": [], + "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0" }, "classification": "sdk-compatible", "contract": "Partitioned question/source/conversation CosmosDict values are checked using fields and nested plain metadata. The original ETag guards replacement and its SDK mapping is returned without changing strict domain contracts.", @@ -9969,8 +9969,7 @@ }, "application/single_app/functions_chat_retry.py::load_owned_retry_message": { "boundary": { - "batches": [], - "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0", + "sha256": "4364cc6ee3f259dccf77ed56316d2bfd5335a7c1bef9bfee1d1a68a3623c46eb", "points": [ { "method": "read_item", @@ -9985,7 +9984,8 @@ "response": "consumed" } ], - "sha256": "4364cc6ee3f259dccf77ed56316d2bfd5335a7c1bef9bfee1d1a68a3623c46eb" + "batches": [], + "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0" }, "classification": "sdk-compatible", "contract": "Query rows remain plain messages; the partitioned conversation CosmosDict is checked through user_id/shared-backing fields and returned unchanged alongside the plain message.", @@ -9996,8 +9996,7 @@ }, "application/single_app/functions_chat_retry.py::prepare_retry_attempt": { "boundary": { - "batches": [], - "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0", + "sha256": "f3e2bd48ab37525f8a65eb11edfb8a2a7968725cc0d52e403e57f6f56e8e1303", "points": [ { "method": "read_item", @@ -10036,7 +10035,8 @@ } ], "queries": [], - "sha256": "f3e2bd48ab37525f8a65eb11edfb8a2a7968725cc0d52e403e57f6f56e8e1303" + "batches": [], + "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0" }, "classification": "sdk-compatible", "contract": "SDK message/conversation points supply identity, counters, source fingerprints and ETags. Conditional conversation writes discard responses; created or replayed question CosmosDict values return through mapping-compatible publication.", @@ -10047,8 +10047,7 @@ }, "application/single_app/functions_chat_retry.py::reconcile_prepared_retry": { "boundary": { - "batches": [], - "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0", + "sha256": "fcf34dc17264670c134057f7015f4dfb6ef19fc140721e1ca681b52fa36dc6e2", "points": [ { "method": "read_item", @@ -10057,7 +10056,8 @@ } ], "queries": [], - "sha256": "fcf34dc17264670c134057f7015f4dfb6ef19fc140721e1ca681b52fa36dc6e2" + "batches": [], + "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0" }, "classification": "sdk-compatible", "contract": "The source question CosmosDict is read through deletion/metadata/content fields for fingerprint comparison; publishing retains the current plain query-row question return shape.", @@ -10068,8 +10068,7 @@ }, "application/single_app/functions_chat_retry.py::retry_source_user": { "boundary": { - "batches": [], - "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0", + "sha256": "306917b7302e1e24d4e187f35a43993da176f3e4ff7b3d501781605a9c3c25e4", "points": [], "queries": [ { @@ -10078,7 +10077,8 @@ "response": "consumed" } ], - "sha256": "306917b7302e1e24d4e187f35a43993da176f3e4ff7b3d501781605a9c3c25e4" + "batches": [], + "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0" }, "classification": "sdk-compatible", "contract": "Partitioned question query rows remain plain dictionaries; nested metadata/thread fields select exactly one nondeleted attempt and the chosen plain row is returned.", @@ -10089,8 +10089,7 @@ }, "application/single_app/functions_chat_retry.py::retry_thread_messages": { "boundary": { - "batches": [], - "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0", + "sha256": "ad96d44d131dec6b6752736bcf2a8261ec9269657805bc6d9665e31b587b8029", "points": [], "queries": [ { @@ -10099,7 +10098,8 @@ "response": "consumed" } ], - "sha256": "ad96d44d131dec6b6752736bcf2a8261ec9269657805bc6d9665e31b587b8029" + "batches": [], + "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0" }, "classification": "sdk-compatible", "contract": "The partitioned thread query is materialized as a list of plain query dictionaries, separate from SDK point response mappings.", @@ -10110,8 +10110,7 @@ }, "application/single_app/functions_chat_retry.py::set_retry_attempt_state": { "boundary": { - "batches": [], - "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0", + "sha256": "c96ae0b730d13ae7b54fc362c424502f5411de761af8c78b20b33133826974e0", "points": [ { "method": "read_item", @@ -10125,7 +10124,8 @@ } ], "queries": [], - "sha256": "c96ae0b730d13ae7b54fc362c424502f5411de761af8c78b20b33133826974e0" + "batches": [], + "module_sha256": "138d88598971207603aa6a0b20589ea0e7eb6aece3da367d59f8bf5e7d0f96c0" }, "classification": "sdk-compatible", "contract": "The SDK question mapping is copied, its nested response-attempt state changed and its ETag used for conditional replace; the write response is discarded and the function returns None.", @@ -10136,8 +10136,7 @@ }, "application/single_app/functions_collaboration.py::_archive_collaboration_item": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "81a9ec1f7877ceacb49f8231426fcaba4468d5ce6c600351ce9e5a523a12f722", "points": [ { "method": "upsert_item", @@ -10146,7 +10145,8 @@ } ], "queries": [], - "sha256": "81a9ec1f7877ceacb49f8231426fcaba4468d5ce6c600351ce9e5a523a12f722" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10157,8 +10157,7 @@ }, "application/single_app/functions_collaboration.py::_bootstrap_collaboration_user_state_from_participant": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "243e59da83841fc656ce010fcbaf0e101fe58f0fa50152395cc0d502ab55772b", "points": [ { "method": "upsert_item", @@ -10167,7 +10166,8 @@ } ], "queries": [], - "sha256": "243e59da83841fc656ce010fcbaf0e101fe58f0fa50152395cc0d502ab55772b" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "classification": "response-unused", "contract": "Existing participant materialization discards write responses. The credential read-only path instead builds a transient state without either upsert; legacy accepted-group recovery checks the real state-store revision remains unchanged.", @@ -10179,8 +10179,7 @@ }, "application/single_app/functions_collaboration.py::_cleanup_linked_collaboration_source": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "f42aff0f85d0b4feefb96cbe06b6ff15377ecc7f6bd9a318401b85e862152cdb", "points": [], "queries": [ { @@ -10189,7 +10188,8 @@ "response": "consumed" } ], - "sha256": "f42aff0f85d0b4feefb96cbe06b6ff15377ecc7f6bd9a318401b85e862152cdb" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10200,8 +10200,7 @@ }, "application/single_app/functions_collaboration.py::_copy_legacy_group_messages_to_collaboration": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "2b02d0f1b9ebd63ca9dd9d31133208d1dad7545d405f66c29227791c16c154b8", "points": [ { "method": "upsert_item", @@ -10216,7 +10215,8 @@ "response": "consumed" } ], - "sha256": "2b02d0f1b9ebd63ca9dd9d31133208d1dad7545d405f66c29227791c16c154b8" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10227,8 +10227,7 @@ }, "application/single_app/functions_collaboration.py::_copy_legacy_personal_messages_to_collaboration": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "930b4ee260fe13406d205cd7e726f15a19c1efe47e5dd14f48fd76657eb73947", "points": [ { "method": "upsert_item", @@ -10243,7 +10242,8 @@ "response": "consumed" } ], - "sha256": "930b4ee260fe13406d205cd7e726f15a19c1efe47e5dd14f48fd76657eb73947" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10254,8 +10254,7 @@ }, "application/single_app/functions_collaboration.py::_delete_collaboration_conversation_records": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "d77fcd784b9320bd57f03d97b4f0e9c0154a150a16eed3a7d32d866363ac8a26", "points": [], "queries": [ { @@ -10269,7 +10268,8 @@ "response": "consumed" } ], - "sha256": "d77fcd784b9320bd57f03d97b4f0e9c0154a150a16eed3a7d32d866363ac8a26" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10280,8 +10280,7 @@ }, "application/single_app/functions_collaboration.py::_delete_item_if_present": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "922d805b6ddc6fd28a0f584c7fa86c33cc89481258fac94efb17dd856168f5ef", "points": [ { "method": "delete_item", @@ -10290,7 +10289,8 @@ } ], "queries": [], - "sha256": "922d805b6ddc6fd28a0f584c7fa86c33cc89481258fac94efb17dd856168f5ef" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10301,8 +10301,7 @@ }, "application/single_app/functions_collaboration.py::_get_collaboration_source_message": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "b82bfcf53198224843c2733e77b4d61cf941cfc7a92b71fefdf0a8975caf2d83", "points": [], "queries": [ { @@ -10311,7 +10310,8 @@ "response": "consumed" } ], - "sha256": "b82bfcf53198224843c2733e77b4d61cf941cfc7a92b71fefdf0a8975caf2d83" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10322,8 +10322,7 @@ }, "application/single_app/functions_collaboration.py::_persist_created_collaboration_conversation": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "f7a02148299a978a10f44b83180142c3b9bead6a995cda939f905c0c97a79702", "points": [ { "method": "upsert_item", @@ -10342,7 +10341,8 @@ } ], "queries": [], - "sha256": "f7a02148299a978a10f44b83180142c3b9bead6a995cda939f905c0c97a79702" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "classification": "sdk-compatible", "contract": "Deterministic conversation conflict reads retain SDK mappings for creator, scope and provenance checks; callers normalize at presentation boundaries.", @@ -10353,8 +10353,7 @@ }, "application/single_app/functions_collaboration.py::_read_linked_collaboration_source": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "e6c2b651fad21fbc95fb160130bd0fbdacc1ffb4ccd6b8a0a2940196c6f36a1c", "points": [ { "method": "read_item", @@ -10363,7 +10362,8 @@ } ], "queries": [], - "sha256": "e6c2b651fad21fbc95fb160130bd0fbdacc1ffb4ccd6b8a0a2940196c6f36a1c" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10374,8 +10374,7 @@ }, "application/single_app/functions_collaboration.py::_refresh_collaboration_conversation_message_summary": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "5d81bc4b52e77c0e1fa14f3050ee1d0ff8e3bddaa64d526ad4e84aee256b0a9e", "points": [ { "method": "upsert_item", @@ -10384,7 +10383,8 @@ } ], "queries": [], - "sha256": "5d81bc4b52e77c0e1fa14f3050ee1d0ff8e3bddaa64d526ad4e84aee256b0a9e" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10395,8 +10395,7 @@ }, "application/single_app/functions_collaboration.py::_save_collaboration_message_doc": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "a81e117416c952874391e9e7fb47e4d5c7d0e90c358a99895437072616745909", "points": [ { "method": "upsert_item", @@ -10410,7 +10409,8 @@ } ], "queries": [], - "sha256": "a81e117416c952874391e9e7fb47e4d5c7d0e90c358a99895437072616745909" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10421,8 +10421,7 @@ }, "application/single_app/functions_collaboration.py::create_personal_collaboration_conversation_record": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "dfd37c69945220a5f95b743f29d90a8ce576766fbd6cf1b8f08e53d2e4158cdb", "points": [ { "method": "upsert_item", @@ -10431,7 +10430,8 @@ } ], "queries": [], - "sha256": "dfd37c69945220a5f95b743f29d90a8ce576766fbd6cf1b8f08e53d2e4158cdb" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "classification": "response-unused", "contract": "Conversation and optional agent-assignment writes ignore SDK response values; deterministic conflict reads are owned by the reviewed persistence helper.", @@ -10442,8 +10442,7 @@ }, "application/single_app/functions_collaboration.py::delete_collaboration_message": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "33c10080f836879d8a797efe249f38232e275ec1496a17bd08ec2944753a53fa", "points": [ { "method": "delete_item", @@ -10452,7 +10451,8 @@ } ], "queries": [], - "sha256": "33c10080f836879d8a797efe249f38232e275ec1496a17bd08ec2944753a53fa" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10463,8 +10463,7 @@ }, "application/single_app/functions_collaboration.py::ensure_collaboration_source_conversation": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "e76cda2ca7d9c3eb98098876808931055af9e95f7f011e68a7bcf232ac5cf1d1", "points": [ { "method": "read_item", @@ -10493,7 +10492,8 @@ } ], "queries": [], - "sha256": "e76cda2ca7d9c3eb98098876808931055af9e95f7f011e68a7bcf232ac5cf1d1" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "classification": "sdk-compatible", "contract": "SDK point responses are inspected as mappings while deterministic safe backing creation preserves scope and ownership; publication normalizes returned records.", @@ -10504,8 +10504,7 @@ }, "application/single_app/functions_collaboration.py::ensure_collaboration_user_state_for_participant": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "904271bb717290fe6b248e9b101d8d40f973fa55371c6f44f186ec49adc50d88", "points": [ { "method": "upsert_item", @@ -10514,7 +10513,8 @@ } ], "queries": [], - "sha256": "904271bb717290fe6b248e9b101d8d40f973fa55371c6f44f186ec49adc50d88" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10525,8 +10525,7 @@ }, "application/single_app/functions_collaboration.py::ensure_group_collaboration_for_legacy_conversation": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "abd066096ace21b74533c074ad8e8ca4d9dd4166e86818d9eba247f2f65db925", "points": [ { "method": "read_item", @@ -10550,7 +10549,8 @@ } ], "queries": [], - "sha256": "abd066096ace21b74533c074ad8e8ca4d9dd4166e86818d9eba247f2f65db925" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10561,8 +10561,7 @@ }, "application/single_app/functions_collaboration.py::ensure_personal_collaboration_for_legacy_conversation": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "002aacd001365411ac0c47e248e4c5cc0592caad8b30f388450d4d1336417fba", "points": [ { "method": "read_item", @@ -10581,7 +10580,8 @@ } ], "queries": [], - "sha256": "002aacd001365411ac0c47e248e4c5cc0592caad8b30f388450d4d1336417fba" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10592,8 +10592,7 @@ }, "application/single_app/functions_collaboration.py::get_collaboration_conversation": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "866583a39854bcfa8102f3e571e757fa43c39f139c5e813f22362ea9672b3bf3", "points": [ { "method": "read_item", @@ -10602,7 +10601,8 @@ } ], "queries": [], - "sha256": "866583a39854bcfa8102f3e571e757fa43c39f139c5e813f22362ea9672b3bf3" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10613,8 +10613,7 @@ }, "application/single_app/functions_collaboration.py::get_collaboration_message": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "0c47f9a6ebf8f9cd0f1f49c93591c51d97569fa68435aff7cb86c3ab5e209e46", "points": [], "queries": [ { @@ -10623,7 +10622,8 @@ "response": "consumed" } ], - "sha256": "0c47f9a6ebf8f9cd0f1f49c93591c51d97569fa68435aff7cb86c3ab5e209e46" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10634,8 +10634,7 @@ }, "application/single_app/functions_collaboration.py::get_collaboration_message_by_source_message": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "bc1f7d59e8e75864743c71d20a733193b42dd6ce20233f789ac13d1057fd868d", "points": [], "queries": [ { @@ -10644,7 +10643,8 @@ "response": "consumed" } ], - "sha256": "bc1f7d59e8e75864743c71d20a733193b42dd6ce20233f789ac13d1057fd868d" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10655,8 +10655,7 @@ }, "application/single_app/functions_collaboration.py::get_collaboration_user_state": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "28086684a7cf53d5b0a1ef5c7fdfce7a4e66ca6fffae759c8a97de769d06b80b", "points": [ { "method": "read_item", @@ -10665,7 +10664,8 @@ } ], "queries": [], - "sha256": "28086684a7cf53d5b0a1ef5c7fdfce7a4e66ca6fffae759c8a97de769d06b80b" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10676,8 +10676,7 @@ }, "application/single_app/functions_collaboration.py::get_personal_collaboration_conversation_by_source_conversation": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "adff32b0374b47eccfd00eeddf676cae9a0afb351286d7f9673fe975287a963a", "points": [], "queries": [ { @@ -10686,7 +10685,8 @@ "response": "consumed" } ], - "sha256": "adff32b0374b47eccfd00eeddf676cae9a0afb351286d7f9673fe975287a963a" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10697,8 +10697,7 @@ }, "application/single_app/functions_collaboration.py::invite_personal_collaboration_participants": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "3db8744eda651c7584c75ca816992bcaee8569075530095484f23c0b66083118", "points": [ { "method": "upsert_item", @@ -10712,7 +10711,8 @@ } ], "queries": [], - "sha256": "3db8744eda651c7584c75ca816992bcaee8569075530095484f23c0b66083118" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10723,8 +10723,7 @@ }, "application/single_app/functions_collaboration.py::leave_personal_collaboration_conversation": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "6ddcf44088ac01bcdd7895db69c7a2af5527a30b1ac68b718838acf414d3a07f", "points": [ { "method": "upsert_item", @@ -10743,7 +10742,8 @@ } ], "queries": [], - "sha256": "6ddcf44088ac01bcdd7895db69c7a2af5527a30b1ac68b718838acf414d3a07f" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10754,8 +10754,7 @@ }, "application/single_app/functions_collaboration.py::list_collaboration_messages": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "f16cfa607f078cddd4df2a3e45e23cb204a2fed9c05cc10bd36b427c51103a56", "points": [], "queries": [ { @@ -10764,7 +10763,8 @@ "response": "consumed" } ], - "sha256": "f16cfa607f078cddd4df2a3e45e23cb204a2fed9c05cc10bd36b427c51103a56" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10775,8 +10775,7 @@ }, "application/single_app/functions_collaboration.py::list_group_collaboration_conversations_for_user": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "80fab44f5f25e2d3f721677035aff8dca59ac643528773f508c218688f8723a7", "points": [], "queries": [ { @@ -10790,7 +10789,8 @@ "response": "consumed" } ], - "sha256": "80fab44f5f25e2d3f721677035aff8dca59ac643528773f508c218688f8723a7" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10801,8 +10801,7 @@ }, "application/single_app/functions_collaboration.py::list_personal_collaboration_conversations_for_user": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "3f3ac6e1f3e60f09b023653aaa69cae0bbcf73f0f4f5776c60d32ae258fbc4a9", "points": [], "queries": [ { @@ -10811,7 +10810,8 @@ "response": "consumed" } ], - "sha256": "3f3ac6e1f3e60f09b023653aaa69cae0bbcf73f0f4f5776c60d32ae258fbc4a9" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10822,8 +10822,7 @@ }, "application/single_app/functions_collaboration.py::mirror_source_message_to_collaboration": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "b87fee77e61174ad161154bb749e5e82e7eb3ddd27881ff7851a1072e584ffc7", "points": [ { "method": "read_item", @@ -10832,7 +10831,8 @@ } ], "queries": [], - "sha256": "b87fee77e61174ad161154bb749e5e82e7eb3ddd27881ff7851a1072e584ffc7" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "classification": "sdk-compatible", "contract": "Deterministic result-message point reads validate source identity and repair summary after partial writes without duplicating messages or resetting user state.", @@ -10843,8 +10843,7 @@ }, "application/single_app/functions_collaboration.py::record_personal_invite_response": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "3380758094440f34831259d54f9c05f5da368142a4fdec77aae12c7005d6e0c6", "points": [ { "method": "upsert_item", @@ -10858,7 +10857,8 @@ } ], "queries": [], - "sha256": "3380758094440f34831259d54f9c05f5da368142a4fdec77aae12c7005d6e0c6" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10869,8 +10869,7 @@ }, "application/single_app/functions_collaboration.py::remove_personal_collaboration_member": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "5cbed7c3b1ff19787ba39e398bdd1ad5e5b89ad97ff5bc8f9bb3f36502abced5", "points": [ { "method": "upsert_item", @@ -10884,7 +10883,8 @@ } ], "queries": [], - "sha256": "5cbed7c3b1ff19787ba39e398bdd1ad5e5b89ad97ff5bc8f9bb3f36502abced5" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10895,8 +10895,7 @@ }, "application/single_app/functions_collaboration.py::sync_collaboration_conversation_metadata_from_source": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "e365dbfdcce9bedbba517cd376661c64191fb0ba4fbc23ed1564bb32fe5bece9", "points": [ { "method": "upsert_item", @@ -10905,7 +10904,8 @@ } ], "queries": [], - "sha256": "e365dbfdcce9bedbba517cd376661c64191fb0ba4fbc23ed1564bb32fe5bece9" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10916,8 +10916,7 @@ }, "application/single_app/functions_collaboration.py::toggle_personal_collaboration_hide": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "95a38cdcd42710990218e8b2676eabd2c6e81816e67ce229fa6971ba231e2cfe", "points": [ { "method": "upsert_item", @@ -10926,7 +10925,8 @@ } ], "queries": [], - "sha256": "95a38cdcd42710990218e8b2676eabd2c6e81816e67ce229fa6971ba231e2cfe" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10937,8 +10937,7 @@ }, "application/single_app/functions_collaboration.py::toggle_personal_collaboration_pin": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "45fb670b46ba303bc530b77085380a22aa6d96f8056722ec6b0b141e2ae45b7a", "points": [ { "method": "upsert_item", @@ -10947,7 +10946,8 @@ } ], "queries": [], - "sha256": "45fb670b46ba303bc530b77085380a22aa6d96f8056722ec6b0b141e2ae45b7a" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10958,8 +10958,7 @@ }, "application/single_app/functions_collaboration.py::update_personal_collaboration_member_role": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "6aae48795aa56b110a9eed86c6d392e8e9283105e688cb20cdf2365461c737f6", "points": [ { "method": "upsert_item", @@ -10973,7 +10972,8 @@ } ], "queries": [], - "sha256": "6aae48795aa56b110a9eed86c6d392e8e9283105e688cb20cdf2365461c737f6" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -10984,8 +10984,7 @@ }, "application/single_app/functions_collaboration.py::update_personal_collaboration_title": { "boundary": { - "batches": [], - "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64", + "sha256": "570233af974a971f1b05cb316faf6f5db852980661ec3b8f16a136999df7ba91", "points": [ { "method": "upsert_item", @@ -10994,7 +10993,8 @@ } ], "queries": [], - "sha256": "570233af974a971f1b05cb316faf6f5db852980661ec3b8f16a136999df7ba91" + "batches": [], + "module_sha256": "f5a3a8781c98ccb3124f28ebc916b0e884ee5067b445c029f771e35cf1c31a64" }, "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.", @@ -11005,8 +11005,7 @@ }, "application/single_app/functions_control_center.py::execute_control_center_refresh": { "boundary": { - "batches": [], - "module_sha256": "7a79c884556ed01b465e2566c774425a4683d198ea793099c7dfe64f1557ee0f", + "sha256": "d8caf75e602f3775b0ad1cd5aacbc3cbd8acd6156abe485cc7ac86634070ccc1", "points": [], "queries": [ { @@ -11020,7 +11019,8 @@ "response": "consumed" } ], - "sha256": "d8caf75e602f3775b0ad1cd5aacbc3cbd8acd6156abe485cc7ac86634070ccc1" + "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.", @@ -11031,8 +11031,7 @@ }, "application/single_app/functions_control_center_activity.py::query_activity_rows": { "boundary": { - "batches": [], - "module_sha256": "da5b3c6c30b9a262a0a798c1137d263854addb4ebe11dbd0875d7de37d8f982d", + "sha256": "73bae9411a3447423b5fd0101ea59fb4abe9d7bbc93f3a7cd185973b9f6d51fd", "points": [], "queries": [ { @@ -11041,7 +11040,8 @@ "response": "consumed" } ], - "sha256": "73bae9411a3447423b5fd0101ea59fb4abe9d7bbc93f3a7cd185973b9f6d51fd" + "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.", @@ -11052,8 +11052,7 @@ }, "application/single_app/functions_control_center_activity_display.py::_lookup": { "boundary": { - "batches": [], - "module_sha256": "5b3dd4420c82279a33a0a4b67d05857127f8da61e9dcce7b7432ce57c21f3ae9", + "sha256": "0c9f4ecff5338b6d35d2bd774f5c2b1ac59738d4a0b152838293b1b64aabf980", "points": [], "queries": [ { @@ -11062,7 +11061,8 @@ "response": "consumed" } ], - "sha256": "0c9f4ecff5338b6d35d2bd774f5c2b1ac59738d4a0b152838293b1b64aabf980" + "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.", @@ -11073,8 +11073,7 @@ }, "application/single_app/functions_control_center_activity_display.py::search_activity_people": { "boundary": { - "batches": [], - "module_sha256": "5b3dd4420c82279a33a0a4b67d05857127f8da61e9dcce7b7432ce57c21f3ae9", + "sha256": "6a220bb4f8ab27e5411d30c4bd4ce5b66a7b8762a8a1556b510cccbb900c703d", "points": [], "queries": [ { @@ -11083,7 +11082,8 @@ "response": "consumed" } ], - "sha256": "6a220bb4f8ab27e5411d30c4bd4ce5b66a7b8762a8a1556b510cccbb900c703d" + "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.", @@ -11094,8 +11094,7 @@ }, "application/single_app/functions_control_center_activity_display.py::search_activity_workspaces": { "boundary": { - "batches": [], - "module_sha256": "5b3dd4420c82279a33a0a4b67d05857127f8da61e9dcce7b7432ce57c21f3ae9", + "sha256": "7f9639ab8e28d246d2f6ba5c602ee455e5632ace045fd9236ac26500d88d0aa3", "points": [], "queries": [ { @@ -11104,7 +11103,8 @@ "response": "consumed" } ], - "sha256": "7f9639ab8e28d246d2f6ba5c602ee455e5632ace045fd9236ac26500d88d0aa3" + "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.", @@ -11115,8 +11115,7 @@ }, "application/single_app/functions_control_center_dashboard.py::_activity_rows": { "boundary": { - "batches": [], - "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a", + "sha256": "a8655e13c345829f02a6f442fa869b60bfe41367114ba2ac528d9db46d62b8ce", "points": [], "queries": [ { @@ -11125,7 +11124,8 @@ "response": "returned" } ], - "sha256": "a8655e13c345829f02a6f442fa869b60bfe41367114ba2ac528d9db46d62b8ce" + "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.", @@ -11136,8 +11136,7 @@ }, "application/single_app/functions_control_center_dashboard.py::aggregate_token_usage": { "boundary": { - "batches": [], - "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a", + "sha256": "db35d6287c013be62ac94b07517632aba190ee1756b31f3ae3902900a9df8a41", "points": [], "queries": [ { @@ -11146,7 +11145,8 @@ "response": "consumed" } ], - "sha256": "db35d6287c013be62ac94b07517632aba190ee1756b31f3ae3902900a9df8a41" + "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.", @@ -11157,8 +11157,7 @@ }, "application/single_app/functions_control_center_dashboard.py::count_active_users": { "boundary": { - "batches": [], - "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a", + "sha256": "b86af7cfafbe5d86283097a33215e20c47d19ececb127bb93c4e3da7e9f7f282", "points": [], "queries": [ { @@ -11167,7 +11166,8 @@ "response": "consumed" } ], - "sha256": "b86af7cfafbe5d86283097a33215e20c47d19ececb127bb93c4e3da7e9f7f282" + "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.", @@ -11178,8 +11178,7 @@ }, "application/single_app/functions_control_center_dashboard.py::find_entities": { "boundary": { - "batches": [], - "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a", + "sha256": "8b505be3272d17253639ec644888f7122169ae4cce8d67bbc8d045f4bf983398", "points": [], "queries": [ { @@ -11188,7 +11187,8 @@ "response": "consumed" } ], - "sha256": "8b505be3272d17253639ec644888f7122169ae4cce8d67bbc8d045f4bf983398" + "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.", @@ -11199,8 +11199,7 @@ }, "application/single_app/functions_control_center_dashboard.py::query_count": { "boundary": { - "batches": [], - "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a", + "sha256": "5e2b6d54da9233dd9265ddcbe0c60a4aadacd5b65ea0cfb8b77bf951525d1899", "points": [], "queries": [ { @@ -11209,7 +11208,8 @@ "response": "consumed" } ], - "sha256": "5e2b6d54da9233dd9265ddcbe0c60a4aadacd5b65ea0cfb8b77bf951525d1899" + "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.", @@ -11220,8 +11220,7 @@ }, "application/single_app/functions_control_center_dashboard.py::resolve_entity_names": { "boundary": { - "batches": [], - "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a", + "sha256": "c8f524d26bafd6c6b2885d349f22bb6e0d6f59e318675b290f13371a53b90c64", "points": [ { "method": "read_item", @@ -11230,7 +11229,8 @@ } ], "queries": [], - "sha256": "c8f524d26bafd6c6b2885d349f22bb6e0d6f59e318675b290f13371a53b90c64" + "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.", @@ -11241,8 +11241,7 @@ }, "application/single_app/functions_control_center_dashboard.py::status_rows": { "boundary": { - "batches": [], - "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a", + "sha256": "119b39edbe363ecdafa500d0f9c0f73f2426272acea903d67b0189d5a2b04bc7", "points": [], "queries": [ { @@ -11251,7 +11250,8 @@ "response": "consumed" } ], - "sha256": "119b39edbe363ecdafa500d0f9c0f73f2426272acea903d67b0189d5a2b04bc7" + "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.", @@ -11262,8 +11262,7 @@ }, "application/single_app/functions_control_center_dashboard.py::token_total": { "boundary": { - "batches": [], - "module_sha256": "b9ce851b63ccf1c58a758f0835ce505444b6b4a5122dc00eb5c45ffb8406b63a", + "sha256": "fac261d07016254a3e47d89a0579595be3c51cee2f430a3dd925e97394c57454", "points": [], "queries": [ { @@ -11272,7 +11271,8 @@ "response": "consumed" } ], - "sha256": "fac261d07016254a3e47d89a0579595be3c51cee2f430a3dd925e97394c57454" + "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.", @@ -11283,8 +11283,7 @@ }, "application/single_app/functions_control_center_groups.py::load_group_inventory": { "boundary": { - "batches": [], - "module_sha256": "eb5639bf4ed1cd12d049f6ef89393d4fa3e2ec8d4c72313bbfa717e2816b6859", + "sha256": "4ba8b911cb2bbce99265fc4537fdfb968c6ac39eb315a9936d6dd839dc51bef5", "points": [], "queries": [ { @@ -11308,7 +11307,8 @@ "response": "consumed" } ], - "sha256": "4ba8b911cb2bbce99265fc4537fdfb968c6ac39eb315a9936d6dd839dc51bef5" + "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.", @@ -11319,8 +11319,7 @@ }, "application/single_app/functions_control_center_public_workspaces.py::query_workspaces": { "boundary": { - "batches": [], - "module_sha256": "78a6ac31d53792c94dcce6108a0a38d7ff6fd4b0f330828c7a84e2f0be40ba20", + "sha256": "ec65c274f2fb229d898b500d814e1b7260f9a0f690f0059cfe58ac3435d3c55b", "points": [], "queries": [ { @@ -11334,7 +11333,8 @@ "response": "consumed" } ], - "sha256": "ec65c274f2fb229d898b500d814e1b7260f9a0f690f0059cfe58ac3435d3c55b" + "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.", @@ -11345,8 +11345,7 @@ }, "application/single_app/functions_control_center_public_workspaces.py::query_workspaces.count": { "boundary": { - "batches": [], - "module_sha256": "78a6ac31d53792c94dcce6108a0a38d7ff6fd4b0f330828c7a84e2f0be40ba20", + "sha256": "969aeca37363676fca053170f21a4a5bd349691fe384a69bf5036dc4e91d0720", "points": [], "queries": [ { @@ -11355,7 +11354,8 @@ "response": "consumed" } ], - "sha256": "969aeca37363676fca053170f21a4a5bd349691fe384a69bf5036dc4e91d0720" + "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.", @@ -11366,8 +11366,7 @@ }, "application/single_app/functions_control_center_public_workspaces.py::select_workspace_ids": { "boundary": { - "batches": [], - "module_sha256": "78a6ac31d53792c94dcce6108a0a38d7ff6fd4b0f330828c7a84e2f0be40ba20", + "sha256": "9e191a39e04da45e984790048eda45fd92202a185568efa9c1e7c195c9352499", "points": [], "queries": [ { @@ -11376,7 +11375,8 @@ "response": "consumed" } ], - "sha256": "9e191a39e04da45e984790048eda45fd92202a185568efa9c1e7c195c9352499" + "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.", @@ -11387,8 +11387,7 @@ }, "application/single_app/functions_conversation_handoff_generation.py::generate_handoff_turn": { "boundary": { - "batches": [], - "module_sha256": "a8a78d566ca2ac1a4adf154062062bd3c019ab7861ee67b29bba28d04ff92f28", + "sha256": "ba1a70eb2a7f4dfc3cb450b0142eb4b3c1dfcd3bd96d1e56bf53d7842549af3b", "points": [ { "method": "create_item", @@ -11402,7 +11401,8 @@ } ], "queries": [], - "sha256": "ba1a70eb2a7f4dfc3cb450b0142eb4b3c1dfcd3bd96d1e56bf53d7842549af3b" + "batches": [], + "module_sha256": "a8a78d566ca2ac1a4adf154062062bd3c019ab7861ee67b29bba28d04ff92f28" }, "classification": "normalized-strict", "contract": "Point reads and conditional create/replace writes are normalized with normalize_cosmos_document while retaining _etag for ETag-fenced queue, lease, and destination message persistence.", @@ -11413,8 +11413,7 @@ }, "application/single_app/functions_conversation_handoff_generation.py::handoff_completion_exists": { "boundary": { - "batches": [], - "module_sha256": "a8a78d566ca2ac1a4adf154062062bd3c019ab7861ee67b29bba28d04ff92f28", + "sha256": "7c0ff3f0b1aa6c551c64799f41a5385762b8621f1872ede8d4c1f68ca3c5ee73", "points": [ { "method": "read_item", @@ -11423,7 +11422,8 @@ } ], "queries": [], - "sha256": "7c0ff3f0b1aa6c551c64799f41a5385762b8621f1872ede8d4c1f68ca3c5ee73" + "batches": [], + "module_sha256": "a8a78d566ca2ac1a4adf154062062bd3c019ab7861ee67b29bba28d04ff92f28" }, "classification": "normalized-strict", "contract": "Point reads and conditional create/replace writes are normalized with normalize_cosmos_document while retaining _etag for ETag-fenced queue, lease, and destination message persistence.", @@ -11434,8 +11434,7 @@ }, "application/single_app/functions_conversation_handoff_generation.py::resolve_handoff_destination": { "boundary": { - "batches": [], - "module_sha256": "a8a78d566ca2ac1a4adf154062062bd3c019ab7861ee67b29bba28d04ff92f28", + "sha256": "4121ef7bbeaad01b8a63717f37e0c02a3e2b5f7eacbe6a65b26dcf70021b1289", "points": [], "queries": [ { @@ -11444,7 +11443,8 @@ "response": "consumed" } ], - "sha256": "4121ef7bbeaad01b8a63717f37e0c02a3e2b5f7eacbe6a65b26dcf70021b1289" + "batches": [], + "module_sha256": "a8a78d566ca2ac1a4adf154062062bd3c019ab7861ee67b29bba28d04ff92f28" }, "classification": "sdk-compatible", "contract": "Query rows are plain JSON dictionaries used for bounded handoff listing, destination model resolution, and queue dispatch.", @@ -11455,8 +11455,7 @@ }, "application/single_app/functions_conversation_handoff_runtime.py::dispatch_conversation_handoffs_once": { "boundary": { - "batches": [], - "module_sha256": "1a1cb09f277847f4e7567a3ea3efe317f20b07ada358aab3d8771b31530c3fc4", + "sha256": "4bc164fbabb272a1ac6549a8c06486fec88d055fc406141e0f57e25ee7b3252b", "points": [], "queries": [ { @@ -11465,7 +11464,8 @@ "response": "consumed" } ], - "sha256": "4bc164fbabb272a1ac6549a8c06486fec88d055fc406141e0f57e25ee7b3252b" + "batches": [], + "module_sha256": "1a1cb09f277847f4e7567a3ea3efe317f20b07ada358aab3d8771b31530c3fc4" }, "classification": "sdk-compatible", "contract": "Query rows are plain JSON dictionaries used for bounded handoff listing, destination model resolution, and queue dispatch.", @@ -11476,8 +11476,7 @@ }, "application/single_app/functions_conversation_handoffs.py::ConversationHandoffService.list": { "boundary": { - "batches": [], - "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254", + "sha256": "c44b02d735668e8d6283fbe27346e005a2c4d44ffce220a4b45148f114a849db", "points": [], "queries": [ { @@ -11486,7 +11485,8 @@ "response": "consumed" } ], - "sha256": "c44b02d735668e8d6283fbe27346e005a2c4d44ffce220a4b45148f114a849db" + "batches": [], + "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254" }, "classification": "sdk-compatible", "contract": "Query rows are plain JSON dictionaries used for bounded handoff listing, destination model resolution, and queue dispatch.", @@ -11497,8 +11497,7 @@ }, "application/single_app/functions_conversation_handoffs.py::ConversationHandoffStore.control": { "boundary": { - "batches": [], - "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254", + "sha256": "6945dbc2d03a32e54076815745e310efa869de876a2d3ac4d83fa30272e95480", "points": [ { "method": "create_item", @@ -11507,7 +11506,8 @@ } ], "queries": [], - "sha256": "6945dbc2d03a32e54076815745e310efa869de876a2d3ac4d83fa30272e95480" + "batches": [], + "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254" }, "classification": "normalized-strict", "contract": "Point reads and conditional create/replace writes are normalized with normalize_cosmos_document while retaining _etag for ETag-fenced queue, lease, and destination message persistence.", @@ -11518,6 +11518,9 @@ }, "application/single_app/functions_conversation_handoffs.py::ConversationHandoffStore.enqueue": { "boundary": { + "sha256": "4ff23b79afc62a51c43344855c4f880ce9002e6a9c4df721f57b3a5aa3921bd7", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -11525,10 +11528,7 @@ "response": "unused" } ], - "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254", - "points": [], - "queries": [], - "sha256": "4ff23b79afc62a51c43344855c4f880ce9002e6a9c4df721f57b3a5aa3921bd7" + "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254" }, "classification": "response-unused", "contract": "Transactional batch enqueue discards batch response list and reads back the committed handoff document through normalized point read.", @@ -11539,8 +11539,7 @@ }, "application/single_app/functions_conversation_handoffs.py::ConversationHandoffStore.read": { "boundary": { - "batches": [], - "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254", + "sha256": "487b5ab277cd79ef80c1677df7bb6afad894ffaa5dc363595e9f2c3f546b9c12", "points": [ { "method": "read_item", @@ -11549,7 +11548,8 @@ } ], "queries": [], - "sha256": "487b5ab277cd79ef80c1677df7bb6afad894ffaa5dc363595e9f2c3f546b9c12" + "batches": [], + "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254" }, "classification": "normalized-strict", "contract": "Point reads and conditional create/replace writes are normalized with normalize_cosmos_document while retaining _etag for ETag-fenced queue, lease, and destination message persistence.", @@ -11560,8 +11560,7 @@ }, "application/single_app/functions_conversation_handoffs.py::ConversationHandoffStore.replace": { "boundary": { - "batches": [], - "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254", + "sha256": "7cb19d08d44b8a9269f47c987ebbe321c02a6397c701a947b5233b26f896b769", "points": [ { "method": "replace_item", @@ -11570,7 +11569,8 @@ } ], "queries": [], - "sha256": "7cb19d08d44b8a9269f47c987ebbe321c02a6397c701a947b5233b26f896b769" + "batches": [], + "module_sha256": "e731826e7036c660dba78a79c3627273029eb41f32938f340289983ec5202254" }, "classification": "normalized-strict", "contract": "Point reads and conditional create/replace writes are normalized with normalize_cosmos_document while retaining _etag for ETag-fenced queue, lease, and destination message persistence.", @@ -11581,8 +11581,7 @@ }, "application/single_app/functions_conversation_metadata.py::_get_conversation_item_with_source": { "boundary": { - "batches": [], - "module_sha256": "9d06ea2e1bd4898240ef755876b12020a42f3baaec6a7fe636ea406ac72db171", + "sha256": "108b7ecf80baca15f5d66dbf1aa825c8b982dd9aced5d1ebdfff477dd09e5e0f", "points": [ { "method": "read_item", @@ -11591,7 +11590,8 @@ } ], "queries": [], - "sha256": "108b7ecf80baca15f5d66dbf1aa825c8b982dd9aced5d1ebdfff477dd09e5e0f" + "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.", @@ -11602,8 +11602,7 @@ }, "application/single_app/functions_conversation_metadata.py::get_user_info_by_id": { "boundary": { - "batches": [], - "module_sha256": "9d06ea2e1bd4898240ef755876b12020a42f3baaec6a7fe636ea406ac72db171", + "sha256": "7e82f787191a5d365a846d782a96038c2ed6faff7152b443f2ab07289acca780", "points": [ { "method": "read_item", @@ -11612,7 +11611,8 @@ } ], "queries": [], - "sha256": "7e82f787191a5d365a846d782a96038c2ed6faff7152b443f2ab07289acca780" + "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.", @@ -11623,8 +11623,7 @@ }, "application/single_app/functions_conversation_metadata.py::update_conversation_with_metadata": { "boundary": { - "batches": [], - "module_sha256": "9d06ea2e1bd4898240ef755876b12020a42f3baaec6a7fe636ea406ac72db171", + "sha256": "b87726d597d3c231d56f40eab20c58ef9b6aecdeb38b01e031c1383366b0a667", "points": [ { "method": "upsert_item", @@ -11638,7 +11637,8 @@ } ], "queries": [], - "sha256": "b87726d597d3c231d56f40eab20c58ef9b6aecdeb38b01e031c1383366b0a667" + "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.", @@ -11647,8 +11647,7 @@ }, "application/single_app/functions_conversation_references.py::ConversationReferenceService._messages": { "boundary": { - "batches": [], - "module_sha256": "68a441bdae011c5bd368917132bbbef6cbf6a126e7ecb3dd5455d76df877542c", + "sha256": "d13782f8e48bccf285bb59fc2e4287192665743f8f00b52e84094727495a9e15", "points": [], "queries": [ { @@ -11657,7 +11656,8 @@ "response": "consumed" } ], - "sha256": "d13782f8e48bccf285bb59fc2e4287192665743f8f00b52e84094727495a9e15" + "batches": [], + "module_sha256": "68a441bdae011c5bd368917132bbbef6cbf6a126e7ecb3dd5455d76df877542c" }, "classification": "sdk-compatible", "contract": "Query rows are plain JSON dictionaries filtered by partition and private ownership before visibility projection and lexical excerpt ranking.", @@ -11668,8 +11668,7 @@ }, "application/single_app/functions_conversation_references.py::ConversationReferenceService.authorize": { "boundary": { - "batches": [], - "module_sha256": "68a441bdae011c5bd368917132bbbef6cbf6a126e7ecb3dd5455d76df877542c", + "sha256": "df72d1ad5169f35f301c263e8d0240c5e3ea0f578ce71c840dc46efa5b07fe30", "points": [ { "method": "read_item", @@ -11678,7 +11677,8 @@ } ], "queries": [], - "sha256": "df72d1ad5169f35f301c263e8d0240c5e3ea0f578ce71c840dc46efa5b07fe30" + "batches": [], + "module_sha256": "68a441bdae011c5bd368917132bbbef6cbf6a126e7ecb3dd5455d76df877542c" }, "classification": "normalized-strict", "contract": "Conversation point reads are normalized with normalize_cosmos_document before ownership/privacy checks and revision digesting; ETags are preserved for concurrent source-change verification.", @@ -11689,8 +11689,7 @@ }, "application/single_app/functions_conversation_references.py::ConversationReferenceService.search": { "boundary": { - "batches": [], - "module_sha256": "68a441bdae011c5bd368917132bbbef6cbf6a126e7ecb3dd5455d76df877542c", + "sha256": "1db22136394ea058c2f5ddb569468c90fba5e8ae31dd03fe7215259049e3e371", "points": [], "queries": [ { @@ -11699,7 +11698,8 @@ "response": "consumed" } ], - "sha256": "1db22136394ea058c2f5ddb569468c90fba5e8ae31dd03fe7215259049e3e371" + "batches": [], + "module_sha256": "68a441bdae011c5bd368917132bbbef6cbf6a126e7ecb3dd5455d76df877542c" }, "classification": "sdk-compatible", "contract": "Query rows are plain JSON dictionaries filtered by partition and private ownership before visibility projection and lexical excerpt ranking.", @@ -11710,8 +11710,7 @@ }, "application/single_app/functions_conversation_unread.py::mark_conversation_unread_guarded": { "boundary": { - "batches": [], - "module_sha256": "c7921edaf1e71076cd3c28fe6c1514a210e30459fdc8e6e88027d4457c9cea99", + "sha256": "9a6a22e304b0f93a7ece564c1863f1b6bad2f0b539daa93058eded758c06e79b", "points": [ { "method": "read_item", @@ -11725,7 +11724,8 @@ } ], "queries": [], - "sha256": "9a6a22e304b0f93a7ece564c1863f1b6bad2f0b539daa93058eded758c06e79b" + "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.", @@ -11736,8 +11736,7 @@ }, "application/single_app/functions_cosmos_stale_cleanup.py::_query_stale_cache_cleanup_candidates": { "boundary": { - "batches": [], - "module_sha256": "445b30fe80983fc814fc8f9dee450c9fcbf5ba460e3d26615b2f18909ae0ac08", + "sha256": "8f9cbb27fdb8121e53e059d91c07bcac9861e5f88dcb989e640d8be3b099ee86", "points": [], "queries": [ { @@ -11746,7 +11745,8 @@ "response": "consumed" } ], - "sha256": "8f9cbb27fdb8121e53e059d91c07bcac9861e5f88dcb989e640d8be3b099ee86" + "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.", @@ -11757,8 +11757,7 @@ }, "application/single_app/functions_cosmos_stale_cleanup.py::run_stale_cache_document_cleanup": { "boundary": { - "batches": [], - "module_sha256": "445b30fe80983fc814fc8f9dee450c9fcbf5ba460e3d26615b2f18909ae0ac08", + "sha256": "576f70c3b5cb4a08a309a37509040c79abf1f058340f3d3ad152306dfbb96061", "points": [ { "method": "delete_item", @@ -11767,7 +11766,8 @@ } ], "queries": [], - "sha256": "576f70c3b5cb4a08a309a37509040c79abf1f058340f3d3ad152306dfbb96061" + "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.", @@ -11776,8 +11776,7 @@ }, "application/single_app/functions_custom_pages.py::_list_cosmos_custom_pages_source": { "boundary": { - "batches": [], - "module_sha256": "244e011c9c06f121e90f93ab4b92e7cc8a25b94bcdae369a9505887383f3d466", + "sha256": "96bea1b8ec1b985d279c627b3eab0042c1ceef18a193b8776a477baff34ab5c1", "points": [], "queries": [ { @@ -11786,7 +11785,8 @@ "response": "consumed" } ], - "sha256": "96bea1b8ec1b985d279c627b3eab0042c1ceef18a193b8776a477baff34ab5c1" + "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.", @@ -11797,8 +11797,7 @@ }, "application/single_app/functions_custom_pages.py::delete_custom_page": { "boundary": { - "batches": [], - "module_sha256": "244e011c9c06f121e90f93ab4b92e7cc8a25b94bcdae369a9505887383f3d466", + "sha256": "3bf47107b89033774e659dfcb87c8334c79eae3adb82eb7241f3e5d46e9d7841", "points": [ { "method": "delete_item", @@ -11807,7 +11806,8 @@ } ], "queries": [], - "sha256": "3bf47107b89033774e659dfcb87c8334c79eae3adb82eb7241f3e5d46e9d7841" + "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.", @@ -11816,8 +11816,7 @@ }, "application/single_app/functions_custom_pages.py::get_custom_page": { "boundary": { - "batches": [], - "module_sha256": "244e011c9c06f121e90f93ab4b92e7cc8a25b94bcdae369a9505887383f3d466", + "sha256": "075f565b6b1bce33d2d6e89284a4cf7453756b9156d5b39882fb81c4f246fed3", "points": [ { "method": "read_item", @@ -11826,7 +11825,8 @@ } ], "queries": [], - "sha256": "075f565b6b1bce33d2d6e89284a4cf7453756b9156d5b39882fb81c4f246fed3" + "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.", @@ -11837,8 +11837,7 @@ }, "application/single_app/functions_custom_pages.py::save_custom_page": { "boundary": { - "batches": [], - "module_sha256": "244e011c9c06f121e90f93ab4b92e7cc8a25b94bcdae369a9505887383f3d466", + "sha256": "91e8a4ab3f9b31dd9ceec8ee6d6b53e7adf1b38710847abcea363a41ccab74f4", "points": [ { "method": "upsert_item", @@ -11847,7 +11846,8 @@ } ], "queries": [], - "sha256": "91e8a4ab3f9b31dd9ceec8ee6d6b53e7adf1b38710847abcea363a41ccab74f4" + "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.", @@ -11858,8 +11858,7 @@ }, "application/single_app/functions_data_management.py::_acquire_backup_source_lock": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "1156f5023afd7cc69267d1f7718d9a9b72583b64f4e256206045e9023cba71ef", "points": [ { "method": "create_item", @@ -11873,7 +11872,8 @@ } ], "queries": [], - "sha256": "1156f5023afd7cc69267d1f7718d9a9b72583b64f4e256206045e9023cba71ef" + "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.", @@ -11882,8 +11882,7 @@ }, "application/single_app/functions_data_management.py::_acquire_migration_destination_lock": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "299274a63ac0020626e8f08a82cb0a12e8079724c3718d5adf1f90f9621eb09a", "points": [ { "method": "create_item", @@ -11897,7 +11896,8 @@ } ], "queries": [], - "sha256": "299274a63ac0020626e8f08a82cb0a12e8079724c3718d5adf1f90f9621eb09a" + "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.", @@ -11906,8 +11906,7 @@ }, "application/single_app/functions_data_management.py::_can_skip_unused_screening_container": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "e96117fdb98d7178acd9d3fcf1cfb908892d39a622f4215a7890e466893760ac", "points": [], "queries": [ { @@ -11916,7 +11915,8 @@ "response": "consumed" } ], - "sha256": "e96117fdb98d7178acd9d3fcf1cfb908892d39a622f4215a7890e466893760ac" + "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.", @@ -11927,8 +11927,7 @@ }, "application/single_app/functions_data_management.py::_count_documents_for_scope": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "50de559c56c361310d5322b8ce0eae56afd451a61d0b311c58d050c400575c00", "points": [], "queries": [ { @@ -11937,7 +11936,8 @@ "response": "consumed" } ], - "sha256": "50de559c56c361310d5322b8ce0eae56afd451a61d0b311c58d050c400575c00" + "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.", @@ -11948,8 +11948,7 @@ }, "application/single_app/functions_data_management.py::_count_migration_scope_documents": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "45df2674c1e38ff2022d816ea6b9443a9e54c2fd1d80efee1bafa81a86330256", "points": [], "queries": [ { @@ -11958,7 +11957,8 @@ "response": "consumed" } ], - "sha256": "45df2674c1e38ff2022d816ea6b9443a9e54c2fd1d80efee1bafa81a86330256" + "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.", @@ -11969,8 +11969,7 @@ }, "application/single_app/functions_data_management.py::_delete_backup_latest_item_states": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "889ed474f8cea7037e6a655f688e130eb1348c863a92691eddced6c72b015e97", "points": [ { "method": "delete_item", @@ -11985,7 +11984,8 @@ "response": "consumed" } ], - "sha256": "889ed474f8cea7037e6a655f688e130eb1348c863a92691eddced6c72b015e97" + "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.", @@ -11994,8 +11994,7 @@ }, "application/single_app/functions_data_management.py::_delete_data_management_job_items": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "8277843ecb2038d86fc93d326cf98867b0c01c7eb53c13ae0082132be6491267", "points": [ { "method": "delete_item", @@ -12010,7 +12009,8 @@ "response": "consumed" } ], - "sha256": "8277843ecb2038d86fc93d326cf98867b0c01c7eb53c13ae0082132be6491267" + "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.", @@ -12019,8 +12019,7 @@ }, "application/single_app/functions_data_management.py::_delete_data_management_job_record": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "3dc2be8aedaa0bb2e8dbeae52c07a8c1ba0a229f7b8038582dc12964afb2997f", "points": [ { "method": "delete_item", @@ -12029,7 +12028,8 @@ } ], "queries": [], - "sha256": "3dc2be8aedaa0bb2e8dbeae52c07a8c1ba0a229f7b8038582dc12964afb2997f" + "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.", @@ -12038,8 +12038,7 @@ }, "application/single_app/functions_data_management.py::_delete_target_cosmos_record": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "781c62d44e44210e46c311c94883691572bf9f269111b177d8a98a9f0a6e78e2", "points": [ { "method": "delete_item", @@ -12048,7 +12047,8 @@ } ], "queries": [], - "sha256": "781c62d44e44210e46c311c94883691572bf9f269111b177d8a98a9f0a6e78e2" + "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.", @@ -12057,8 +12057,7 @@ }, "application/single_app/functions_data_management.py::_execute_restore_cosmos_resources": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "b714b68b7302a6be058daaf49db0770ce54093c5d04c700fb09bef16067db516", "points": [ { "method": "create_item", @@ -12082,7 +12081,8 @@ } ], "queries": [], - "sha256": "b714b68b7302a6be058daaf49db0770ce54093c5d04c700fb09bef16067db516" + "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.", @@ -12091,8 +12091,7 @@ }, "application/single_app/functions_data_management.py::_get_backup_retention_candidates": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "cc00d86174ba4f9053b30d048f4d289cf4c9941efcd88b1383042a16789be8ab", "points": [], "queries": [ { @@ -12101,7 +12100,8 @@ "response": "consumed" } ], - "sha256": "cc00d86174ba4f9053b30d048f4d289cf4c9941efcd88b1383042a16789be8ab" + "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.", @@ -12112,8 +12112,7 @@ }, "application/single_app/functions_data_management.py::_get_completed_migration_baseline_candidates": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "d636563fbb9de29cd722e3ec0e452eea9615992bceba8aaa8c03973cceb60685", "points": [], "queries": [ { @@ -12122,7 +12121,8 @@ "response": "consumed" } ], - "sha256": "d636563fbb9de29cd722e3ec0e452eea9615992bceba8aaa8c03973cceb60685" + "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.", @@ -12133,8 +12133,7 @@ }, "application/single_app/functions_data_management.py::_get_latest_successful_full_backup_id": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "e8d3e2a2cd4b6e1444de26528721369d890a4dd324b9d70199f681192922db3e", "points": [], "queries": [ { @@ -12143,7 +12142,8 @@ "response": "consumed" } ], - "sha256": "e8d3e2a2cd4b6e1444de26528721369d890a4dd324b9d70199f681192922db3e" + "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.", @@ -12154,8 +12154,7 @@ }, "application/single_app/functions_data_management.py::_get_target_cosmos_document": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "5952597833a75301059e0dccb894ce2acb12fe380cb01bf932e0b0f59e6b46a4", "points": [ { "method": "read_item", @@ -12164,7 +12163,8 @@ } ], "queries": [], - "sha256": "5952597833a75301059e0dccb894ce2acb12fe380cb01bf932e0b0f59e6b46a4" + "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.", @@ -12175,8 +12175,7 @@ }, "application/single_app/functions_data_management.py::_iter_backup_cosmos_source_items": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "53a729a50c19515e34484503cc4c33da0a3a7eb608cb2a8be0b942c9fcc5cd8c", "points": [], "queries": [ { @@ -12185,7 +12184,8 @@ "response": "consumed" } ], - "sha256": "53a729a50c19515e34484503cc4c33da0a3a7eb608cb2a8be0b942c9fcc5cd8c" + "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.", @@ -12196,8 +12196,7 @@ }, "application/single_app/functions_data_management.py::_iter_backup_manifest_entries": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "6d36ccb0cb47684ecc2b67d25c56a23c0ce8eba85afda071e9ce51c58b264fc9", "points": [], "queries": [ { @@ -12206,7 +12205,8 @@ "response": "consumed" } ], - "sha256": "6d36ccb0cb47684ecc2b67d25c56a23c0ce8eba85afda071e9ce51c58b264fc9" + "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.", @@ -12217,8 +12217,7 @@ }, "application/single_app/functions_data_management.py::_iter_cosmos_container_items": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "0ed8aee4d69ff66892b314fd06679dfe83f2f7b65be94db5949e7122f22ed42f", "points": [], "queries": [ { @@ -12227,7 +12226,8 @@ "response": "consumed" } ], - "sha256": "0ed8aee4d69ff66892b314fd06679dfe83f2f7b65be94db5949e7122f22ed42f" + "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.", @@ -12238,8 +12238,7 @@ }, "application/single_app/functions_data_management.py::_iter_mirror_deletion_candidates": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "d82f49b371357ea9e0352016fa9651b2389835eee3556e70ddfd4e7628506613", "points": [], "queries": [ { @@ -12248,7 +12247,8 @@ "response": "consumed" } ], - "sha256": "d82f49b371357ea9e0352016fa9651b2389835eee3556e70ddfd4e7628506613" + "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.", @@ -12259,8 +12259,7 @@ }, "application/single_app/functions_data_management.py::_iter_selected_cosmos_records": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "2fa98318fb30b819166ac94434cdc5a69626ca14597eb330363c11e08ed41235", "points": [ { "method": "read_item", @@ -12280,7 +12279,8 @@ "response": "consumed" } ], - "sha256": "2fa98318fb30b819166ac94434cdc5a69626ca14597eb330363c11e08ed41235" + "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.", @@ -12291,8 +12291,7 @@ }, "application/single_app/functions_data_management.py::_iter_selected_screening_records": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "135582b4945c575838b7799b1ad217a4590da766e13076bf8a5f3216016de7e5", "points": [], "queries": [ { @@ -12301,7 +12300,8 @@ "response": "consumed" } ], - "sha256": "135582b4945c575838b7799b1ad217a4590da766e13076bf8a5f3216016de7e5" + "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.", @@ -12312,8 +12312,7 @@ }, "application/single_app/functions_data_management.py::_iter_target_cosmos_records": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "f2da1129ac4f0c455c369c8452c5da246cc55cae3dc9470b14a83a4fd8ec1a31", "points": [ { "method": "read_item", @@ -12333,7 +12332,8 @@ "response": "consumed" } ], - "sha256": "f2da1129ac4f0c455c369c8452c5da246cc55cae3dc9470b14a83a4fd8ec1a31" + "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.", @@ -12344,8 +12344,7 @@ }, "application/single_app/functions_data_management.py::_log_data_management_activity": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "b7e44093cc95b85b05d3bd3f9295f79613b9243ca093924afe970ec365509df7", "points": [ { "method": "create_item", @@ -12354,7 +12353,8 @@ } ], "queries": [], - "sha256": "b7e44093cc95b85b05d3bd3f9295f79613b9243ca093924afe970ec365509df7" + "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.", @@ -12363,8 +12363,7 @@ }, "application/single_app/functions_data_management.py::_preflight_target_cosmos_migration_access": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "b179e99653bdbc8b0d93ef5ef27638ddcc05eebbc6fc0338d3c26bf17568d5a9", "points": [], "queries": [ { @@ -12373,7 +12372,8 @@ "response": "consumed" } ], - "sha256": "b179e99653bdbc8b0d93ef5ef27638ddcc05eebbc6fc0338d3c26bf17568d5a9" + "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.", @@ -12384,8 +12384,7 @@ }, "application/single_app/functions_data_management.py::_query_data_management_history_items": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "2c75156094cb1eb33a7844e0b8ac4f174a2b62e15fde95ed7dc58e6a48706492", "points": [], "queries": [ { @@ -12394,7 +12393,8 @@ "response": "consumed" } ], - "sha256": "2c75156094cb1eb33a7844e0b8ac4f174a2b62e15fde95ed7dc58e6a48706492" + "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.", @@ -12405,8 +12405,7 @@ }, "application/single_app/functions_data_management.py::_query_migration_catalog_count": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "31db2d1049192891f1935e6fbfdef72fcec02c35dcaabadd8af5ff08ef0263ab", "points": [], "queries": [ { @@ -12415,7 +12414,8 @@ "response": "consumed" } ], - "sha256": "31db2d1049192891f1935e6fbfdef72fcec02c35dcaabadd8af5ff08ef0263ab" + "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.", @@ -12426,8 +12426,7 @@ }, "application/single_app/functions_data_management.py::_query_migration_catalog_page": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "06422e6ad296c14a49acd5f3456161134243c89edbdae7f4bfb709d10ccbe477", "points": [], "queries": [ { @@ -12436,7 +12435,8 @@ "response": "consumed" } ], - "sha256": "06422e6ad296c14a49acd5f3456161134243c89edbdae7f4bfb709d10ccbe477" + "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.", @@ -12447,8 +12447,7 @@ }, "application/single_app/functions_data_management.py::_read_backup_latest_item_state": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "635eaf0b2b1deaab051fd92811f7eeed77b163140b743042864eda9e9f9cf891", "points": [ { "method": "read_item", @@ -12457,7 +12456,8 @@ } ], "queries": [], - "sha256": "635eaf0b2b1deaab051fd92811f7eeed77b163140b743042864eda9e9f9cf891" + "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.", @@ -12468,8 +12468,7 @@ }, "application/single_app/functions_data_management.py::_read_data_management_migration_review_authorization": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "ddde2af5d9923fc184a09e1050126ee9b201cedd11432372450fa2c2f3cf3129", "points": [ { "method": "read_item", @@ -12478,7 +12477,8 @@ } ], "queries": [], - "sha256": "ddde2af5d9923fc184a09e1050126ee9b201cedd11432372450fa2c2f3cf3129" + "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.", @@ -12489,8 +12489,7 @@ }, "application/single_app/functions_data_management.py::_read_data_management_restore_review_authorization": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "2bc7eb15578af5daaa770ea4d8fbfa4c2f9e2aa8174c85f902cdd307255a3e0d", "points": [ { "method": "read_item", @@ -12499,7 +12498,8 @@ } ], "queries": [], - "sha256": "2bc7eb15578af5daaa770ea4d8fbfa4c2f9e2aa8174c85f902cdd307255a3e0d" + "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.", @@ -12510,8 +12510,7 @@ }, "application/single_app/functions_data_management.py::_read_job": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "2b581dd2f2d287c71774edb59900c0f9d8c5fbf323f530e5c0a4b3af0794c85e", "points": [ { "method": "read_item", @@ -12520,7 +12519,8 @@ } ], "queries": [], - "sha256": "2b581dd2f2d287c71774edb59900c0f9d8c5fbf323f530e5c0a4b3af0794c85e" + "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.", @@ -12531,8 +12531,7 @@ }, "application/single_app/functions_data_management.py::_record_backup_latest_item_state": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "9f42a9f36f33f2543272e99b01217d4c5d9a980fc5b0386956345ab19b050dea", "points": [ { "method": "upsert_item", @@ -12541,7 +12540,8 @@ } ], "queries": [], - "sha256": "9f42a9f36f33f2543272e99b01217d4c5d9a980fc5b0386956345ab19b050dea" + "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.", @@ -12552,8 +12552,7 @@ }, "application/single_app/functions_data_management.py::_record_backup_retention_cleanup_run": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "8fd38eb240db47293fe72f079c645cb17c6ab04dbb63fb343529fd7b94a8e3cf", "points": [ { "method": "upsert_item", @@ -12562,7 +12561,8 @@ } ], "queries": [], - "sha256": "8fd38eb240db47293fe72f079c645cb17c6ab04dbb63fb343529fd7b94a8e3cf" + "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.", @@ -12573,8 +12573,7 @@ }, "application/single_app/functions_data_management.py::_release_backup_source_lock": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "cfa10f2cedfaa89a00868f18d0216359c9a756563f9a2c7b3c8d215d082638c8", "points": [ { "method": "delete_item", @@ -12583,7 +12582,8 @@ } ], "queries": [], - "sha256": "cfa10f2cedfaa89a00868f18d0216359c9a756563f9a2c7b3c8d215d082638c8" + "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.", @@ -12592,8 +12592,7 @@ }, "application/single_app/functions_data_management.py::_release_migration_destination_lock": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "4209b88c551063d216198beb0a30ddd4d23bc140dfe22133cc45d812e0416d8a", "points": [ { "method": "delete_item", @@ -12602,7 +12601,8 @@ } ], "queries": [], - "sha256": "4209b88c551063d216198beb0a30ddd4d23bc140dfe22133cc45d812e0416d8a" + "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.", @@ -12611,8 +12611,7 @@ }, "application/single_app/functions_data_management.py::_renew_backup_source_lock": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "dfacc8e61875120bb7e6b7d5588972f38013e4ddc7081991f34f6371eb97913b", "points": [ { "method": "replace_item", @@ -12621,7 +12620,8 @@ } ], "queries": [], - "sha256": "dfacc8e61875120bb7e6b7d5588972f38013e4ddc7081991f34f6371eb97913b" + "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.", @@ -12632,8 +12632,7 @@ }, "application/single_app/functions_data_management.py::_renew_migration_destination_lock": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "6b3cfbdfc441ae263404480a9ff3563a0c7fb03f159cb9cf45e21118c3430b43", "points": [ { "method": "replace_item", @@ -12642,7 +12641,8 @@ } ], "queries": [], - "sha256": "6b3cfbdfc441ae263404480a9ff3563a0c7fb03f159cb9cf45e21118c3430b43" + "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.", @@ -12653,8 +12653,7 @@ }, "application/single_app/functions_data_management.py::_replace_job": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "e76a497989a82d4599637d065d2d664b4160549ed6c8f5550c4af3fc9c609617", "points": [ { "method": "replace_item", @@ -12663,7 +12662,8 @@ } ], "queries": [], - "sha256": "e76a497989a82d4599637d065d2d664b4160549ed6c8f5550c4af3fc9c609617" + "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.", @@ -12674,8 +12674,7 @@ }, "application/single_app/functions_data_management.py::_save_data_management_job": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "65c51b134236c83a4075237a5dad16bc66657372ec3ef2a4da36b7c368ae9ca7", "points": [ { "method": "replace_item", @@ -12689,7 +12688,8 @@ } ], "queries": [], - "sha256": "65c51b134236c83a4075237a5dad16bc66657372ec3ef2a4da36b7c368ae9ca7" + "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.", @@ -12700,8 +12700,7 @@ }, "application/single_app/functions_data_management.py::_source_blob_reference_exists_in_plan": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "53244c5892e56b7962b081f37c627c4a3058fb93a06cf1d7a959a1c81d45720d", "points": [], "queries": [ { @@ -12710,7 +12709,8 @@ "response": "consumed" } ], - "sha256": "53244c5892e56b7962b081f37c627c4a3058fb93a06cf1d7a959a1c81d45720d" + "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.", @@ -12721,8 +12721,7 @@ }, "application/single_app/functions_data_management.py::_source_cosmos_document_exists": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "356166331d45027946bd9094906b7b2d343b39083e6ef95af201ed8256bd314a", "points": [ { "method": "read_item", @@ -12731,7 +12730,8 @@ } ], "queries": [], - "sha256": "356166331d45027946bd9094906b7b2d343b39083e6ef95af201ed8256bd314a" + "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.", @@ -12740,8 +12740,7 @@ }, "application/single_app/functions_data_management.py::_source_cosmos_identity_exists": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "794a2fb15e890905bb13f43f0d8343905c8433f2fec473a3e0d4ff8cb5fe1a00", "points": [ { "method": "read_item", @@ -12750,7 +12749,8 @@ } ], "queries": [], - "sha256": "794a2fb15e890905bb13f43f0d8343905c8433f2fec473a3e0d4ff8cb5fe1a00" + "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.", @@ -12759,8 +12759,7 @@ }, "application/single_app/functions_data_management.py::_sync_backup_latest_item_state_from_manifest": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "8c81923fcae42d7d185f39394c532e3a89d704ec85ceb53ea51ffb2af1d98178", "points": [], "queries": [ { @@ -12769,7 +12768,8 @@ "response": "consumed" } ], - "sha256": "8c81923fcae42d7d185f39394c532e3a89d704ec85ceb53ea51ffb2af1d98178" + "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.", @@ -12780,8 +12780,7 @@ }, "application/single_app/functions_data_management.py::_target_cosmos_container_has_records": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "7c827945ce36b2ded7946406b2b03ab0ccd191ebe9e7137a1f00e9259d31fe1b", "points": [], "queries": [ { @@ -12790,7 +12789,8 @@ "response": "consumed" } ], - "sha256": "7c827945ce36b2ded7946406b2b03ab0ccd191ebe9e7137a1f00e9259d31fe1b" + "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.", @@ -12801,8 +12801,7 @@ }, "application/single_app/functions_data_management.py::_validate_mirror_deletion_candidate": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "73b4d035cb8fb3dd503d59be8b8fbb35a412877adfd67fac82a38419c036526f", "points": [ { "method": "read_item", @@ -12811,7 +12810,8 @@ } ], "queries": [], - "sha256": "73b4d035cb8fb3dd503d59be8b8fbb35a412877adfd67fac82a38419c036526f" + "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.", @@ -12822,8 +12822,7 @@ }, "application/single_app/functions_data_management.py::_verify_target_cosmos_container_access": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "7804d18a425bc8e407c02eb34c07260e12fabb835b4ccbe05712ec4f68dfb0ed", "points": [ { "method": "create_item", @@ -12842,7 +12841,8 @@ } ], "queries": [], - "sha256": "7804d18a425bc8e407c02eb34c07260e12fabb835b4ccbe05712ec4f68dfb0ed" + "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.", @@ -12851,8 +12851,7 @@ }, "application/single_app/functions_data_management.py::_write_backup_manifest_batch": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "fc9c2aed0977f161771b762fdde3ecd99ca32fce24f9484aa72a487a3d74f001", "points": [ { "method": "create_item", @@ -12861,7 +12860,8 @@ } ], "queries": [], - "sha256": "fc9c2aed0977f161771b762fdde3ecd99ca32fce24f9484aa72a487a3d74f001" + "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.", @@ -12872,8 +12872,7 @@ }, "application/single_app/functions_data_management.py::_write_cosmos_migration_record": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "54c827540111b7418e25b36c84c8e136e192cec58eb9056bf7f4f827c135436e", "points": [ { "method": "replace_item", @@ -12887,7 +12886,8 @@ } ], "queries": [], - "sha256": "54c827540111b7418e25b36c84c8e136e192cec58eb9056bf7f4f827c135436e" + "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.", @@ -12896,8 +12896,7 @@ }, "application/single_app/functions_data_management.py::_write_migration_manifest_batch": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "e22445ac2b74236524d03f99ade1081433d45a99a975c6dab157e2d4ffc7c48f", "points": [ { "method": "create_item", @@ -12906,7 +12905,8 @@ } ], "queries": [], - "sha256": "e22445ac2b74236524d03f99ade1081433d45a99a975c6dab157e2d4ffc7c48f" + "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.", @@ -12917,8 +12917,7 @@ }, "application/single_app/functions_data_management.py::_write_mirror_deletion_candidate_batch": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "a4d7e8bf307d8b4955b2c080d24b140600817620537e1c8599386d743d0ee7ac", "points": [ { "method": "create_item", @@ -12927,7 +12926,8 @@ } ], "queries": [], - "sha256": "a4d7e8bf307d8b4955b2c080d24b140600817620537e1c8599386d743d0ee7ac" + "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.", @@ -12938,8 +12938,7 @@ }, "application/single_app/functions_data_management.py::check_due_data_management_jobs_once": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "cf3be808a8de94c1cda12dee5e99fa85d9b4d61c5725ee2d0e270448f327a9dc", "points": [ { "method": "upsert_item", @@ -12948,7 +12947,8 @@ } ], "queries": [], - "sha256": "cf3be808a8de94c1cda12dee5e99fa85d9b4d61c5725ee2d0e270448f327a9dc" + "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.", @@ -12957,8 +12957,7 @@ }, "application/single_app/functions_data_management.py::consume_data_management_migration_review_authorization": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "b8845bf44b2ae5fde1c398ba4b250741ac40277ec14a7be6c07f9238d81f75fa", "points": [ { "method": "replace_item", @@ -12967,7 +12966,8 @@ } ], "queries": [], - "sha256": "b8845bf44b2ae5fde1c398ba4b250741ac40277ec14a7be6c07f9238d81f75fa" + "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.", @@ -12976,8 +12976,7 @@ }, "application/single_app/functions_data_management.py::consume_data_management_restore_review_authorization": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "d2fbe50ae2193666287cd5c3e055f052d059881c5a5a31dcd1f8562a3656879a", "points": [ { "method": "replace_item", @@ -12986,7 +12985,8 @@ } ], "queries": [], - "sha256": "d2fbe50ae2193666287cd5c3e055f052d059881c5a5a31dcd1f8562a3656879a" + "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.", @@ -12995,8 +12995,7 @@ }, "application/single_app/functions_data_management.py::create_data_management_job_item": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "80b4711fcb134c2cf37dedd100ee57f6eae6477261cc27088dfb7f61004a64b0", "points": [ { "method": "create_item", @@ -13005,7 +13004,8 @@ } ], "queries": [], - "sha256": "80b4711fcb134c2cf37dedd100ee57f6eae6477261cc27088dfb7f61004a64b0" + "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.", @@ -13016,8 +13016,7 @@ }, "application/single_app/functions_data_management.py::create_data_management_migration_review_authorization": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "83aab229f6cefb0d7ccc7d20d43bf993ac77920c2b42b6e2a6e3d4c788c9064d", "points": [ { "method": "create_item", @@ -13026,7 +13025,8 @@ } ], "queries": [], - "sha256": "83aab229f6cefb0d7ccc7d20d43bf993ac77920c2b42b6e2a6e3d4c788c9064d" + "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.", @@ -13037,8 +13037,7 @@ }, "application/single_app/functions_data_management.py::create_data_management_restore_review_authorization": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "344262a83ee347b301942441f02a4bd532b4a521fee3834e1a37dd2ecaca4c19", "points": [ { "method": "create_item", @@ -13047,7 +13046,8 @@ } ], "queries": [], - "sha256": "344262a83ee347b301942441f02a4bd532b4a521fee3834e1a37dd2ecaca4c19" + "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.", @@ -13058,8 +13058,7 @@ }, "application/single_app/functions_data_management.py::execute_backup_job": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "071880facfce8080ed983e8468d83f0e9efc4743ace35ef35e28c6aca10a6797", "points": [ { "method": "upsert_item", @@ -13068,7 +13067,8 @@ } ], "queries": [], - "sha256": "071880facfce8080ed983e8468d83f0e9efc4743ace35ef35e28c6aca10a6797" + "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.", @@ -13077,8 +13077,7 @@ }, "application/single_app/functions_data_management.py::generate_data_management_encryption_key": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "8ed68ebcc3bcd79c697c369d1b8bd1164823356fc7dddd81a5796f12607feeab", "points": [ { "method": "upsert_item", @@ -13087,7 +13086,8 @@ } ], "queries": [], - "sha256": "8ed68ebcc3bcd79c697c369d1b8bd1164823356fc7dddd81a5796f12607feeab" + "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.", @@ -13098,8 +13098,7 @@ }, "application/single_app/functions_data_management.py::get_data_management_cosmos_editor_document": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "5f4a015de1d86a9a2875b50f3d224c0c86d27a0029a8d64908a352db2fd91a2e", "points": [ { "method": "read_item", @@ -13108,7 +13107,8 @@ } ], "queries": [], - "sha256": "5f4a015de1d86a9a2875b50f3d224c0c86d27a0029a8d64908a352db2fd91a2e" + "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.", @@ -13119,8 +13119,7 @@ }, "application/single_app/functions_data_management.py::get_data_management_job_items": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "823b89d8fde5d636efcb149f42264a53a1bd830c33e9cb953b2bb5792b72d276", "points": [], "queries": [ { @@ -13129,7 +13128,8 @@ "response": "consumed" } ], - "sha256": "823b89d8fde5d636efcb149f42264a53a1bd830c33e9cb953b2bb5792b72d276" + "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.", @@ -13140,8 +13140,7 @@ }, "application/single_app/functions_data_management.py::get_data_management_settings": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "4af686e7bc36eb1b8650421e3069e0bebea7b313ad1fa04cdbefe478b7afcb03", "points": [ { "method": "read_item", @@ -13155,7 +13154,8 @@ } ], "queries": [], - "sha256": "4af686e7bc36eb1b8650421e3069e0bebea7b313ad1fa04cdbefe478b7afcb03" + "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.", @@ -13166,8 +13166,7 @@ }, "application/single_app/functions_data_management.py::get_recoverable_data_management_jobs": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "ac49ad705d6a1cca94028607b3ce516a773419361f4192a0d8a8a691c41e3d79", "points": [], "queries": [ { @@ -13176,7 +13175,8 @@ "response": "consumed" } ], - "sha256": "ac49ad705d6a1cca94028607b3ce516a773419361f4192a0d8a8a691c41e3d79" + "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.", @@ -13187,8 +13187,7 @@ }, "application/single_app/functions_data_management.py::iter_data_management_migration_manifest_entries": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "7ebe18fff20d8cfe3aa3641340ecdd33dc1ca3ae1c9d9d10a6d91bcfd2215bbf", "points": [], "queries": [ { @@ -13197,7 +13196,8 @@ "response": "consumed" } ], - "sha256": "7ebe18fff20d8cfe3aa3641340ecdd33dc1ca3ae1c9d9d10a6d91bcfd2215bbf" + "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.", @@ -13208,8 +13208,7 @@ }, "application/single_app/functions_data_management.py::log_data_management_cosmos_editor_activity": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "4c1b61f70a7cbb3dd410ca6ca31e7b93d9e8f8c67d3a4378a56c1a3693ec80a6", "points": [ { "method": "create_item", @@ -13218,7 +13217,8 @@ } ], "queries": [], - "sha256": "4c1b61f70a7cbb3dd410ca6ca31e7b93d9e8f8c67d3a4378a56c1a3693ec80a6" + "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.", @@ -13227,8 +13227,7 @@ }, "application/single_app/functions_data_management.py::query_data_management_cosmos_editor_documents": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "7fd0f0f087a69c9bc8abf14ee693b83039b2df70666c28d09a97ac17649c722b", "points": [], "queries": [ { @@ -13237,7 +13236,8 @@ "response": "consumed" } ], - "sha256": "7fd0f0f087a69c9bc8abf14ee693b83039b2df70666c28d09a97ac17649c722b" + "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.", @@ -13248,8 +13248,7 @@ }, "application/single_app/functions_data_management.py::queue_data_management_job": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "d91c461782433ba4acb19f9638930604eec90949283a5effe89467a4ca6b1ab9", "points": [ { "method": "create_item", @@ -13258,7 +13257,8 @@ } ], "queries": [], - "sha256": "d91c461782433ba4acb19f9638930604eec90949283a5effe89467a4ca6b1ab9" + "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.", @@ -13269,8 +13269,7 @@ }, "application/single_app/functions_data_management.py::release_data_management_migration_review_reservation": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "d0ae4d3171075d383d5b0cb26638b17aee5acd1f79d52d5541b4dc7fb16a783d", "points": [ { "method": "read_item", @@ -13284,7 +13283,8 @@ } ], "queries": [], - "sha256": "d0ae4d3171075d383d5b0cb26638b17aee5acd1f79d52d5541b4dc7fb16a783d" + "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.", @@ -13295,8 +13295,7 @@ }, "application/single_app/functions_data_management.py::release_data_management_restore_review_reservation": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "17e494bff0d2f822470ac56f18e2aa8a712d52bbaa058c4a71b6a5f8c6a4b1bd", "points": [ { "method": "read_item", @@ -13310,7 +13309,8 @@ } ], "queries": [], - "sha256": "17e494bff0d2f822470ac56f18e2aa8a712d52bbaa058c4a71b6a5f8c6a4b1bd" + "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.", @@ -13321,8 +13321,7 @@ }, "application/single_app/functions_data_management.py::reserve_data_management_migration_review_authorization": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "8e23aaef88d9a6137e58b91865d022631a786328d0331973e4fd5d9c1684df21", "points": [ { "method": "replace_item", @@ -13331,7 +13330,8 @@ } ], "queries": [], - "sha256": "8e23aaef88d9a6137e58b91865d022631a786328d0331973e4fd5d9c1684df21" + "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.", @@ -13340,8 +13340,7 @@ }, "application/single_app/functions_data_management.py::reserve_data_management_restore_review_authorization": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "3b5c80bef29e42f5a4a9644f2ff87ccd50497f8663f3bbe65a75cd877ea4b56b", "points": [ { "method": "replace_item", @@ -13350,7 +13349,8 @@ } ], "queries": [], - "sha256": "3b5c80bef29e42f5a4a9644f2ff87ccd50497f8663f3bbe65a75cd877ea4b56b" + "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.", @@ -13359,8 +13359,7 @@ }, "application/single_app/functions_data_management.py::resolve_data_management_migration_manifest_item": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "f4b05d857447554829f55fc52fb29240fff9df67cf656cd0eae08e4bf29475ab", "points": [], "queries": [ { @@ -13369,7 +13368,8 @@ "response": "consumed" } ], - "sha256": "f4b05d857447554829f55fc52fb29240fff9df67cf656cd0eae08e4bf29475ab" + "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.", @@ -13380,8 +13380,7 @@ }, "application/single_app/functions_data_management.py::save_data_management_cosmos_editor_document": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "587602962d41293d7d6299dad87478944bb9b05813e2dd942abea8703c138199", "points": [ { "method": "read_item", @@ -13395,7 +13394,8 @@ } ], "queries": [], - "sha256": "587602962d41293d7d6299dad87478944bb9b05813e2dd942abea8703c138199" + "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.", @@ -13406,8 +13406,7 @@ }, "application/single_app/functions_data_management.py::update_data_management_settings": { "boundary": { - "batches": [], - "module_sha256": "28d7434aeac092dac33cb7eefa9667b0055120c3407c03b86b053c43fc64207f", + "sha256": "0a05821ae275bc5a6fe68887a7c7a2f4dc8ca8a5c57d9f8fb708a2869fe757d2", "points": [ { "method": "upsert_item", @@ -13416,7 +13415,8 @@ } ], "queries": [], - "sha256": "0a05821ae275bc5a6fe68887a7c7a2f4dc8ca8a5c57d9f8fb708a2869fe757d2" + "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.", @@ -13427,8 +13427,7 @@ }, "application/single_app/functions_data_management_search_write_fence.py::_create_or_read_gate": { "boundary": { - "batches": [], - "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8", + "sha256": "f50ff429e07619dbd7a7096911c3958b755dcb9f8eb70b01db8aa9d9cf881a04", "points": [ { "method": "create_item", @@ -13437,7 +13436,8 @@ } ], "queries": [], - "sha256": "f50ff429e07619dbd7a7096911c3958b755dcb9f8eb70b01db8aa9d9cf881a04" + "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.", @@ -13448,8 +13448,7 @@ }, "application/single_app/functions_data_management_search_write_fence.py::_read_gate": { "boundary": { - "batches": [], - "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8", + "sha256": "3ef200cc300f5d740fd76e762e2c34323f0b37971ed423972647c738f537a234", "points": [ { "method": "read_item", @@ -13458,7 +13457,8 @@ } ], "queries": [], - "sha256": "3ef200cc300f5d740fd76e762e2c34323f0b37971ed423972647c738f537a234" + "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.", @@ -13469,8 +13469,7 @@ }, "application/single_app/functions_data_management_search_write_fence.py::_read_target_migration_coordinator": { "boundary": { - "batches": [], - "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8", + "sha256": "11a26ea7441237e83255ee4a10965210efe572236f3833e69b2fe1d627e8333a", "points": [ { "method": "read_item", @@ -13479,7 +13478,8 @@ } ], "queries": [], - "sha256": "11a26ea7441237e83255ee4a10965210efe572236f3833e69b2fe1d627e8333a" + "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.", @@ -13490,8 +13490,7 @@ }, "application/single_app/functions_data_management_search_write_fence.py::_replace_gate": { "boundary": { - "batches": [], - "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8", + "sha256": "9274f1b8d7578a0097e33f3dd32d28ddbf37cb2fadab58ef6c53864a39fc9544", "points": [ { "method": "replace_item", @@ -13500,7 +13499,8 @@ } ], "queries": [], - "sha256": "9274f1b8d7578a0097e33f3dd32d28ddbf37cb2fadab58ef6c53864a39fc9544" + "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.", @@ -13511,8 +13511,7 @@ }, "application/single_app/functions_data_management_search_write_fence.py::_replace_target_migration_coordinator": { "boundary": { - "batches": [], - "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8", + "sha256": "d5d8acd8ce4dd17eb62405ec3337da9637d273aa2371821676988b3bab9ce381", "points": [ { "method": "replace_item", @@ -13521,7 +13520,8 @@ } ], "queries": [], - "sha256": "d5d8acd8ce4dd17eb62405ec3337da9637d273aa2371821676988b3bab9ce381" + "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.", @@ -13532,8 +13532,7 @@ }, "application/single_app/functions_data_management_search_write_fence.py::acquire_data_management_target_migration_coordinator": { "boundary": { - "batches": [], - "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8", + "sha256": "23684c81874120629e13589240c2a717076f7ae9788de74ae7859263af768d8c", "points": [ { "method": "create_item", @@ -13542,7 +13541,8 @@ } ], "queries": [], - "sha256": "23684c81874120629e13589240c2a717076f7ae9788de74ae7859263af768d8c" + "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.", @@ -13553,8 +13553,7 @@ }, "application/single_app/functions_data_management_search_write_fence.py::release_data_management_target_migration_coordinator": { "boundary": { - "batches": [], - "module_sha256": "5b95ba9f75c5d47bbff823d3c88866e3794ffd32f35fb8a19ee0cf3ec3889ee8", + "sha256": "4d03da0f8b06a81d403edc9b4d6ba4740718f3778e08710e3239c3b0b37583e9", "points": [ { "method": "delete_item", @@ -13563,7 +13562,8 @@ } ], "queries": [], - "sha256": "4d03da0f8b06a81d403edc9b4d6ba4740718f3778e08710e3239c3b0b37583e9" + "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.", @@ -14103,8 +14103,7 @@ }, "application/single_app/functions_document_provenance.py::_read_conversation": { "boundary": { - "batches": [], - "module_sha256": "63e92c8afe6afb506cda20cc3c6b842bb0b58f93cd498cbd707ab26744c99abe", + "sha256": "d5ee19382f399f303fa7f372b09eda5613126561a76ec75c3c0354c44645a2c4", "points": [ { "method": "read_item", @@ -14113,7 +14112,8 @@ } ], "queries": [], - "sha256": "d5ee19382f399f303fa7f372b09eda5613126561a76ec75c3c0354c44645a2c4" + "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.", @@ -14140,8 +14140,8 @@ "contract": "DAI-unavailable discovery reads scoped metadata from the matching source container using supported non-aggregate SQL. Query rows are plain dictionaries; common current-revision, approved-access and search shaping precedes pagination. Returned page metadata is refreshed through the source-authority owner before safe public projection.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_v2_document_source_selection.py", - "functional_tests/test_v2_document_source_discovery_imports.py" + "functional_tests/test_v2_document_source_discovery_imports.py", + "functional_tests/test_v2_document_source_selection.py" ] }, "application/single_app/functions_document_source_discovery.py::source_catalog": { @@ -14162,8 +14162,8 @@ "contract": "Conversation ownership and scope-lock query rows are plain dictionaries. Only the authorized workspace identities are passed to the existing DAI read/cache owner or scoped source-container fallback; real configured discovery and DAI readiness execute with offline SDK-shaped point responses.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_v2_document_source_selection.py", - "functional_tests/test_v2_document_source_discovery_imports.py" + "functional_tests/test_v2_document_source_discovery_imports.py", + "functional_tests/test_v2_document_source_selection.py" ] }, "application/single_app/functions_documents.py::_complete_document_search_sync_pass": { @@ -14178,12 +14178,12 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", - "tests": [], - "evidence_scope": "source-review" + "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. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "source-review", + "tests": [] }, "application/single_app/functions_documents.py::_delete_document_search_sync_record": { "boundary": { @@ -14197,12 +14197,12 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", - "tests": [], - "evidence_scope": "source-review" + "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. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "source-review", + "tests": [] }, "application/single_app/functions_documents.py::_get_document_family_items_from_document": { "boundary": { @@ -14216,16 +14216,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::_process_document_upload_background_impl": { "boundary": { @@ -14244,18 +14244,18 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Bookkeeping review: final and partial counts use version/scoped Search keys plus acknowledged mutations; Cosmos activity-log points remain mapping consumers. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Bookkeeping review: final and partial counts use version/scoped Search keys plus acknowledged mutations; Cosmos activity-log points remain mapping consumers. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_document_chunk_bookkeeping.py::test_upload_finalizer_persists_actual_not_processor_estimated_count", "functional_tests/test_excel_document_accessibility_extraction.py::test_ingestion_modes_scopes_native_properties_and_chunk_identity", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::_query_current_xsd_documents": { "boundary": { @@ -14269,16 +14269,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::_read_document_for_search_sync": { "boundary": { @@ -14292,16 +14292,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::_read_document_search_sync_record": { "boundary": { @@ -14315,16 +14315,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::_rebase_document_after_fenced_acl_projection": { "boundary": { @@ -14338,16 +14338,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::_replace_document_search_sync_record": { "boundary": { @@ -14361,16 +14361,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::_upsert_document_and_sync_access_index": { "boundary": { @@ -14399,16 +14399,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::_workspace_file_name_exists": { "boundary": { @@ -14422,16 +14422,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::create_document": { "boundary": { @@ -14445,20 +14445,20 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "contract": "create_document: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::delete_document": { "boundary": { - "sha256": "080105834da852cd36f85bc6ca2aecac5fe7519a943cb16e35338ff2bcb3bd38", + "sha256": "e951293cdfee47a6801b4a31b9c6eb74edbf834e93ee1ea0917f43e49f2b4147", "points": [ { "method": "read_item", @@ -14493,16 +14493,15 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "contract": "Excel revision cleanup consumes installed-SDK CosmosDict point documents as mappings, checks owner/scope and ETag before native-artifact deletion, and preserves conditional document deletion. The real deletion owner is exercised for personal/group/public SDK responses and stale ETag failure; no strict top-level dict/JSON consumer was added.", + "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", - "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", - "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + "functional_tests/test_excel_document_delete_sdk_contract.py::test_real_delete_owner_handles_sdk_points_and_scope_bound_native_cleanup", + "functional_tests/test_excel_document_delete_sdk_contract.py::test_stale_sdk_etag_prevents_private_inventory_deletion" + ] }, "application/single_app/functions_documents.py::delete_document_revision": { "boundary": { @@ -14521,16 +14520,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::delete_from_blob_storage": { "boundary": { @@ -14544,16 +14543,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::detect_doc_type": { "boundary": { @@ -14577,16 +14576,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::extract_document_metadata": { "boundary": { @@ -14600,16 +14599,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "contract": "extract_document_metadata: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_chat_upload_workspace_documents_for_collaboration": { "boundary": { @@ -14623,16 +14622,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_chat_upload_workspace_documents_for_conversation": { "boundary": { @@ -14651,16 +14650,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_document_metadata": { "boundary": { @@ -14674,16 +14673,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "contract": "get_document_metadata: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_document_metadata_for_citations": { "boundary": { @@ -14697,16 +14696,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_document_record": { "boundary": { @@ -14720,16 +14719,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_document_version": { "boundary": { @@ -14743,16 +14742,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "contract": "get_document_version: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_document_versions": { "boundary": { @@ -14766,16 +14765,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_documents_shared_with_group": { "boundary": { @@ -14789,16 +14788,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_documents_shared_with_user": { "boundary": { @@ -14812,16 +14811,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_latest_version": { "boundary": { @@ -14835,16 +14834,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_shared_groups_for_document": { "boundary": { @@ -14858,16 +14857,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_shared_users_for_document": { "boundary": { @@ -14881,16 +14880,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::get_workspace_tags": { "boundary": { @@ -14904,16 +14903,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "contract": "get_workspace_tags: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::is_document_shared_with_group": { "boundary": { @@ -14927,16 +14926,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::is_document_shared_with_user": { "boundary": { @@ -14950,16 +14949,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::process_due_document_search_metadata_syncs": { "boundary": { @@ -14973,16 +14972,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::propagate_tags_to_blob_metadata": { "boundary": { @@ -14996,16 +14995,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::queue_group_workspace_upload_from_temp_file": { "boundary": { @@ -15019,12 +15018,12 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", - "tests": [], - "evidence_scope": "source-review" + "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. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "source-review", + "tests": [] }, "application/single_app/functions_documents.py::queue_personal_workspace_upload_from_temp_file": { "boundary": { @@ -15038,12 +15037,12 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", - "tests": [], - "evidence_scope": "source-review" + "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. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "source-review", + "tests": [] }, "application/single_app/functions_documents.py::request_document_search_metadata_sync": { "boundary": { @@ -15057,16 +15056,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::share_document_with_group": { "boundary": { @@ -15080,16 +15079,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::share_document_with_user": { "boundary": { @@ -15103,16 +15102,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::sync_chat_upload_workspace_attachment_status": { "boundary": { @@ -15131,16 +15130,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::unshare_document_from_group": { "boundary": { @@ -15154,16 +15153,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::unshare_document_from_user": { "boundary": { @@ -15177,16 +15176,16 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::update_document": { "boundary": { @@ -15200,10 +15199,11 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "classification": "sdk-compatible", - "contract": "Workspace-scoped query rows are plain dictionaries. Status predicates only interpret strings; filenames cannot force success/failure or rewrite screening copy. Strict update returns the SDK saved mapping to mapping-compatible callers; read/write ETags, operation guards, access projection and screening holds are preserved. Runtime evidence exercises personal/group/public status writes with installed-SDK point responses and plain query rows. Bookkeeping review: only an exact legacy metadata warning is retired after a successful outcome; that transition uses the existing ETag-conditional storage helper. SDK mappings, query rows, scope and concurrent-state checks remain intact. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "contract": "Workspace-scoped query rows are plain dictionaries. Status predicates only interpret strings; filenames cannot force success/failure or rewrite screening copy. Strict update returns the SDK saved mapping to mapping-compatible callers; read/write ETags, operation guards, access projection and screening holds are preserved. Runtime evidence exercises personal/group/public status writes with installed-SDK point responses and plain query rows. Bookkeeping review: only an exact legacy metadata warning is retired after a successful outcome; that transition uses the existing ETag-conditional storage helper. SDK mappings, query rows, scope and concurrent-state checks remain intact. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", @@ -15211,8 +15211,7 @@ "functional_tests/test_document_search_metadata_sync.py::test_status_update_cannot_write_after_its_operation_guard_expires", "functional_tests/test_document_search_metadata_sync.py::test_status_updates_preserve_sdk_points_etags_and_query_rows", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::upgrade_legacy_documents": { "boundary": { @@ -15226,16 +15225,16 @@ } ], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "contract": "upgrade_legacy_documents: query rows/pages are plain JSON, not Cosmos point wrappers. Nested domain shape checks therefore need no point-response repair. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_documents.py::upload_to_blob": { "boundary": { @@ -15249,21 +15248,20 @@ ], "queries": [], "batches": [], - "module_sha256": "5b81e665780da736d45ec873cef018d3f73cec8dff2191718391137bacc79593" + "module_sha256": "e0262c638d3292404adcaa48086ceef5fb0b1d9fdf35dcb36a0bc80f3859e940" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained.", + "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_content_screening_upload_only_intake.py::test_model_generated_metadata_applies_without_a_hold", "functional_tests/test_document_chunk_bookkeeping.py::test_sdk_conditional_warning_cleanup", "functional_tests/test_workspace_metadata_outcomes.py::test_upload_dispatcher_preserves_ready_content_after_metadata_failure" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/functions_embedding_compatibility.py::inspect_empty_embedding_stores": { "boundary": { - "batches": [], - "module_sha256": "71fe1b8f5e3e548be9f057d959b28b2f985430f6da03bc3e68837c95748ca790", + "sha256": "f5bff887c0e375421b000aa9992db31519d14f16628e35f050354c6528e9266a", "points": [], "queries": [ { @@ -15272,7 +15270,8 @@ "response": "consumed" } ], - "sha256": "f5bff887c0e375421b000aa9992db31519d14f16628e35f050354c6528e9266a" + "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.", @@ -15283,8 +15282,7 @@ }, "application/single_app/functions_embedding_compatibility.py::persist_fact_with_embedding": { "boundary": { - "batches": [], - "module_sha256": "71fe1b8f5e3e548be9f057d959b28b2f985430f6da03bc3e68837c95748ca790", + "sha256": "5f84ef0e7495641ff891d7a5daea698a8cd6c7e06e6bc6993d27a51883cbeb84", "points": [ { "method": "upsert_item", @@ -15293,7 +15291,8 @@ } ], "queries": [], - "sha256": "5f84ef0e7495641ff891d7a5daea698a8cd6c7e06e6bc6993d27a51883cbeb84" + "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.", @@ -15304,8 +15303,7 @@ }, "application/single_app/functions_file_sync.py::_count_active_runs": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "0a002574af668bb25fe75c28165774524a298e1033fa651987f1ca0cbddd9e61", "points": [], "queries": [ { @@ -15314,7 +15312,8 @@ "response": "consumed" } ], - "sha256": "0a002574af668bb25fe75c28165774524a298e1033fa651987f1ca0cbddd9e61" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Sums scalar COUNT query results across personal, group, and public run containers; queued/running records count and completed records do not.", @@ -15325,8 +15324,7 @@ }, "application/single_app/functions_file_sync.py::_create_run": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "3cc96ae02b4dedffba1307397eae942a9556712e56db7d123cd9a055bea3ebcd", "points": [ { "method": "create_item", @@ -15335,7 +15333,8 @@ } ], "queries": [], - "sha256": "3cc96ae02b4dedffba1307397eae942a9556712e56db7d123cd9a055bea3ebcd" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "response-unused", "contract": "Discards the SDK create response and returns its locally built run dictionary. The stored point response is CosmosDict with plain nested counts; create failures propagate.", @@ -15347,8 +15346,7 @@ }, "application/single_app/functions_file_sync.py::_get_due_sources_for_scope": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "2a2fc9683cf5553b82d959720f5bd5cc3adbf041f52d4df7f757b746c78503f5", "points": [], "queries": [ { @@ -15357,7 +15355,8 @@ "response": "consumed" } ], - "sha256": "2a2fc9683cf5553b82d959720f5bd5cc3adbf041f52d4df7f757b746c78503f5" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Enumerates plain source query rows for enabled schedules due by the supplied clock. Disabled sources and future schedules are excluded without point-response normalization.", @@ -15368,8 +15367,7 @@ }, "application/single_app/functions_file_sync.py::_load_existing_items": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "205276fef67372c1d48d43aafcbf74a953b7b22ee3e365d552d53bd1dc4649a2", "points": [], "queries": [ { @@ -15378,7 +15376,8 @@ "response": "consumed" } ], - "sha256": "205276fef67372c1d48d43aafcbf74a953b7b22ee3e365d552d53bd1dc4649a2" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Indexes plain SDK query rows by item id inside the requested source partition; the resulting item map contains plain nested dictionaries rather than point wrappers.", @@ -15389,8 +15388,7 @@ }, "application/single_app/functions_file_sync.py::_read_file_sync_source_for_document_action": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "a5fe10c45e9cda96611ec1a8dbeba7e467207478b8b2f2e18860f19906b75392", "points": [ { "method": "read_item", @@ -15399,7 +15397,8 @@ } ], "queries": [], - "sha256": "a5fe10c45e9cda96611ec1a8dbeba7e467207478b8b2f2e18860f19906b75392" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Returns the partition-scoped SDK point mapping with its ETag for document-action consumers. Only a missing record or absent input becomes None; provider failures remain failures.", @@ -15410,8 +15409,7 @@ }, "application/single_app/functions_file_sync.py::_source_has_active_run": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "421f529adb9102d224e216c8ff478b400fe30c3db6ef346afdce3c716f30fd38", "points": [], "queries": [ { @@ -15420,7 +15418,8 @@ "response": "consumed" } ], - "sha256": "421f529adb9102d224e216c8ff478b400fe30c3db6ef346afdce3c716f30fd38" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Consumes a scalar COUNT query scoped to the source partition and tests the count, without treating query values as point documents.", @@ -15431,8 +15430,7 @@ }, "application/single_app/functions_file_sync.py::_update_run": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "bdf3034569dac37190ea626b28a6c481f1320a864b12798305129e13ee85d3cf", "points": [ { "method": "upsert_item", @@ -15441,7 +15439,8 @@ } ], "queries": [], - "sha256": "bdf3034569dac37190ea626b28a6c481f1320a864b12798305129e13ee85d3cf" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "response-unused", "contract": "Updates either a local run dictionary or SDK mapping in place and discards the upsert response. The stored ETag advances independently of the caller's old response; write errors propagate.", @@ -15453,8 +15452,7 @@ }, "application/single_app/functions_file_sync.py::_write_with_etag_guard": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "e94dd9f3af36ebe03ed770d742f559d7443aa0d30326fa60b6bbd025a90d4e5e", "points": [ { "method": "read_item", @@ -15473,7 +15471,8 @@ } ], "queries": [], - "sha256": "e94dd9f3af36ebe03ed770d742f559d7443aa0d30326fa60b6bbd025a90d4e5e" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Reads CosmosDict through mapping operations, preserves ETags when applying callbacks, and returns SDK create/replace documents. Conditional conflicts retry against the current record; missing records are not recreated without an explicit factory.", @@ -15485,8 +15484,7 @@ }, "application/single_app/functions_file_sync.py::create_file_sync_source": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "4a29ec8b6b55930c1be8c9e075a47969fdc5c80f9af47f50a9c67e21c491bda5", "points": [ { "method": "create_item", @@ -15495,7 +15493,8 @@ } ], "queries": [], - "sha256": "4a29ec8b6b55930c1be8c9e075a47969fdc5c80f9af47f50a9c67e21c491bda5" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "response-unused", "contract": "Discards the SDK create response and returns the locally constructed source dictionary; the stored response preserves SDK shape and ETag. Storage write failures still propagate.", @@ -15507,8 +15506,7 @@ }, "application/single_app/functions_file_sync.py::delete_file_sync_source": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "89cf46d55f9f99400925ec442d7b6be638312d03dce6c824965c0ae7fffcb5da", "points": [ { "method": "delete_item", @@ -15527,7 +15525,8 @@ } ], "queries": [], - "sha256": "89cf46d55f9f99400925ec442d7b6be638312d03dce6c824965c0ae7fffcb5da" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Consumes the authorized SDK source and a fresh CosmosDict after a conditional-delete conflict through mapping access. Preserves configuration revision semantics while retrying an ETag-only change; delete responses are unused.", @@ -15538,8 +15537,7 @@ }, "application/single_app/functions_file_sync.py::get_authorized_sync_source": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "b489d71bee733870574ae480e0bce7dc24717f032b37505d28d8b1922993b0cf", "points": [ { "method": "read_item", @@ -15548,7 +15546,8 @@ } ], "queries": [], - "sha256": "b489d71bee733870574ae480e0bce7dc24717f032b37505d28d8b1922993b0cf" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Authorizes workspace access before the partition-scoped point read, checks scope fields through mapping access, and returns CosmosDict with its ETag. Missing partitions and mismatched stored scope are rejected.", @@ -15559,8 +15558,7 @@ }, "application/single_app/functions_file_sync.py::list_file_sync_runs": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "a2292b1e75d7679e7e2cfe5bc9e5bb52d36f002c82eb5934ea20d1aaf2227640", "points": [], "queries": [ { @@ -15569,7 +15567,8 @@ "response": "consumed" } ], - "sha256": "a2292b1e75d7679e7e2cfe5bc9e5bb52d36f002c82eb5934ea20d1aaf2227640" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Enumerates plain SDK query dictionaries from the source partition, ordered by run start and bounded by TOP. No point-response conversion is required.", @@ -15580,8 +15579,7 @@ }, "application/single_app/functions_file_sync.py::list_file_sync_sources": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "7f6d99469fe2b70c3cfcb08d3599d76075ba116bdb994324c7633dc0887b3982", "points": [], "queries": [ { @@ -15590,7 +15588,8 @@ "response": "consumed" } ], - "sha256": "7f6d99469fe2b70c3cfcb08d3599d76075ba116bdb994324c7633dc0887b3982" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Enumerates plain SDK query dictionaries within the requested workspace partition. Source results do not cross an exact-dictionary point-response contract.", @@ -15601,8 +15600,7 @@ }, "application/single_app/functions_file_sync.py::process_file_sync_run_by_id": { "boundary": { - "batches": [], - "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88", + "sha256": "6124d481313fe57e8660500690dd2b0801e59ea262a07954e55f7a1927c579d2", "points": [ { "method": "read_item", @@ -15616,7 +15614,8 @@ } ], "queries": [], - "sha256": "6124d481313fe57e8660500690dd2b0801e59ea262a07954e55f7a1927c579d2" + "batches": [], + "module_sha256": "9920f576f264519bde1eea95af0f97e0ced5ea81536ccb6fb53312c15a2f4e88" }, "classification": "sdk-compatible", "contract": "Reads source and run from their workspace/source partitions and forwards the SDK mappings, ETags, and plain nested counts to the engine. A missing source fails before engine invocation.", @@ -15627,8 +15626,7 @@ }, "application/single_app/functions_generated_file_approvals.py::list_expired_pending_generated_file_artifacts": { "boundary": { - "batches": [], - "module_sha256": "0e6fdc72af6ae3b1b7f13be057ddee12d65a2fbc6c6520f83bb0cf37bfe6ecdb", + "sha256": "93ba8d8aad1721d4f52a9db66526b8497ac4d0c59961199595aaddc341b8dfb2", "points": [], "queries": [ { @@ -15637,7 +15635,8 @@ "response": "consumed" } ], - "sha256": "93ba8d8aad1721d4f52a9db66526b8497ac4d0c59961199595aaddc341b8dfb2" + "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.", @@ -15648,8 +15647,7 @@ }, "application/single_app/functions_global_actions.py::delete_global_action": { "boundary": { - "batches": [], - "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1", + "sha256": "7674102fc2d2dc82e72d05c3d00c889c7ed3e680144537345bf078ff55e5bc67", "points": [ { "method": "read_item", @@ -15663,7 +15661,8 @@ } ], "queries": [], - "sha256": "7674102fc2d2dc82e72d05c3d00c889c7ed3e680144537345bf078ff55e5bc67" + "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.", @@ -15674,8 +15673,7 @@ }, "application/single_app/functions_global_actions.py::get_global_action": { "boundary": { - "batches": [], - "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1", + "sha256": "06beac7729d9219e19620c807432d190d6da6777320a107999d741cf177cd3b2", "points": [ { "method": "read_item", @@ -15684,7 +15682,8 @@ } ], "queries": [], - "sha256": "06beac7729d9219e19620c807432d190d6da6777320a107999d741cf177cd3b2" + "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.", @@ -15695,8 +15694,7 @@ }, "application/single_app/functions_global_actions.py::get_global_actions": { "boundary": { - "batches": [], - "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1", + "sha256": "f48ca62db481735fc54480d260220aa50798edc793ab117d6af6241439b5fe50", "points": [], "queries": [ { @@ -15705,7 +15703,8 @@ "response": "consumed" } ], - "sha256": "f48ca62db481735fc54480d260220aa50798edc793ab117d6af6241439b5fe50" + "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.", @@ -15716,8 +15715,7 @@ }, "application/single_app/functions_global_actions.py::save_global_action": { "boundary": { - "batches": [], - "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1", + "sha256": "5156bc4729ca3084851df4eaabf5f14a95c890501dc73a6152e665e925fbd911", "points": [ { "method": "read_item", @@ -15736,7 +15734,8 @@ } ], "queries": [], - "sha256": "5156bc4729ca3084851df4eaabf5f14a95c890501dc73a6152e665e925fbd911" + "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.", @@ -15747,8 +15746,7 @@ }, "application/single_app/functions_global_actions.py::update_global_action_enabled": { "boundary": { - "batches": [], - "module_sha256": "d9eaff6fe065d14c00ed1ad006778dd865c1547a96a0c0a61a2e41a3df8c32d1", + "sha256": "363fba9a82a206cdd254ce69b9b3a78b48dcca10d63a9047ab7cc4727abc96ab", "points": [ { "method": "read_item", @@ -15762,7 +15760,8 @@ } ], "queries": [], - "sha256": "363fba9a82a206cdd254ce69b9b3a78b48dcca10d63a9047ab7cc4727abc96ab" + "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.", @@ -15773,8 +15772,7 @@ }, "application/single_app/functions_global_agents.py::delete_global_agent": { "boundary": { - "batches": [], - "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768", + "sha256": "fc5b63ea44747a8f8cac3ce50ffdd1a2001b133b84c7d3f99855c3be0211fb12", "points": [ { "method": "read_item", @@ -15788,7 +15786,8 @@ } ], "queries": [], - "sha256": "fc5b63ea44747a8f8cac3ce50ffdd1a2001b133b84c7d3f99855c3be0211fb12" + "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.", @@ -15799,8 +15798,7 @@ }, "application/single_app/functions_global_agents.py::get_global_agent": { "boundary": { - "batches": [], - "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768", + "sha256": "87466d43743b0a517723561263491de813d1cf54a06185a4ecb474fe85b43b8a", "points": [ { "method": "read_item", @@ -15809,7 +15807,8 @@ } ], "queries": [], - "sha256": "87466d43743b0a517723561263491de813d1cf54a06185a4ecb474fe85b43b8a" + "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.", @@ -15820,8 +15819,7 @@ }, "application/single_app/functions_global_agents.py::get_global_agents": { "boundary": { - "batches": [], - "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768", + "sha256": "a07d6cde0c50937ef62c8b2c0def934eda710891b52de7e0e7f08d789f240dbb", "points": [], "queries": [ { @@ -15830,7 +15828,8 @@ "response": "consumed" } ], - "sha256": "a07d6cde0c50937ef62c8b2c0def934eda710891b52de7e0e7f08d789f240dbb" + "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.", @@ -15841,8 +15840,7 @@ }, "application/single_app/functions_global_agents.py::save_global_agent": { "boundary": { - "batches": [], - "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768", + "sha256": "dd1b2de959dd1064989f66ae7f68116f31c2f55978a9f4b74929a24bd8e3e563", "points": [ { "method": "read_item", @@ -15856,7 +15854,8 @@ } ], "queries": [], - "sha256": "dd1b2de959dd1064989f66ae7f68116f31c2f55978a9f4b74929a24bd8e3e563" + "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.", @@ -15867,8 +15866,7 @@ }, "application/single_app/functions_global_agents.py::update_global_agent_enabled": { "boundary": { - "batches": [], - "module_sha256": "09a25c74df9cad738a44148cc2324d1748eb39eff1a20c3a60ca774d7bcde768", + "sha256": "dd247e225c4422edb5c07aa149c05d522353ceba224e71e0d5ffe2c0ce36d393", "points": [ { "method": "read_item", @@ -15882,7 +15880,8 @@ } ], "queries": [], - "sha256": "dd247e225c4422edb5c07aa149c05d522353ceba224e71e0d5ffe2c0ce36d393" + "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.", @@ -15893,8 +15892,7 @@ }, "application/single_app/functions_governance.py::_read_existing_item_policy_for_delete": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "7b1081b6d08d02d39c6d06bbed3df28166527dfccb6c0a302b957313e7d1d5f2", "points": [ { "method": "read_item", @@ -15908,7 +15906,8 @@ } ], "queries": [], - "sha256": "7b1081b6d08d02d39c6d06bbed3df28166527dfccb6c0a302b957313e7d1d5f2" + "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.", @@ -15919,8 +15918,7 @@ }, "application/single_app/functions_governance.py::_read_item_policies": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "5ea52f69c3e1b771eabea40da752047e9e7b76af321b3103ef88cf3df8d8af23", "points": [], "queries": [ { @@ -15929,7 +15927,8 @@ "response": "consumed" } ], - "sha256": "5ea52f69c3e1b771eabea40da752047e9e7b76af321b3103ef88cf3df8d8af23" + "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.", @@ -15940,8 +15939,7 @@ }, "application/single_app/functions_governance.py::_read_stored_feature_policy": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "7ef077434901e851e9d5e0ce7d9fb1cc0da752db39d860d892abdb456898d7fe", "points": [ { "method": "read_item", @@ -15950,7 +15948,8 @@ } ], "queries": [], - "sha256": "7ef077434901e851e9d5e0ce7d9fb1cc0da752db39d860d892abdb456898d7fe" + "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.", @@ -15961,8 +15960,7 @@ }, "application/single_app/functions_governance.py::_read_stored_item_policy": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "75885bf8515dfe187aee2ef954cdd1621a7716e103bd08b827d61b1055f4fb71", "points": [ { "method": "read_item", @@ -15971,7 +15969,8 @@ } ], "queries": [], - "sha256": "75885bf8515dfe187aee2ef954cdd1621a7716e103bd08b827d61b1055f4fb71" + "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.", @@ -15982,8 +15981,7 @@ }, "application/single_app/functions_governance.py::bootstrap_default_feature_policies": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "c22d56a6e85b6004683f582ee6ad75bd4bc7fb020a7477f9285302418b5a6e5f", "points": [ { "method": "upsert_item", @@ -15992,7 +15990,8 @@ } ], "queries": [], - "sha256": "c22d56a6e85b6004683f582ee6ad75bd4bc7fb020a7477f9285302418b5a6e5f" + "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.", @@ -16001,8 +16000,7 @@ }, "application/single_app/functions_governance.py::delete_item_policy": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "0bc0016c518eb833757dda5f1537acc800395bf0a182093e9d02dc09910e06c1", "points": [ { "method": "delete_item", @@ -16011,7 +16009,8 @@ } ], "queries": [], - "sha256": "0bc0016c518eb833757dda5f1537acc800395bf0a182093e9d02dc09910e06c1" + "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.", @@ -16020,8 +16019,7 @@ }, "application/single_app/functions_governance.py::list_feature_policies": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "34c57ce8e70aa88119be09ba446098784095f3ef59ff29df5064d2ee63752b05", "points": [], "queries": [ { @@ -16030,7 +16028,8 @@ "response": "consumed" } ], - "sha256": "34c57ce8e70aa88119be09ba446098784095f3ef59ff29df5064d2ee63752b05" + "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.", @@ -16041,8 +16040,7 @@ }, "application/single_app/functions_governance.py::list_item_policies": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "d78236b0574cf23133b88ad582daca7f8bc8265e2f6930c77dc6b5a5e4aec55e", "points": [], "queries": [ { @@ -16056,7 +16054,8 @@ "response": "consumed" } ], - "sha256": "d78236b0574cf23133b88ad582daca7f8bc8265e2f6930c77dc6b5a5e4aec55e" + "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.", @@ -16067,8 +16066,7 @@ }, "application/single_app/functions_governance.py::list_item_policies_by_policy_id": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "bf3d817087f0733612da3a7c9aaf0159e0f2f58e982efc267c8cfdfbd329d0dc", "points": [], "queries": [ { @@ -16077,7 +16075,8 @@ "response": "consumed" } ], - "sha256": "bf3d817087f0733612da3a7c9aaf0159e0f2f58e982efc267c8cfdfbd329d0dc" + "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.", @@ -16088,8 +16087,7 @@ }, "application/single_app/functions_governance.py::retarget_item_policy": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "a8aea44eb3c83ca87a4625165dbfd2c591f71d7046c47dc0dba1bf9d2cb23893", "points": [ { "method": "delete_item", @@ -16098,7 +16096,8 @@ } ], "queries": [], - "sha256": "a8aea44eb3c83ca87a4625165dbfd2c591f71d7046c47dc0dba1bf9d2cb23893" + "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.", @@ -16107,8 +16106,7 @@ }, "application/single_app/functions_governance.py::upsert_feature_policy": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "f8ee2ee205f4d4cc4bbcb9c4e8ceec8b086908b95bb54cc7ff9e775cf40b2f02", "points": [ { "method": "upsert_item", @@ -16117,7 +16115,8 @@ } ], "queries": [], - "sha256": "f8ee2ee205f4d4cc4bbcb9c4e8ceec8b086908b95bb54cc7ff9e775cf40b2f02" + "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.", @@ -16128,8 +16127,7 @@ }, "application/single_app/functions_governance.py::upsert_item_policy": { "boundary": { - "batches": [], - "module_sha256": "ed7d66be2a1d42d5105e8280f22ad37188aa606146c276d3fb897cafe573f75d", + "sha256": "bdfcfa8c51906b56ca681b1267e5fa6248e3fd4109d706b5b4e5d5dcaf2e2d03", "points": [ { "method": "upsert_item", @@ -16148,7 +16146,8 @@ } ], "queries": [], - "sha256": "bdfcfa8c51906b56ca681b1267e5fa6248e3fd4109d706b5b4e5d5dcaf2e2d03" + "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.", @@ -16159,8 +16158,7 @@ }, "application/single_app/functions_group.py::create_group": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "fba53efb319bf42254ccc86345e5980cf102ad8d80f7e45d963b566c3e6f55ea", "points": [ { "method": "create_item", @@ -16169,7 +16167,8 @@ } ], "queries": [], - "sha256": "fba53efb319bf42254ccc86345e5980cf102ad8d80f7e45d963b566c3e6f55ea" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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.", @@ -16178,8 +16177,7 @@ }, "application/single_app/functions_group.py::delete_group": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "f32d321fc87859808cac4cbf3102d28e7d8d3c255d2e9456545679adcb71103f", "points": [ { "method": "delete_item", @@ -16188,7 +16186,8 @@ } ], "queries": [], - "sha256": "f32d321fc87859808cac4cbf3102d28e7d8d3c255d2e9456545679adcb71103f" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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.", @@ -16197,8 +16196,7 @@ }, "application/single_app/functions_group.py::discover_group_records": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "4de430f31b8e3879fd06279f59176b375914b21ccd46bc6f61c1262939e40231", "points": [], "queries": [ { @@ -16207,7 +16205,8 @@ "response": "consumed" } ], - "sha256": "4de430f31b8e3879fd06279f59176b375914b21ccd46bc6f61c1262939e40231" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -16218,8 +16217,7 @@ }, "application/single_app/functions_group.py::find_group_by_id": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "364ab7847a8fd50ed4eb145de1f71ff1dc6a953009559de56b178596d7d90206", "points": [ { "method": "read_item", @@ -16228,7 +16226,8 @@ } ], "queries": [], - "sha256": "364ab7847a8fd50ed4eb145de1f71ff1dc6a953009559de56b178596d7d90206" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -16239,8 +16238,7 @@ }, "application/single_app/functions_group.py::find_groups_by_ids": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "a3f4c6aad35cca9df64a6c9129730a5169502592566cfe98139e2cb04613711e", "points": [], "queries": [ { @@ -16249,7 +16247,8 @@ "response": "consumed" } ], - "sha256": "a3f4c6aad35cca9df64a6c9129730a5169502592566cfe98139e2cb04613711e" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -16260,8 +16259,7 @@ }, "application/single_app/functions_group.py::get_user_groups": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "3738f18009c7d241642fb17e972b7290caca75c0e450d911ee0c972d9624c302", "points": [], "queries": [ { @@ -16270,7 +16268,8 @@ "response": "consumed" } ], - "sha256": "3738f18009c7d241642fb17e972b7290caca75c0e450d911ee0c972d9624c302" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -16281,8 +16280,7 @@ }, "application/single_app/functions_group.py::list_groups_for_admin_directory": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "cd8e30dda80ad391ac364c2c1b7cfd1dbe554324d8df573998e8957e053b0bab", "points": [], "queries": [ { @@ -16291,7 +16289,8 @@ "response": "consumed" } ], - "sha256": "cd8e30dda80ad391ac364c2c1b7cfd1dbe554324d8df573998e8957e053b0bab" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -16302,8 +16301,7 @@ }, "application/single_app/functions_group.py::search_all_groups": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "7a345b4fa2344585390f67d858a0f3c85e9ce8c276b02ee3e2f603306cfccb00", "points": [], "queries": [ { @@ -16312,7 +16310,8 @@ "response": "consumed" } ], - "sha256": "7a345b4fa2344585390f67d858a0f3c85e9ce8c276b02ee3e2f603306cfccb00" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -16323,8 +16322,7 @@ }, "application/single_app/functions_group.py::search_groups": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "2b410088ff1accc0e4aede5797db454700ba9aa3913bdbf679e063337999e001", "points": [], "queries": [ { @@ -16333,7 +16331,8 @@ "response": "consumed" } ], - "sha256": "2b410088ff1accc0e4aede5797db454700ba9aa3913bdbf679e063337999e001" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -16344,8 +16343,7 @@ }, "application/single_app/functions_group.py::update_group_document_with_etag_guard": { "boundary": { - "batches": [], - "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884", + "sha256": "7966f21ba0d02a709c499271cb163c42a3aaef53cc3d471932beba4a17a4ef59", "points": [ { "method": "read_item", @@ -16359,7 +16357,8 @@ } ], "queries": [], - "sha256": "7966f21ba0d02a709c499271cb163c42a3aaef53cc3d471932beba4a17a4ef59" + "batches": [], + "module_sha256": "d678775f0611493ebbfaacdda135264c2a36c7fe3ef5d4e5d2cbfbcc68ddb884" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -16370,8 +16369,7 @@ }, "application/single_app/functions_group_actions.py::delete_group_action": { "boundary": { - "batches": [], - "module_sha256": "f974e05320904cc49bcbe9ae0b51ededa85733f01f391dc71f00801715f4fa20", + "sha256": "d9c65156b7cb97d51c3b272647139823600a4ee7430d3ef1486dc92266d44631", "points": [ { "method": "read_item", @@ -16385,7 +16383,8 @@ } ], "queries": [], - "sha256": "d9c65156b7cb97d51c3b272647139823600a4ee7430d3ef1486dc92266d44631" + "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.", @@ -16396,8 +16395,7 @@ }, "application/single_app/functions_group_actions.py::get_group_action": { "boundary": { - "batches": [], - "module_sha256": "f974e05320904cc49bcbe9ae0b51ededa85733f01f391dc71f00801715f4fa20", + "sha256": "c878130377dde9aa9f4944159b4d1d2b4f00435433a287c90e3daedc56ee85a5", "points": [ { "method": "read_item", @@ -16412,7 +16410,8 @@ "response": "consumed" } ], - "sha256": "c878130377dde9aa9f4944159b4d1d2b4f00435433a287c90e3daedc56ee85a5" + "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.", @@ -16423,8 +16422,7 @@ }, "application/single_app/functions_group_actions.py::get_group_actions": { "boundary": { - "batches": [], - "module_sha256": "f974e05320904cc49bcbe9ae0b51ededa85733f01f391dc71f00801715f4fa20", + "sha256": "44257a71303f0aa964003704cb3bc1e4726c36897664d893d2614fc7239c8e1e", "points": [], "queries": [ { @@ -16433,7 +16431,8 @@ "response": "consumed" } ], - "sha256": "44257a71303f0aa964003704cb3bc1e4726c36897664d893d2614fc7239c8e1e" + "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.", @@ -16444,8 +16443,7 @@ }, "application/single_app/functions_group_actions.py::save_group_action": { "boundary": { - "batches": [], - "module_sha256": "f974e05320904cc49bcbe9ae0b51ededa85733f01f391dc71f00801715f4fa20", + "sha256": "398c6c9077307aab6ee002062bf0759f2d8691f1d7f54a2d58fa60e8e224c4c2", "points": [ { "method": "read_item", @@ -16464,7 +16462,8 @@ } ], "queries": [], - "sha256": "398c6c9077307aab6ee002062bf0759f2d8691f1d7f54a2d58fa60e8e224c4c2" + "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.", @@ -16475,8 +16474,7 @@ }, "application/single_app/functions_group_agents.py::delete_group_agent": { "boundary": { - "batches": [], - "module_sha256": "bd655e3f50d7513a07458457de9d8c13b8a8384a1dbb2d7fbf0e76bd2382c5f1", + "sha256": "ed27863285b9b53309362f566f7ee69cd59a5b4df107560f48baf517d2068657", "points": [ { "method": "read_item", @@ -16490,7 +16488,8 @@ } ], "queries": [], - "sha256": "ed27863285b9b53309362f566f7ee69cd59a5b4df107560f48baf517d2068657" + "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.", @@ -16501,8 +16500,7 @@ }, "application/single_app/functions_group_agents.py::get_group_agent": { "boundary": { - "batches": [], - "module_sha256": "bd655e3f50d7513a07458457de9d8c13b8a8384a1dbb2d7fbf0e76bd2382c5f1", + "sha256": "6bbbde245c75f8b133db5f71da4a3d133f9377bdfb854555db2f94ff83ed5e1b", "points": [ { "method": "read_item", @@ -16511,7 +16509,8 @@ } ], "queries": [], - "sha256": "6bbbde245c75f8b133db5f71da4a3d133f9377bdfb854555db2f94ff83ed5e1b" + "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.", @@ -16522,8 +16521,7 @@ }, "application/single_app/functions_group_agents.py::get_group_agents": { "boundary": { - "batches": [], - "module_sha256": "bd655e3f50d7513a07458457de9d8c13b8a8384a1dbb2d7fbf0e76bd2382c5f1", + "sha256": "d66936b1c1fc4d0b112fc50651a71c0965166ba735a3a0168156b22e100ab7c3", "points": [], "queries": [ { @@ -16532,7 +16530,8 @@ "response": "consumed" } ], - "sha256": "d66936b1c1fc4d0b112fc50651a71c0965166ba735a3a0168156b22e100ab7c3" + "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.", @@ -16543,8 +16542,7 @@ }, "application/single_app/functions_group_agents.py::save_group_agent": { "boundary": { - "batches": [], - "module_sha256": "bd655e3f50d7513a07458457de9d8c13b8a8384a1dbb2d7fbf0e76bd2382c5f1", + "sha256": "07bbabbae7b011c45d81d1f18852e5531c8cf189aedacaf244628f1310425960", "points": [ { "method": "read_item", @@ -16558,7 +16556,8 @@ } ], "queries": [], - "sha256": "07bbabbae7b011c45d81d1f18852e5531c8cf189aedacaf244628f1310425960" + "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.", @@ -16569,8 +16568,7 @@ }, "application/single_app/functions_group_directory.py::list_group_directory": { "boundary": { - "batches": [], - "module_sha256": "cb67c7e2d4ed87d04e4ea6e6997a8aba181b1dd9845a7041ed7eedac7cbd9693", + "sha256": "366e7e0cc3180f9f4b66f7b5230ffc0f34d34f7c20187f393fcb14f0021e1ca8", "points": [], "queries": [ { @@ -16579,7 +16577,8 @@ "response": "consumed" } ], - "sha256": "366e7e0cc3180f9f4b66f7b5230ffc0f34d34f7c20187f393fcb14f0021e1ca8" + "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.", @@ -16590,8 +16589,7 @@ }, "application/single_app/functions_group_document_access.py::group_document_cleanup_allowed": { "boundary": { - "batches": [], - "module_sha256": "01063006a57ae3950f3263ed00928470b3abf5b821506df27b8d091043b54c4b", + "sha256": "19e8816ff30cbd57ea90ebf207916a6a07ebfeb4279e1bfa362857181a445743", "points": [ { "method": "read_item", @@ -16600,7 +16598,8 @@ } ], "queries": [], - "sha256": "19e8816ff30cbd57ea90ebf207916a6a07ebfeb4279e1bfa362857181a445743" + "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.", @@ -16611,8 +16610,7 @@ }, "application/single_app/functions_group_document_access.py::group_document_family_records": { "boundary": { - "batches": [], - "module_sha256": "01063006a57ae3950f3263ed00928470b3abf5b821506df27b8d091043b54c4b", + "sha256": "4017d60b880bf52e622c7761eda48bf7d28fe23157c5179515a44af6bfe42c7f", "points": [], "queries": [ { @@ -16621,7 +16619,8 @@ "response": "consumed" } ], - "sha256": "4017d60b880bf52e622c7761eda48bf7d28fe23157c5179515a44af6bfe42c7f" + "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.", @@ -16632,8 +16631,7 @@ }, "application/single_app/functions_group_document_access.py::read_group_document_record": { "boundary": { - "batches": [], - "module_sha256": "01063006a57ae3950f3263ed00928470b3abf5b821506df27b8d091043b54c4b", + "sha256": "3a90a3fe17ea041fa63bfa59aac7b2d7a062512ab28b429cc23a2a6f8cefdef3", "points": [ { "method": "read_item", @@ -16642,7 +16640,8 @@ } ], "queries": [], - "sha256": "3a90a3fe17ea041fa63bfa59aac7b2d7a062512ab28b429cc23a2a6f8cefdef3" + "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.", @@ -16653,8 +16652,7 @@ }, "application/single_app/functions_group_document_collaboration.py::_replace": { "boundary": { - "batches": [], - "module_sha256": "4c4e8a5b21d9f3178521192bead8cfd1815dbc3e3820daa872e2ad3e1fd6cccb", + "sha256": "e53730650c34e6ca0092bc2e5f7e846d09ac2ed52d6723a30cff183dcbb00929", "points": [ { "method": "replace_item", @@ -16663,7 +16661,8 @@ } ], "queries": [], - "sha256": "e53730650c34e6ca0092bc2e5f7e846d09ac2ed52d6723a30cff183dcbb00929" + "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.", @@ -16674,8 +16673,7 @@ }, "application/single_app/functions_group_document_management.py::_current_owned_documents": { "boundary": { - "batches": [], - "module_sha256": "a09154616e4a1bb4dc5372a63ff66d2cc0839efd0adb0e9c5f48c97f80de4eec", + "sha256": "06f498d6e46ae44bc1bf500ac0b80de47ccb60cd9d82df3d109a947c0aef276c", "points": [], "queries": [ { @@ -16684,7 +16682,8 @@ "response": "consumed" } ], - "sha256": "06f498d6e46ae44bc1bf500ac0b80de47ccb60cd9d82df3d109a947c0aef276c" + "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.", @@ -16695,8 +16694,7 @@ }, "application/single_app/functions_group_document_management.py::_patch_tag_definitions": { "boundary": { - "batches": [], - "module_sha256": "a09154616e4a1bb4dc5372a63ff66d2cc0839efd0adb0e9c5f48c97f80de4eec", + "sha256": "965ea1f62d9876e817c7eb3fc5587e756dd0fa659a9e953bc686bffe4de4b936", "points": [ { "method": "patch_item", @@ -16705,7 +16703,8 @@ } ], "queries": [], - "sha256": "965ea1f62d9876e817c7eb3fc5587e756dd0fa659a9e953bc686bffe4de4b936" + "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.", @@ -16716,8 +16715,7 @@ }, "application/single_app/functions_group_document_projection_fence.py::_read_source": { "boundary": { - "batches": [], - "module_sha256": "67c0cbf3306378b707ba938ff1deb96273f8738360181841211bf577b079d05d", + "sha256": "6a82b334a000459e1ca892563c8ae3ecd61bd62d50fa267202c027e4fb1893a9", "points": [ { "method": "read_item", @@ -16726,7 +16724,8 @@ } ], "queries": [], - "sha256": "6a82b334a000459e1ca892563c8ae3ecd61bd62d50fa267202c027e4fb1893a9" + "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.", @@ -16737,8 +16736,7 @@ }, "application/single_app/functions_group_document_projection_fence.py::_replace_source": { "boundary": { - "batches": [], - "module_sha256": "67c0cbf3306378b707ba938ff1deb96273f8738360181841211bf577b079d05d", + "sha256": "4488f7e94f4d8c9086cf8551f49360775f3f49c18c2c2bd94f72ea5305fb853c", "points": [ { "method": "replace_item", @@ -16747,7 +16745,8 @@ } ], "queries": [], - "sha256": "4488f7e94f4d8c9086cf8551f49360775f3f49c18c2c2bd94f72ea5305fb853c" + "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.", @@ -16758,8 +16757,7 @@ }, "application/single_app/functions_group_document_publication.py::decide_group_document_publication": { "boundary": { - "batches": [], - "module_sha256": "7cfee4023fee65493f57fed44a235331c454457dd9b2acb1c124422840ab64dc", + "sha256": "907a5b60e3781b2fbe0a94e4ef1620c41b89f4b8e8fb89a08ad3b180d26c6922", "points": [ { "method": "read_item", @@ -16768,7 +16766,8 @@ } ], "queries": [], - "sha256": "907a5b60e3781b2fbe0a94e4ef1620c41b89f4b8e8fb89a08ad3b180d26c6922" + "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.", @@ -16804,8 +16803,7 @@ }, "application/single_app/functions_group_endpoint_access.py::find_group_endpoint_references": { "boundary": { - "batches": [], - "module_sha256": "df122c97599e66467c6caa5acb336ab568500e788585183f260ede8d6edf91e4", + "sha256": "c12451273e949ee7773379755da4d5650093e37f876310bfc53c3572929a16bd", "points": [], "queries": [ { @@ -16819,7 +16817,8 @@ "response": "consumed" } ], - "sha256": "c12451273e949ee7773379755da4d5650093e37f876310bfc53c3572929a16bd" + "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.", @@ -16830,8 +16829,7 @@ }, "application/single_app/functions_group_insights.py::read_group_activity": { "boundary": { - "batches": [], - "module_sha256": "17771f87e419b3db9bd88ac22db9217fe38c251fa83c384cd0dee8f445d963c2", + "sha256": "02a6ceb6137a7e3dfe75426d2768593c0dbfca8002a175c76e41bf83ac6bbb58", "points": [], "queries": [ { @@ -16840,7 +16838,8 @@ "response": "consumed" } ], - "sha256": "02a6ceb6137a7e3dfe75426d2768593c0dbfca8002a175c76e41bf83ac6bbb58" + "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.", @@ -16851,8 +16850,7 @@ }, "application/single_app/functions_group_insights.py::read_group_stats_rows": { "boundary": { - "batches": [], - "module_sha256": "17771f87e419b3db9bd88ac22db9217fe38c251fa83c384cd0dee8f445d963c2", + "sha256": "286a81c4e2d06ca24524dd8fa29028c66e53bd0a20c31db7877a604c886e184a", "points": [], "queries": [ { @@ -16861,7 +16859,8 @@ "response": "consumed" } ], - "sha256": "286a81c4e2d06ca24524dd8fa29028c66e53bd0a20c31db7877a604c886e184a" + "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.", @@ -16872,8 +16871,7 @@ }, "application/single_app/functions_group_membership_audit.py::log_group_member_role_change": { "boundary": { - "batches": [], - "module_sha256": "7ac6ddacc88bfec1d8c21c378a6dfb92498274bb3d8f8bae5b6c428ed72f31ca", + "sha256": "8bb45ee8df6679ffc5afa1d8329430c6ff8e1cf445d80d2c7fad3072089f95a4", "points": [ { "method": "create_item", @@ -16882,7 +16880,8 @@ } ], "queries": [], - "sha256": "8bb45ee8df6679ffc5afa1d8329430c6ff8e1cf445d80d2c7fad3072089f95a4" + "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.", @@ -16891,8 +16890,7 @@ }, "application/single_app/functions_group_workflows.py::_normalize_group_workflow_conversation_id": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "d2f0ac990a4b66131a7967389f9b6007ff10c89a473f12d4c81b3dadc4209c74", "points": [ { "method": "read_item", @@ -16901,7 +16899,8 @@ } ], "queries": [], - "sha256": "d2f0ac990a4b66131a7967389f9b6007ff10c89a473f12d4c81b3dadc4209c74" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "Conversation point response is consumed only through Mapping.get for chat-type and workflow-group authorization; no strict dict gate.", @@ -16912,8 +16911,7 @@ }, "application/single_app/functions_group_workflows.py::delete_group_workflow": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "884453e79ebac453abf1aed5561e0810f281451507ca3ed29d42861818476613", "points": [ { "method": "delete_item", @@ -16943,7 +16941,8 @@ "response": "consumed" } ], - "sha256": "884453e79ebac453abf1aed5561e0810f281451507ca3ed29d42861818476613" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "response-unused", "contract": "Delete point responses are unused. Run/item query projections are ordinary SDK dictionary rows consumed only with get; workflow point read is normalized by get_group_workflow.", @@ -16951,8 +16950,7 @@ }, "application/single_app/functions_group_workflows.py::get_due_group_workflows": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "73c1e21224746b5331d2aaf760f615fd781bb6ba44563b212fcfb6af4acb0230", "points": [], "queries": [ { @@ -16961,7 +16959,8 @@ "response": "consumed" } ], - "sha256": "73c1e21224746b5331d2aaf760f615fd781bb6ba44563b212fcfb6af4acb0230" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "Query yields SDK ordinary dictionary rows; each is projected through _strip_cosmos_metadata into a domain dictionary.", @@ -16972,8 +16971,7 @@ }, "application/single_app/functions_group_workflows.py::get_group_workflow": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "3b19231886f2f1c7116d3883ae38a9e6b9e601ce11ca92204e64402ce753e5a6", "points": [ { "method": "read_item", @@ -16982,7 +16980,8 @@ } ], "queries": [], - "sha256": "3b19231886f2f1c7116d3883ae38a9e6b9e601ce11ca92204e64402ce753e5a6" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "SDK CosmosDict point response passes through metadata projection using Mapping.items, yielding an ordinary dictionary without a strict dict gate.", @@ -16993,8 +16992,7 @@ }, "application/single_app/functions_group_workflows.py::get_group_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "26a98a98b22a86265b43a5c496dd979cd51aa0d709d2d129f84a66599bfe3c4b", "points": [ { "method": "read_item", @@ -17003,7 +17001,8 @@ } ], "queries": [], - "sha256": "26a98a98b22a86265b43a5c496dd979cd51aa0d709d2d129f84a66599bfe3c4b" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "SDK CosmosDict point response is metadata-projected into a plain domain dictionary; missing scoped points return None.", @@ -17014,8 +17013,7 @@ }, "application/single_app/functions_group_workflows.py::get_group_workflow_run_item": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "e1f1a0b97b96c5a070196bf252118f1a214026946691e9c3808187f9fc32bb06", "points": [ { "method": "read_item", @@ -17024,7 +17022,8 @@ } ], "queries": [], - "sha256": "e1f1a0b97b96c5a070196bf252118f1a214026946691e9c3808187f9fc32bb06" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "SDK point Mapping is checked for public item type using get, then metadata-projected to a dictionary; internal chunk points remain hidden.", @@ -17035,8 +17034,7 @@ }, "application/single_app/functions_group_workflows.py::get_group_workflows": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "4f943219bcc99c0089a31eba95b585937d567abfbb4b48534b0bd6302494c1ba", "points": [], "queries": [ { @@ -17045,7 +17043,8 @@ "response": "consumed" } ], - "sha256": "4f943219bcc99c0089a31eba95b585937d567abfbb4b48534b0bd6302494c1ba" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "Query rows are plain SDK dictionaries; metadata projection returns ordinary domain dictionaries in the requested group partition.", @@ -17056,8 +17055,7 @@ }, "application/single_app/functions_group_workflows.py::get_latest_group_workflow_run_for_conversation": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "2f346c495c5b141cce5c0a70672e675de3c1c667e8102f41fa92c477d2aada27", "points": [], "queries": [ { @@ -17066,7 +17064,8 @@ "response": "consumed" } ], - "sha256": "2f346c495c5b141cce5c0a70672e675de3c1c667e8102f41fa92c477d2aada27" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "Latest-run query row is an ordinary dictionary and is metadata-projected; no strict point-response assumption.", @@ -17077,8 +17076,7 @@ }, "application/single_app/functions_group_workflows.py::list_group_workflow_run_items": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "375cb94037bda4d7accfb133a40ca199cd512a18770883489c8ca43193f01e73", "points": [], "queries": [ { @@ -17087,7 +17085,8 @@ "response": "consumed" } ], - "sha256": "375cb94037bda4d7accfb133a40ca199cd512a18770883489c8ca43193f01e73" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "Plain query rows are checked using Mapping.get, internal result chunks are excluded, and public rows become metadata-free dictionaries.", @@ -17098,8 +17097,7 @@ }, "application/single_app/functions_group_workflows.py::list_group_workflow_runs": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "0472f91b976597560df7fbc9e3ebd609e89d85233607450ef7eee0adee317000", "points": [], "queries": [ { @@ -17108,7 +17106,8 @@ "response": "consumed" } ], - "sha256": "0472f91b976597560df7fbc9e3ebd609e89d85233607450ef7eee0adee317000" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "Run query rows use metadata projection and list slicing, accepting SDK ordinary dictionary query rows.", @@ -17119,8 +17118,7 @@ }, "application/single_app/functions_group_workflows.py::save_group_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "b3305f400e0d0814f32b00a3c043622a9f7c0b87efb6ebb8d980e3eebf3490ee", "points": [ { "method": "upsert_item", @@ -17129,7 +17127,8 @@ } ], "queries": [], - "sha256": "b3305f400e0d0814f32b00a3c043622a9f7c0b87efb6ebb8d980e3eebf3490ee" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "Upsert CosmosDict response is immediately projected using Mapping.items into a metadata-free domain dictionary.", @@ -17140,8 +17139,7 @@ }, "application/single_app/functions_group_workflows.py::save_group_workflow_run_item": { "boundary": { - "batches": [], - "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956", + "sha256": "d0b2a68046ed60569bfa48313ba29059609b4bf9ba47e41566e5b4de1b4522d4", "points": [ { "method": "upsert_item", @@ -17150,7 +17148,8 @@ } ], "queries": [], - "sha256": "d0b2a68046ed60569bfa48313ba29059609b4bf9ba47e41566e5b4de1b4522d4" + "batches": [], + "module_sha256": "ba82e8112707af1ff4099c7d5070e787967b44304b051b9eb7c9b8a364ddf956" }, "classification": "sdk-compatible", "contract": "Upsert CosmosDict response is immediately projected using Mapping.items into a metadata-free public item dictionary.", @@ -17161,8 +17160,7 @@ }, "application/single_app/functions_image_generation.py::generate_chat_image_message": { "boundary": { - "batches": [], - "module_sha256": "a60da3943007a93c52417c75ce0b6f8d1b64407ef405a04d444b7b08e82bff5a", + "sha256": "f84591ad3631ababa97bad8124d94b3998413f4d5e9d167cce2874d3c39be2a8", "points": [ { "method": "upsert_item", @@ -17176,7 +17174,8 @@ } ], "queries": [], - "sha256": "f84591ad3631ababa97bad8124d94b3998413f4d5e9d167cce2874d3c39be2a8" + "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.", @@ -17185,8 +17184,7 @@ }, "application/single_app/functions_image_messages.py::get_complete_image_content": { "boundary": { - "batches": [], - "module_sha256": "d8e7a7409e3f236cd5308741e0479e8dba94bbe130c816231bf17dc65b1a93aa", + "sha256": "3eabaf85d1d97c233907ebbe124e07a198bbf6a286e6234dd4fddee38bb4d181", "points": [ { "method": "read_item", @@ -17201,7 +17199,8 @@ "response": "consumed" } ], - "sha256": "3eabaf85d1d97c233907ebbe124e07a198bbf6a286e6234dd4fddee38bb4d181" + "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.", @@ -17212,8 +17211,7 @@ }, "application/single_app/functions_keyvault_reminders.py::check_due_key_vault_secret_reminders_once": { "boundary": { - "batches": [], - "module_sha256": "0b40c4876a7a8a096d6ad9e399c0b79aa28a7f5726644ef91e82de544f07ad88", + "sha256": "abcbc62dfbdf7b189d6dbc3f458a4a7d29be825e185dd81ef2725422616271f0", "points": [ { "method": "upsert_item", @@ -17222,7 +17220,8 @@ } ], "queries": [], - "sha256": "abcbc62dfbdf7b189d6dbc3f458a4a7d29be825e185dd81ef2725422616271f0" + "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.", @@ -17231,8 +17230,7 @@ }, "application/single_app/functions_keyvault_reminders.py::list_key_vault_secret_reminders": { "boundary": { - "batches": [], - "module_sha256": "0b40c4876a7a8a096d6ad9e399c0b79aa28a7f5726644ef91e82de544f07ad88", + "sha256": "5adcef66bb2425c406e6f99e92d577c027a3fbb081fbb0810f6fde66893bcc1f", "points": [], "queries": [ { @@ -17241,7 +17239,8 @@ "response": "consumed" } ], - "sha256": "5adcef66bb2425c406e6f99e92d577c027a3fbb081fbb0810f6fde66893bcc1f" + "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.", @@ -17252,8 +17251,7 @@ }, "application/single_app/functions_keyvault_reminders.py::mark_key_vault_secret_reminder_disabled": { "boundary": { - "batches": [], - "module_sha256": "0b40c4876a7a8a096d6ad9e399c0b79aa28a7f5726644ef91e82de544f07ad88", + "sha256": "5764e630b5561ca10e06f1d83728cd36da5bc1263fbb83ec7dc66f1909d95b98", "points": [ { "method": "read_item", @@ -17273,7 +17271,8 @@ "response": "consumed" } ], - "sha256": "5764e630b5561ca10e06f1d83728cd36da5bc1263fbb83ec7dc66f1909d95b98" + "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.", @@ -17284,8 +17283,7 @@ }, "application/single_app/functions_keyvault_reminders.py::upsert_key_vault_secret_reminder": { "boundary": { - "batches": [], - "module_sha256": "0b40c4876a7a8a096d6ad9e399c0b79aa28a7f5726644ef91e82de544f07ad88", + "sha256": "68a720386ee906ad81a21a0a2acedb862ab5c24d2a92a7dfa8fde5e82718a7ec", "points": [ { "method": "read_item", @@ -17299,7 +17297,8 @@ } ], "queries": [], - "sha256": "68a720386ee906ad81a21a0a2acedb862ab5c24d2a92a7dfa8fde5e82718a7ec" + "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.", @@ -17310,8 +17309,7 @@ }, "application/single_app/functions_logging.py::add_file_task_to_file_processing_log": { "boundary": { - "batches": [], - "module_sha256": "aa092f523b2fb4ebda6b7c1b090cde94256c078c11644cc5aac0151bc00cdc68", + "sha256": "457beed78345bc6077c386c4b90354055396b1afc4f51175422f862709a0293c", "points": [ { "method": "create_item", @@ -17320,7 +17318,8 @@ } ], "queries": [], - "sha256": "457beed78345bc6077c386c4b90354055396b1afc4f51175422f862709a0293c" + "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.", @@ -17329,8 +17328,7 @@ }, "application/single_app/functions_logging.py::delete_file_processing_logs": { "boundary": { - "batches": [], - "module_sha256": "aa092f523b2fb4ebda6b7c1b090cde94256c078c11644cc5aac0151bc00cdc68", + "sha256": "bbd78ee77d657f7395637baddc19a0caf283cf78a0e566eca87e035c9bda20b6", "points": [ { "method": "delete_item", @@ -17345,7 +17343,8 @@ "response": "consumed" } ], - "sha256": "bbd78ee77d657f7395637baddc19a0caf283cf78a0e566eca87e035c9bda20b6" + "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.", @@ -17354,8 +17353,7 @@ }, "application/single_app/functions_m365_agent_continuation.py::AgentContinuationJournal._job": { "boundary": { - "batches": [], - "module_sha256": "777fe3b284e3ee4bab85f72d100a6ae8e1a9fad93c2dbc77587275bbd4efc6aa", + "sha256": "38a3c4a38b0331a58845de19f984151fc9b0644859ebab5c56a28728844bf4a1", "points": [ { "method": "read_item", @@ -17374,7 +17372,8 @@ } ], "queries": [], - "sha256": "38a3c4a38b0331a58845de19f984151fc9b0644859ebab5c56a28728844bf4a1" + "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.", @@ -17385,8 +17384,7 @@ }, "application/single_app/functions_m365_agent_continuation.py::AgentContinuationJournal._save_reference": { "boundary": { - "batches": [], - "module_sha256": "777fe3b284e3ee4bab85f72d100a6ae8e1a9fad93c2dbc77587275bbd4efc6aa", + "sha256": "a43164912a9e5c34ae26e81f716e718b107d7dd7b6a9abd36be453a83fdeee4d", "points": [ { "method": "replace_item", @@ -17395,7 +17393,8 @@ } ], "queries": [], - "sha256": "a43164912a9e5c34ae26e81f716e718b107d7dd7b6a9abd36be453a83fdeee4d" + "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.", @@ -17404,6 +17403,9 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService._batch": { "boundary": { + "sha256": "a5ab035924002ea4a15830219c2e5ad3e303f4d222b9e689b2546b5584f10aa4", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -17411,10 +17413,7 @@ "response": "unused" } ], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", - "points": [], - "queries": [], - "sha256": "a5ab035924002ea4a15830219c2e5ad3e303f4d222b9e689b2546b5584f10aa4" + "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.", @@ -17423,8 +17422,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService._create_once": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "3109d7bce82022889d2382fae8c0f26be01e644af0d9c069418746a7c786fd24", "points": [ { "method": "create_item", @@ -17433,7 +17431,8 @@ } ], "queries": [], - "sha256": "3109d7bce82022889d2382fae8c0f26be01e644af0d9c069418746a7c786fd24" + "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.", @@ -17444,6 +17443,9 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService._create_self_authored_binding": { "boundary": { + "sha256": "80bfd6d145a5964e670bc893d789b27685b070a52d3f3767ef1901f197c0aa9f", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -17451,10 +17453,7 @@ "response": "unused" } ], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", - "points": [], - "queries": [], - "sha256": "80bfd6d145a5964e670bc893d789b27685b070a52d3f3767ef1901f197c0aa9f" + "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.", @@ -17463,8 +17462,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService._notify": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "466bd8056f66c645605fde559c93aecf508ba30f35474d8798b729f4ac3ffabd", "points": [ { "method": "replace_item", @@ -17473,7 +17471,8 @@ } ], "queries": [], - "sha256": "466bd8056f66c645605fde559c93aecf508ba30f35474d8798b729f4ac3ffabd" + "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.", @@ -17484,8 +17483,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService._read": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "bc411c2e1b68a6a96377e84a3318448de95a99c3c6a43391a719ab0ce8388631", "points": [ { "method": "read_item", @@ -17494,7 +17492,8 @@ } ], "queries": [], - "sha256": "bc411c2e1b68a6a96377e84a3318448de95a99c3c6a43391a719ab0ce8388631" + "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.", @@ -17505,8 +17504,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService._records": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "2ff7c9aa0e0369858a1d516209fda03eebe2423b91210e17eee7e0812b61c556", "points": [], "queries": [ { @@ -17515,7 +17513,8 @@ "response": "returned" } ], - "sha256": "2ff7c9aa0e0369858a1d516209fda03eebe2423b91210e17eee7e0812b61c556" + "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.", @@ -17526,8 +17525,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService.claim_continuation": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "7de9e649ab3052edd557e66f44d7d41aff69f6533f2f22a31c1c64cb1671bbf2", "points": [ { "method": "replace_item", @@ -17536,7 +17534,8 @@ } ], "queries": [], - "sha256": "7de9e649ab3052edd557e66f44d7d41aff69f6533f2f22a31c1c64cb1671bbf2" + "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.", @@ -17545,8 +17544,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService.expire_pending": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "29e62460fcd984b36c7bb031b0ed4751102f21b0c13c4850f1971d2bc12959e8", "points": [], "queries": [ { @@ -17555,7 +17553,8 @@ "response": "consumed" } ], - "sha256": "29e62460fcd984b36c7bb031b0ed4751102f21b0c13c4850f1971d2bc12959e8" + "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.", @@ -17566,8 +17565,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService.list_conversation_audit": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "e2b822f0ed7756df009298b18a1bbd8626957447613826e9cc63fbcaccfae817", "points": [], "queries": [ { @@ -17576,7 +17574,8 @@ "response": "consumed" } ], - "sha256": "e2b822f0ed7756df009298b18a1bbd8626957447613826e9cc63fbcaccfae817" + "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.", @@ -17587,8 +17586,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService.list_pending_continuations": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "14f6d1acfea9a20f8514ea1ad51af8f84c434b22a588d64532101cfd12a938dc", "points": [], "queries": [ { @@ -17597,7 +17595,8 @@ "response": "consumed" } ], - "sha256": "14f6d1acfea9a20f8514ea1ad51af8f84c434b22a588d64532101cfd12a938dc" + "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.", @@ -17608,8 +17607,7 @@ }, "application/single_app/functions_m365_approvals.py::M365ApprovalService.list_records": { "boundary": { - "batches": [], - "module_sha256": "3b7675037d17f3f74b45bd3dff37d1aaadbf9d60297fd379e579c5e7971eaac5", + "sha256": "e79d493fa22a320459fc3847f5c94a13d62e57c11f68f9d9c9c61784ec771a8a", "points": [], "queries": [ { @@ -17618,7 +17616,8 @@ "response": "consumed" } ], - "sha256": "e79d493fa22a320459fc3847f5c94a13d62e57c11f68f9d9c9c61784ec771a8a" + "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.", @@ -17629,8 +17628,7 @@ }, "application/single_app/functions_m365_connections.py::M365ConnectionService._ensure_connection": { "boundary": { - "batches": [], - "module_sha256": "b7e44c027116916d873943b657a51487f726dda36f1732a2799eca3d13886629", + "sha256": "06571ba9c0632569d03f745fcfe489f929832b186115cf715eea0f84ab6b30b6", "points": [ { "method": "create_item", @@ -17639,7 +17637,8 @@ } ], "queries": [], - "sha256": "06571ba9c0632569d03f745fcfe489f929832b186115cf715eea0f84ab6b30b6" + "batches": [], + "module_sha256": "b7e44c027116916d873943b657a51487f726dda36f1732a2799eca3d13886629" }, "classification": "sdk-compatible", "contract": "New chat and workflow records have separate identifiers and kinds. Created SDK mappings enter only binding field reads and conditional cache persistence, never exact-dict domain validation.", @@ -17650,8 +17649,7 @@ }, "application/single_app/functions_m365_connections.py::M365ConnectionService._read": { "boundary": { - "batches": [], - "module_sha256": "b7e44c027116916d873943b657a51487f726dda36f1732a2799eca3d13886629", + "sha256": "5701c522de37b955d94183789200765c5f3742f65a153c522dd9fbec99b34461", "points": [ { "method": "read_item", @@ -17660,7 +17658,8 @@ } ], "queries": [], - "sha256": "5701c522de37b955d94183789200765c5f3742f65a153c522dd9fbec99b34461" + "batches": [], + "module_sha256": "b7e44c027116916d873943b657a51487f726dda36f1732a2799eca3d13886629" }, "classification": "sdk-compatible", "contract": "Chat and workflow owners consume SDK point mappings through field reads, copy dict projections, and ETag-conditional writes; encrypted cache binding includes record kind and generation.", @@ -17671,8 +17670,7 @@ }, "application/single_app/functions_m365_connections.py::M365ConnectionService._replace": { "boundary": { - "batches": [], - "module_sha256": "b7e44c027116916d873943b657a51487f726dda36f1732a2799eca3d13886629", + "sha256": "2478fb2888e536ab40978c343ce2e659bf3e1c541359a479a360ffc19ac15398", "points": [ { "method": "replace_item", @@ -17681,7 +17679,8 @@ } ], "queries": [], - "sha256": "2478fb2888e536ab40978c343ce2e659bf3e1c541359a479a360ffc19ac15398" + "batches": [], + "module_sha256": "b7e44c027116916d873943b657a51487f726dda36f1732a2799eca3d13886629" }, "classification": "sdk-compatible", "contract": "Conditional replacements route by the authorized user_id in the body, preserve ETag ownership, and return field-read SDK mappings for chat and workflow credentials.", @@ -17692,8 +17691,7 @@ }, "application/single_app/functions_m365_connections.py::M365ConnectionService.start_connection": { "boundary": { - "batches": [], - "module_sha256": "b7e44c027116916d873943b657a51487f726dda36f1732a2799eca3d13886629", + "sha256": "f311893a8487e66263903cf506fbccc0c3b9ff28d189f013a2c58950d7efea85", "points": [ { "method": "create_item", @@ -17702,7 +17700,8 @@ } ], "queries": [], - "sha256": "f311893a8487e66263903cf506fbccc0c3b9ff28d189f013a2c58950d7efea85" + "batches": [], + "module_sha256": "b7e44c027116916d873943b657a51487f726dda36f1732a2799eca3d13886629" }, "classification": "response-unused", "contract": "The OAuth flow create response is discarded; the protected local flow fields are used for the authorization URL. Workflow create failures remain visible.", @@ -17710,8 +17709,7 @@ }, "application/single_app/functions_m365_continuations.py::_fail_deleted_workflow": { "boundary": { - "batches": [], - "module_sha256": "75e4481db115f322d8b6ceede395e28ff20dee828de691b3f1e46742f96ce3dc", + "sha256": "10d9349b1c74318c6b96945662a92c6f5cbd6b32bde554b8271181dfe00bd1fe", "points": [ { "method": "replace_item", @@ -17720,7 +17718,8 @@ } ], "queries": [], - "sha256": "10d9349b1c74318c6b96945662a92c6f5cbd6b32bde554b8271181dfe00bd1fe" + "batches": [], + "module_sha256": "75e4481db115f322d8b6ceede395e28ff20dee828de691b3f1e46742f96ce3dc" }, "classification": "response-unused", "contract": "The continuation's own failed/workflow_deleted/completed_at projection is conditionally replaced with its snapshot ETag; the SDK write response is unused. No pending-delivery lifecycle fields are applied.", @@ -17730,8 +17729,7 @@ }, "application/single_app/functions_m365_continuations.py::resume_pending_workflows": { "boundary": { - "batches": [], - "module_sha256": "75e4481db115f322d8b6ceede395e28ff20dee828de691b3f1e46742f96ce3dc", + "sha256": "63da48177fb86ac078d48d86c36a36d047ec5c6af7aeb3c4f7b5057abc42f6b9", "points": [ { "method": "replace_item", @@ -17761,7 +17759,8 @@ "response": "consumed" } ], - "sha256": "63da48177fb86ac078d48d86c36a36d047ec5c6af7aeb3c4f7b5057abc42f6b9" + "batches": [], + "module_sha256": "75e4481db115f322d8b6ceede395e28ff20dee828de691b3f1e46742f96ce3dc" }, "classification": "sdk-compatible", "contract": "Candidates are plain query rows; the returned claim is an SDK mapping consumed by field reads and expanded into conditional state projections. ETag conflicts preserve newer approval/cancellation/claims; uncertain effects remain recovery_required without replay. No strict whole-document JSON sink consumes the SDK wrapper.", @@ -17773,8 +17772,7 @@ }, "application/single_app/functions_m365_file_runtime.py::resolve_m365_budget_run": { "boundary": { - "batches": [], - "module_sha256": "c621a160a202ca8e92cde73b76d8264f4165ae0859d2b90a7670ac8d5e8b444d", + "sha256": "4fcd38af27c9c4047a3922353919555a9c378b648ab849c61d1d585f8d3549ed", "points": [ { "method": "read_item", @@ -17803,7 +17801,8 @@ } ], "queries": [], - "sha256": "4fcd38af27c9c4047a3922353919555a9c378b648ab849c61d1d585f8d3549ed" + "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.", @@ -17814,8 +17813,7 @@ }, "application/single_app/functions_m365_history.py::M365HistoryService.prepare": { "boundary": { - "batches": [], - "module_sha256": "f7d090e10c507826cae67b1f5ed0e88a4cd92224f214c28241b7168732cd63dd", + "sha256": "c54c18eaa7c82499a4350b150180e9469c436bc00bdbff7725df160148b00c77", "points": [ { "method": "upsert_item", @@ -17834,7 +17832,8 @@ } ], "queries": [], - "sha256": "c54c18eaa7c82499a4350b150180e9469c436bc00bdbff7725df160148b00c77" + "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.", @@ -17843,8 +17842,7 @@ }, "application/single_app/functions_m365_history.py::M365HistoryService.validate_decision": { "boundary": { - "batches": [], - "module_sha256": "f7d090e10c507826cae67b1f5ed0e88a4cd92224f214c28241b7168732cd63dd", + "sha256": "f1d8dc5ceeee632d714e5a986d9638558753b3666eee6d23ee3c8cf364444b4b", "points": [ { "method": "read_item", @@ -17853,7 +17851,8 @@ } ], "queries": [], - "sha256": "f1d8dc5ceeee632d714e5a986d9638558753b3666eee6d23ee3c8cf364444b4b" + "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.", @@ -17864,8 +17863,7 @@ }, "application/single_app/functions_m365_pending_delivery.py::_read_delivery": { "boundary": { - "batches": [], - "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f", + "sha256": "d2728311c4be65a4f417fa73e7300339ff71ca17657595600c1e525eb339fc4b", "points": [ { "method": "read_item", @@ -17874,20 +17872,20 @@ } ], "queries": [], - "sha256": "d2728311c4be65a4f417fa73e7300339ff71ca17657595600c1e525eb339fc4b" + "batches": [], + "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f" }, "classification": "normalized-strict", "contract": "Normalize owner-partitioned point reads before delivery/edit material validation; preserve the claim ETag.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_review.py" + "functional_tests/test_m365_pending_review.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_pending_delivery.py::_save_claimed_outcome": { "boundary": { - "batches": [], - "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f", + "sha256": "bcc8ba13ef14fe096b7207e5d517b856d014ff3f8c20f3e1a228f09a164d117c", "points": [ { "method": "replace_item", @@ -17896,20 +17894,20 @@ } ], "queries": [], - "sha256": "bcc8ba13ef14fe096b7207e5d517b856d014ff3f8c20f3e1a228f09a164d117c" + "batches": [], + "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f" }, "classification": "normalized-strict", "contract": "Normalize the conditional outcome write before terminal history cleanup and publication; conflicts never authorize replay.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_review.py" + "functional_tests/test_m365_pending_review.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_pending_delivery.py::cancel_m365_conversation_deliveries": { "boundary": { - "batches": [], - "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f", + "sha256": "fc4ff5f6544051c85fc2c6bf69d0bad7b5330af9b77736bbb2f437a6bd9b1b94", "points": [], "queries": [ { @@ -17918,20 +17916,20 @@ "response": "consumed" } ], - "sha256": "fc4ff5f6544051c85fc2c6bf69d0bad7b5330af9b77736bbb2f437a6bd9b1b94" + "batches": [], + "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f" }, "classification": "sdk-compatible", "contract": "Authorized conversation cancellation consumes plain query rows and preserves current conditional claims.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_review.py" + "functional_tests/test_m365_pending_review.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_pending_delivery.py::cancel_m365_run_deliveries": { "boundary": { - "batches": [], - "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f", + "sha256": "93e74d510151c23e29b45eda5de74d8c10ec4c28fe430c2f8e7200aff029b1b8", "points": [], "queries": [ { @@ -17940,20 +17938,20 @@ "response": "consumed" } ], - "sha256": "93e74d510151c23e29b45eda5de74d8c10ec4c28fe430c2f8e7200aff029b1b8" + "batches": [], + "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f" }, "classification": "sdk-compatible", "contract": "Authorized run cancellation consumes plain query rows, not SDK point wrappers.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_review.py" + "functional_tests/test_m365_pending_review.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_pending_delivery.py::dispatch_due_m365_deliveries": { "boundary": { - "batches": [], - "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f", + "sha256": "f24659e984c4d20cd189dba27efb28849c31a7e0c858de84a4b4131cca24e12c", "points": [ { "method": "replace_item", @@ -17978,20 +17976,20 @@ "response": "consumed" } ], - "sha256": "f24659e984c4d20cd189dba27efb28849c31a7e0c858de84a4b4131cca24e12c" + "batches": [], + "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f" }, "classification": "sdk-compatible", "contract": "Scheduled worker consumes plain query rows and returned write mappings through field access; expired/unknown claims never repeat delivery.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_review.py" + "functional_tests/test_m365_pending_review.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_pending_delivery.py::dispatch_m365_pending_delivery": { "boundary": { - "batches": [], - "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f", + "sha256": "1952741e6466c513cc84ffb2367d04d3ee8e3656431bf49d50a4145b23485753", "points": [ { "method": "replace_item", @@ -18005,20 +18003,20 @@ } ], "queries": [], - "sha256": "1952741e6466c513cc84ffb2367d04d3ee8e3656431bf49d50a4145b23485753" + "batches": [], + "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f" }, "classification": "sdk-compatible", "contract": "Conditional claim write is a mapping consumed by field access/spread; outcome storage normalizes before current-card publication. Draft POST is irreversible and cannot replay on uncertain outcome.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_review.py" + "functional_tests/test_m365_pending_review.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_pending_delivery.py::notify_m365_pending_delivery": { "boundary": { - "batches": [], - "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f", + "sha256": "b8964d89647848fdb5b3e0665e7c78d490d9e86b17a149cbff287e4299b717fd", "points": [ { "method": "read_item", @@ -18032,20 +18030,20 @@ } ], "queries": [], - "sha256": "b8964d89647848fdb5b3e0665e7c78d490d9e86b17a149cbff287e4299b717fd" + "batches": [], + "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f" }, "classification": "sdk-compatible", "contract": "Notification read/write mappings supply only identity/state fields and safe JSON display metadata.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_review.py" + "functional_tests/test_m365_pending_review.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_pending_delivery.py::refresh_m365_sent_link": { "boundary": { - "batches": [], - "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f", + "sha256": "5d6aad2753417b82e746e569718468a86672c8cb864cc2d053c437dcbfbb55a8", "points": [ { "method": "replace_item", @@ -18059,20 +18057,20 @@ } ], "queries": [], - "sha256": "5d6aad2753417b82e746e569718468a86672c8cb864cc2d053c437dcbfbb55a8" + "batches": [], + "module_sha256": "1eb0125daecc6ce3628d79865e60d2bbd2375adc29011e6e70d13a2db8af5b4f" }, "classification": "normalized-strict", "contract": "Normalize the conditional read-only link write before publication; a lookup cannot change accepted delivery into an actionable state.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_review.py" + "functional_tests/test_m365_pending_review.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_pending_review.py::_read_owned": { "boundary": { - "batches": [], - "module_sha256": "262820312ec47c3cd913fad68308cf599e237de88f259fe2b0310c214c0f84fd", + "sha256": "cb6b2ee76d0e478237a929b893709cac9f60419cc6aa67e0c17e02144e543e1b", "points": [ { "method": "read_item", @@ -18081,7 +18079,8 @@ } ], "queries": [], - "sha256": "cb6b2ee76d0e478237a929b893709cac9f60419cc6aa67e0c17e02144e543e1b" + "batches": [], + "module_sha256": "262820312ec47c3cd913fad68308cf599e237de88f259fe2b0310c214c0f84fd" }, "classification": "normalized-strict", "contract": "Normalize the owned action point read before copying review material, exact-dictionary field validation and version checks; enforce owner and current scope.", @@ -18092,8 +18091,7 @@ }, "application/single_app/functions_m365_pending_review.py::save_pending_review": { "boundary": { - "batches": [], - "module_sha256": "262820312ec47c3cd913fad68308cf599e237de88f259fe2b0310c214c0f84fd", + "sha256": "d7aaefcf24a526249d1c2243f51e1f8e2e603e4a3f724f3df2855e66ccc77909", "points": [ { "method": "replace_item", @@ -18112,7 +18110,8 @@ } ], "queries": [], - "sha256": "d7aaefcf24a526249d1c2243f51e1f8e2e603e4a3f724f3df2855e66ccc77909" + "batches": [], + "module_sha256": "262820312ec47c3cd913fad68308cf599e237de88f259fe2b0310c214c0f84fd" }, "classification": "normalized-strict", "contract": "Normalize the edit-claim write before history transaction/material handling. Conditional Graph PATCH and owner-partition batch preserve ETags; lost acknowledgements never overwrite a committed newer revision.", @@ -18123,8 +18122,7 @@ }, "application/single_app/functions_m365_request_resume.py::_execute_chat_continuation": { "boundary": { - "batches": [], - "module_sha256": "a6f545de1ed2f9428c30a5c16a716da29742723dcfb0dcd23239c320ad502010", + "sha256": "bca40cc675f16a2817b46f48162d5432a842c5776942db6df3aa2734d74c0a97", "points": [ { "method": "read_item", @@ -18153,7 +18151,8 @@ } ], "queries": [], - "sha256": "bca40cc675f16a2817b46f48162d5432a842c5776942db6df3aa2734d74c0a97" + "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.", @@ -18164,8 +18163,7 @@ }, "application/single_app/functions_m365_request_resume.py::_queue_chat_job": { "boundary": { - "batches": [], - "module_sha256": "a6f545de1ed2f9428c30a5c16a716da29742723dcfb0dcd23239c320ad502010", + "sha256": "30030c2ec8012411a10e5b5b1919a9ce13218c6ae525b07ee898715ddcb8e559", "points": [ { "method": "replace_item", @@ -18184,7 +18182,8 @@ } ], "queries": [], - "sha256": "30030c2ec8012411a10e5b5b1919a9ce13218c6ae525b07ee898715ddcb8e559" + "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.", @@ -18195,8 +18194,7 @@ }, "application/single_app/functions_m365_request_resume.py::get_m365_chat_request": { "boundary": { - "batches": [], - "module_sha256": "a6f545de1ed2f9428c30a5c16a716da29742723dcfb0dcd23239c320ad502010", + "sha256": "0b8d9f5421b663b3e82ec20e6b896c5815b89aa71bb85b1ae84a23da3222472b", "points": [ { "method": "read_item", @@ -18205,7 +18203,8 @@ } ], "queries": [], - "sha256": "0b8d9f5421b663b3e82ec20e6b896c5815b89aa71bb85b1ae84a23da3222472b" + "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.", @@ -18216,8 +18215,7 @@ }, "application/single_app/functions_m365_request_resume.py::queue_approved_chat": { "boundary": { - "batches": [], - "module_sha256": "a6f545de1ed2f9428c30a5c16a716da29742723dcfb0dcd23239c320ad502010", + "sha256": "35b789fdb83fb382ba1c5964e714007b590f5622963b2ecca8116a513c67a1ea", "points": [ { "method": "read_item", @@ -18226,7 +18224,8 @@ } ], "queries": [], - "sha256": "35b789fdb83fb382ba1c5964e714007b590f5622963b2ecca8116a513c67a1ea" + "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.", @@ -18237,8 +18236,7 @@ }, "application/single_app/functions_m365_review_history.py::clear_review_history": { "boundary": { - "batches": [], - "module_sha256": "466555e650a2a70010caeec2c139f1f1b53722212ab4fd59f43b2a163c24559e", + "sha256": "12b8e3ca56795d2be70a467afcc9fc2798e886bca1218568a686de88889daed2", "points": [ { "method": "delete_item", @@ -18247,7 +18245,8 @@ } ], "queries": [], - "sha256": "12b8e3ca56795d2be70a467afcc9fc2798e886bca1218568a686de88889daed2" + "batches": [], + "module_sha256": "466555e650a2a70010caeec2c139f1f1b53722212ab4fd59f43b2a163c24559e" }, "classification": "response-unused", "contract": "The owner-partitioned terminal history deletion response is unused; cleanup never deletes the delivery receipt.", @@ -18258,14 +18257,7 @@ }, "application/single_app/functions_m365_review_history.py::commit_review_history": { "boundary": { - "batches": [ - { - "method": "execute_item_batch", - "receiver": "container", - "response": "unused" - } - ], - "module_sha256": "466555e650a2a70010caeec2c139f1f1b53722212ab4fd59f43b2a163c24559e", + "sha256": "b9ab0c4e7c6727f92633f213ccadc6a403721d415a1f8e904c4f523033e0d4ae", "points": [ { "method": "read_item", @@ -18274,7 +18266,14 @@ } ], "queries": [], - "sha256": "b9ab0c4e7c6727f92633f213ccadc6a403721d415a1f8e904c4f523033e0d4ae" + "batches": [ + { + "method": "execute_item_batch", + "receiver": "container", + "response": "unused" + } + ], + "module_sha256": "466555e650a2a70010caeec2c139f1f1b53722212ab4fd59f43b2a163c24559e" }, "classification": "normalized-strict", "contract": "History point reads are normalized before deepcopy; owner-partition action/history batch returns are unused. Normalize the final action read before returning its current revision.", @@ -18285,8 +18284,7 @@ }, "application/single_app/functions_m365_review_history.py::read_review_history": { "boundary": { - "batches": [], - "module_sha256": "466555e650a2a70010caeec2c139f1f1b53722212ab4fd59f43b2a163c24559e", + "sha256": "398667aa7022431a8ab9471dca3c531de90943927dc780580fd26a5688fea0e3", "points": [ { "method": "read_item", @@ -18295,7 +18293,8 @@ } ], "queries": [], - "sha256": "398667aa7022431a8ab9471dca3c531de90943927dc780580fd26a5688fea0e3" + "batches": [], + "module_sha256": "466555e650a2a70010caeec2c139f1f1b53722212ab4fd59f43b2a163c24559e" }, "classification": "normalized-strict", "contract": "Normalize owner-partitioned history point reads before copying stored JSON, preserving the ETag for conditional history writes and verifying action/owner identity.", @@ -18306,8 +18305,7 @@ }, "application/single_app/functions_m365_runtime.py::_begin_step_m365_request": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "1a0d49690da4403001806ce06036feab699410c719d35f3cfbc7bad0aa6967d9", "points": [ { "method": "read_item", @@ -18326,20 +18324,20 @@ } ], "queries": [], - "sha256": "1a0d49690da4403001806ce06036feab699410c719d35f3cfbc7bad0aa6967d9" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "SDK request point mappings supply current actor/scope fields; conditional writes build plain projections. No point wrapper reaches a strict domain envelope.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_orchestration_operation_runtime.py", - "functional_tests/test_m365_runtime_adapters.py" + "functional_tests/test_m365_runtime_adapters.py", + "functional_tests/test_orchestration_operation_runtime.py" ] }, "application/single_app/functions_m365_runtime.py::_conversation_access": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "e94df4808e4592ec18eb9010d8fcd6f09e3abc0903cee71514ff65d980e92f80", "points": [ { "method": "read_item", @@ -18348,7 +18346,8 @@ } ], "queries": [], - "sha256": "e94df4808e4592ec18eb9010d8fcd6f09e3abc0903cee71514ff65d980e92f80" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Conversation point mappings are field-read to enforce current ownership or participation access; no exact-dictionary document contract is entered.", @@ -18360,8 +18359,7 @@ }, "application/single_app/functions_m365_runtime.py::_finish_step_m365_request": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "dfbde90b1416ac2b5eec4dd32401533a2741fad99fa3883957faabbb7d6f0e0a", "points": [ { "method": "read_item", @@ -18375,20 +18373,20 @@ } ], "queries": [], - "sha256": "dfbde90b1416ac2b5eec4dd32401533a2741fad99fa3883957faabbb7d6f0e0a" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Step request point mappings supply saved state fields and ETags for conditional status projections; nested result values remain plain JSON.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_orchestration_operation_runtime.py", - "functional_tests/test_m365_runtime_adapters.py" + "functional_tests/test_m365_runtime_adapters.py", + "functional_tests/test_orchestration_operation_runtime.py" ] }, "application/single_app/functions_m365_runtime.py::_save_m365_wait_record": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "2797013dea000e9806d96b32c6e43c53ddc924102879b15533a1c48f4555de78", "points": [ { "method": "replace_item", @@ -18402,7 +18400,8 @@ } ], "queries": [], - "sha256": "2797013dea000e9806d96b32c6e43c53ddc924102879b15533a1c48f4555de78" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "response-unused", "contract": "Wait-record create/replace responses are unused; conflicts and storage failures remain visible.", @@ -18412,8 +18411,7 @@ }, "application/single_app/functions_m365_runtime.py::cancel_m365_workflow_requests": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "f92501ebe5ab9902fa3034ed1f67086ff91b31dac29aa8cdd142e8f93a59ad0f", "points": [ { "method": "replace_item", @@ -18428,7 +18426,8 @@ "response": "consumed" } ], - "sha256": "f92501ebe5ab9902fa3034ed1f67086ff91b31dac29aa8cdd142e8f93a59ad0f" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "response-unused", "contract": "Cancellation field-reads plain query rows, conditionally updates the continuation's own status and discards SDK point write responses.", @@ -18438,8 +18437,7 @@ }, "application/single_app/functions_m365_runtime.py::complete_m365_request": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "3f7312d6e3535ba4ecb3b081d3ab6a64de5a2c16ef115231ecf667221b822727", "points": [ { "method": "read_item", @@ -18453,7 +18451,8 @@ } ], "queries": [], - "sha256": "3f7312d6e3535ba4ecb3b081d3ab6a64de5a2c16ef115231ecf667221b822727" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Completion point mappings supply current identity/status/ETag fields for conditional writes. SDK mapping mutation is supported and no strict result sink consumes the whole record.", @@ -18465,8 +18464,7 @@ }, "application/single_app/functions_m365_runtime.py::configure_m365_history_runtime.has_active_request": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "6422ab69881531452236ad4c61df7b7fd31f6abf27ad7921a9759c45738d9611", "points": [], "queries": [ { @@ -18475,7 +18473,8 @@ "response": "consumed" } ], - "sha256": "6422ab69881531452236ad4c61df7b7fd31f6abf27ad7921a9759c45738d9611" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "The active-request existence check consumes plain query rows, not point response wrappers.", @@ -18486,8 +18485,7 @@ }, "application/single_app/functions_m365_runtime.py::configure_m365_history_runtime.read_conversation": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "81f74cc8de28bd0ab1fb0ca3a7cc6b7a2b8516ff6857d19fdb0145d2141e641c", "points": [ { "method": "read_item", @@ -18496,7 +18494,8 @@ } ], "queries": [], - "sha256": "81f74cc8de28bd0ab1fb0ca3a7cc6b7a2b8516ff6857d19fdb0145d2141e641c" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "History authorization receives conversation SDK point mappings and consumes identity fields; no exact-dictionary document sink is introduced.", @@ -18507,8 +18506,7 @@ }, "application/single_app/functions_m365_runtime.py::configure_m365_history_runtime.read_messages": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "0865df916310260aa1726aa65944a839bed4e99d2f260ae3843cc73550c6e281", "points": [], "queries": [ { @@ -18517,7 +18515,8 @@ "response": "returned" } ], - "sha256": "0865df916310260aa1726aa65944a839bed4e99d2f260ae3843cc73550c6e281" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "History reader returns plain query rows to field-projection consumers; these are not SDK point wrappers.", @@ -18528,8 +18527,7 @@ }, "application/single_app/functions_m365_runtime.py::configure_m365_pending_delivery_runtime.capture_step_reference": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "9adff3d7f8d79231da3a2efb48b11c8c1d9d76ece4c376ead4744043120093e1", "points": [ { "method": "read_item", @@ -18538,7 +18536,8 @@ } ], "queries": [], - "sha256": "9adff3d7f8d79231da3a2efb48b11c8c1d9d76ece4c376ead4744043120093e1" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Execution request SDK mappings supply actor/conversation/run fields; exact owned plan reauthorization produces plain provenance strings rather than trusting browser or tool identifiers.", @@ -18549,8 +18548,7 @@ }, "application/single_app/functions_m365_runtime.py::configure_m365_pending_delivery_runtime.delivery_context": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "aaa98ff7ca4c425aa186a13e30f60ed691318dd0226ebfa3629ec389e4806d3a", "points": [ { "method": "read_item", @@ -18559,20 +18557,20 @@ } ], "queries": [], - "sha256": "aaa98ff7ca4c425aa186a13e30f60ed691318dd0226ebfa3629ec389e4806d3a" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "The request SDK mapping is field-read and reauthorized against current actor, conversation, selected capability and owned plan before token/transport work.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_pending_authorization.py", - "functional_tests/test_m365_pending_action_provenance.py" + "functional_tests/test_m365_pending_action_provenance.py", + "functional_tests/test_m365_pending_authorization.py" ] }, "application/single_app/functions_m365_runtime.py::ensure_m365_execution_record": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "5848d54df3d21b12d05977ceb0ce9100152aa812107904cadc036b6df61b3fa7", "points": [ { "method": "read_item", @@ -18591,21 +18589,21 @@ } ], "queries": [], - "sha256": "5848d54df3d21b12d05977ceb0ce9100152aa812107904cadc036b6df61b3fa7" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Point execution mappings supply current request identity fields; SDK responses retain ETags for conditional state changes and are not strict result envelopes.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_m365_pending_authorization.py", - "functional_tests/test_orchestration_operation_runtime.py", - "functional_tests/test_m365_runtime_adapters.py" + "functional_tests/test_m365_runtime_adapters.py", + "functional_tests/test_orchestration_operation_runtime.py" ] }, "application/single_app/functions_m365_runtime.py::initialize_m365_chat_context": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "78c3195f52aa2130c40796040e6dd9dbb131c76fdf54873ee894250de3977992", "points": [ { "method": "replace_item", @@ -18614,7 +18612,8 @@ } ], "queries": [], - "sha256": "78c3195f52aa2130c40796040e6dd9dbb131c76fdf54873ee894250de3977992" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "response-unused", "contract": "Context-initialization conditional write responses are unused; failures are not hidden.", @@ -18624,8 +18623,7 @@ }, "application/single_app/functions_m365_runtime.py::load_current_workflow": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "03033aa434b0c8b273fc0f86ff205142a605f76ad6a0f32507ed4f57082b3f9a", "points": [ { "method": "read_item", @@ -18634,7 +18632,8 @@ } ], "queries": [], - "sha256": "03033aa434b0c8b273fc0f86ff205142a605f76ad6a0f32507ed4f57082b3f9a" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "normalized-strict", "contract": "The exact personal/group partition point response is normalized before metadata projection and alert/editor contracts. Only an authoritative scoped 404 or stored deletion tombstone produces m365_workflow_missing; authorization, invalid responses and transient storage failures propagate. Real SDK tests preserve the existing plain editor projection.", @@ -18645,8 +18644,7 @@ }, "application/single_app/functions_m365_runtime.py::read_pending_m365_chat_request": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "c35a9095736a4c9f4752403fb57273c2099bfa3dc7ffcf1bee0e49d3d4bcaf58", "points": [ { "method": "read_item", @@ -18655,7 +18653,8 @@ } ], "queries": [], - "sha256": "c35a9095736a4c9f4752403fb57273c2099bfa3dc7ffcf1bee0e49d3d4bcaf58" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Pending-request SDK point mappings supply current status and bound identity fields before owned context restoration.", @@ -18667,8 +18666,7 @@ }, "application/single_app/functions_m365_runtime.py::record_m365_auth_wait": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "af8dd5ee33d78057062dbf8716aa293f6547a8fe074c1ced26ddcc95a7486758", "points": [ { "method": "read_item", @@ -18677,20 +18675,20 @@ } ], "queries": [], - "sha256": "af8dd5ee33d78057062dbf8716aa293f6547a8fe074c1ced26ddcc95a7486758" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Authentication wait SDK point mappings supply prior conditional request state, not credential or domain result envelopes; persisted records are plain projections.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_runtime_adapters.py", - "functional_tests/test_m365_pending_authorization.py" + "functional_tests/test_m365_pending_authorization.py", + "functional_tests/test_m365_runtime_adapters.py" ] }, "application/single_app/functions_m365_runtime.py::record_m365_pending": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "f6ea113efe3512445b7deb94d22934253f4433ee516f27256c4918792f396459", "points": [ { "method": "read_item", @@ -18699,7 +18697,8 @@ } ], "queries": [], - "sha256": "f6ea113efe3512445b7deb94d22934253f4433ee516f27256c4918792f396459" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Pending request SDK mappings are field-read and projected for durable wait state; nested result payloads remain plain JSON and conditional writes retain the prior ETag.", @@ -18711,8 +18710,7 @@ }, "application/single_app/functions_m365_runtime.py::validate_m365_approval_decision": { "boundary": { - "batches": [], - "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e", + "sha256": "4f826c8ed178865620e59ab6d82d67decd6beec8bacbeef0ce461230d69b4981", "points": [ { "method": "read_item", @@ -18721,7 +18719,8 @@ } ], "queries": [], - "sha256": "4f826c8ed178865620e59ab6d82d67decd6beec8bacbeef0ce461230d69b4981" + "batches": [], + "module_sha256": "1929651d37301e0b3c6b470c5aff19102fabbc96dd123be0278874ec2aa2bd2e" }, "classification": "sdk-compatible", "contract": "Approval decisions field-read the saved request SDK mapping and revalidate identity, current workflow state and existing grants before permitting execution.", @@ -18733,8 +18732,7 @@ }, "application/single_app/functions_m365_workflow_checkpoints.py::read_m365_task_checkpoint": { "boundary": { - "batches": [], - "module_sha256": "f45108154d13ed770437c100c697604b36f43f7085a02641d3f9253d17630bf8", + "sha256": "3ecca6cc5278e1089576108f05fff9b2aa804f628e8ccfa2cfcf72ee051ac3c1", "points": [ { "method": "read_item", @@ -18743,7 +18741,8 @@ } ], "queries": [], - "sha256": "3ecca6cc5278e1089576108f05fff9b2aa804f628e8ccfa2cfcf72ee051ac3c1" + "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.", @@ -18754,8 +18753,7 @@ }, "application/single_app/functions_m365_workflow_checkpoints.py::save_m365_task_checkpoint": { "boundary": { - "batches": [], - "module_sha256": "f45108154d13ed770437c100c697604b36f43f7085a02641d3f9253d17630bf8", + "sha256": "cf551d0f20fdbff945bd7d6b3132d0a136a309d8602740a0e83cf2cf84542ccf", "points": [ { "method": "read_item", @@ -18769,7 +18767,8 @@ } ], "queries": [], - "sha256": "cf551d0f20fdbff945bd7d6b3132d0a136a309d8602740a0e83cf2cf84542ccf" + "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.", @@ -18780,8 +18779,7 @@ }, "application/single_app/functions_mcp_server_enterprise.py::check_inbound_mcp_tool_rate_limit": { "boundary": { - "batches": [], - "module_sha256": "949892aba844ba1cc8d6dbbdcb15039f4b8ee065ed8746ac899a241b310044d1", + "sha256": "483022f6b457fcebf07a6930e11487c6a112930fc3d3165ecbb7a7414d4a1ed2", "points": [ { "method": "read_item", @@ -18800,7 +18798,8 @@ } ], "queries": [], - "sha256": "483022f6b457fcebf07a6930e11487c6a112930fc3d3165ecbb7a7414d4a1ed2" + "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.", @@ -18811,8 +18810,7 @@ }, "application/single_app/functions_mcp_server_tools.py::_authorize_personal_conversation_read": { "boundary": { - "batches": [], - "module_sha256": "1be21d1cdcb00f00f725f438b47a498872b52f44500d0afbd64e31535c9fd08e", + "sha256": "1c73b8fa565e26035e7c6b24a0f751a6bb5e44db78ee6df30be7a4ca316c4dfc", "points": [ { "method": "read_item", @@ -18821,7 +18819,8 @@ } ], "queries": [], - "sha256": "1c73b8fa565e26035e7c6b24a0f751a6bb5e44db78ee6df30be7a4ca316c4dfc" + "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.", @@ -18832,8 +18831,7 @@ }, "application/single_app/functions_mcp_server_tools.py::_load_legacy_messages": { "boundary": { - "batches": [], - "module_sha256": "1be21d1cdcb00f00f725f438b47a498872b52f44500d0afbd64e31535c9fd08e", + "sha256": "d67081cb0a441b0e02a3c300d8144c2b12deba58d5d4de626bca00772c533557", "points": [], "queries": [ { @@ -18842,7 +18840,8 @@ "response": "consumed" } ], - "sha256": "d67081cb0a441b0e02a3c300d8144c2b12deba58d5d4de626bca00772c533557" + "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.", @@ -18853,8 +18852,7 @@ }, "application/single_app/functions_mcp_server_tools.py::_load_legacy_personal_conversations": { "boundary": { - "batches": [], - "module_sha256": "1be21d1cdcb00f00f725f438b47a498872b52f44500d0afbd64e31535c9fd08e", + "sha256": "e5cec58019e23a47d31e943d9e00679cf292f59703e32c5c33ea524de7ba8c3b", "points": [], "queries": [ { @@ -18863,7 +18861,8 @@ "response": "consumed" } ], - "sha256": "e5cec58019e23a47d31e943d9e00679cf292f59703e32c5c33ea524de7ba8c3b" + "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.", @@ -18874,8 +18873,7 @@ }, "application/single_app/functions_mcp_server_tools.py::_load_personal_prompt_page": { "boundary": { - "batches": [], - "module_sha256": "1be21d1cdcb00f00f725f438b47a498872b52f44500d0afbd64e31535c9fd08e", + "sha256": "30188601d4e059b81d22788dac75e518528705060759ce10f3e599a57bf5ac34", "points": [], "queries": [ { @@ -18884,7 +18882,8 @@ "response": "consumed" } ], - "sha256": "30188601d4e059b81d22788dac75e518528705060759ce10f3e599a57bf5ac34" + "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.", @@ -18895,8 +18894,7 @@ }, "application/single_app/functions_mcp_tool_pinning.py::persist_mcp_tool_drift": { "boundary": { - "batches": [], - "module_sha256": "0a11525ea1e7cd836555f9d347c5edd02bc33d7d298fb2846ce2e0688ded9082", + "sha256": "5445fda53c145770c71c22611f6881b142f1db79d327117d9a045630af7f3575", "points": [ { "method": "read_item", @@ -18940,7 +18938,8 @@ } ], "queries": [], - "sha256": "5445fda53c145770c71c22611f6881b142f1db79d327117d9a045630af7f3575" + "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.", @@ -18951,8 +18950,7 @@ }, "application/single_app/functions_msgraph_pending_actions.py::create_msgraph_pending_action": { "boundary": { - "batches": [], - "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6", + "sha256": "8c0de777d079e2e0e27125bc72e0e38bd92bcf418eb846f9bf1ac2a83020ff41", "points": [ { "method": "create_item", @@ -18961,7 +18959,8 @@ } ], "queries": [], - "sha256": "8c0de777d079e2e0e27125bc72e0e38bd92bcf418eb846f9bf1ac2a83020ff41" + "batches": [], + "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6" }, "classification": "sdk-compatible", "contract": "Create response mapping supplies bridge-bound references and notification fields; metadata stripping returns a plain dictionary. New immutable draft strategy is fingerprint-bound; old strategy remains compatible.", @@ -18973,8 +18972,7 @@ }, "application/single_app/functions_msgraph_pending_actions.py::get_chat_pending_action_cards": { "boundary": { - "batches": [], - "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6", + "sha256": "bbab2fabd0cacb6b0a20b65cab88c0f964ea3d8eb0f60d84aac548c50c5f1cb5", "points": [], "queries": [ { @@ -18983,7 +18981,8 @@ "response": "consumed" } ], - "sha256": "bbab2fabd0cacb6b0a20b65cab88c0f964ea3d8eb0f60d84aac548c50c5f1cb5" + "batches": [], + "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6" }, "classification": "sdk-compatible", "contract": "Authorized card discovery consumes plain query rows and sanitized field projections; new producing-message provenance comes only from verified bridge context.", @@ -18995,8 +18994,7 @@ }, "application/single_app/functions_msgraph_pending_actions.py::get_msgraph_pending_action": { "boundary": { - "batches": [], - "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6", + "sha256": "80d93c023dbc3f29a38a9adc2c1909c17f3f898c0ed33c32e7976b8c127a3d43", "points": [ { "method": "read_item", @@ -19005,7 +19003,8 @@ } ], "queries": [], - "sha256": "80d93c023dbc3f29a38a9adc2c1909c17f3f898c0ed33c32e7976b8c127a3d43" + "batches": [], + "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6" }, "classification": "sdk-compatible", "contract": "Point mapping supplies status fields; sent-link refresh is read-only and normalizes its write. Metadata stripping returns a plain dictionary, not a Cosmos wrapper.", @@ -19017,8 +19016,7 @@ }, "application/single_app/functions_msgraph_pending_actions.py::get_pending_action_page": { "boundary": { - "batches": [], - "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6", + "sha256": "da0a376596b373159a31fe339feff36bca2c917e51d1dcefaeded453c8698eb0", "points": [], "queries": [ { @@ -19027,7 +19025,8 @@ "response": "consumed" } ], - "sha256": "da0a376596b373159a31fe339feff36bca2c917e51d1dcefaeded453c8698eb0" + "batches": [], + "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6" }, "classification": "sdk-compatible", "contract": "Owner/current-conversation filtering consumes plain query rows and emits sanitized current card pages.", @@ -19039,8 +19038,7 @@ }, "application/single_app/functions_msgraph_pending_actions.py::list_msgraph_pending_actions": { "boundary": { - "batches": [], - "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6", + "sha256": "15ed10422a707cacd8fe90801341251aee79cabd6d4bdb938a5d3e0347111c14", "points": [], "queries": [ { @@ -19049,7 +19047,8 @@ "response": "consumed" } ], - "sha256": "15ed10422a707cacd8fe90801341251aee79cabd6d4bdb938a5d3e0347111c14" + "batches": [], + "module_sha256": "e031382d46ba52dee218b8e8867ba0141b30ebb224e54f7ad760dd18b8862cb6" }, "classification": "sdk-compatible", "contract": "Owner-partitioned list consumes plain query rows; history documents have a separate type and are not pending actions.", @@ -19061,8 +19060,7 @@ }, "application/single_app/functions_notifications.py::_read_existing_notification": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "91f109e5978ce611adfde3d1810c92a1d612b369c3ef866143ef1e599e275849", "points": [ { "method": "read_item", @@ -19071,7 +19069,8 @@ } ], "queries": [], - "sha256": "91f109e5978ce611adfde3d1810c92a1d612b369c3ef866143ef1e599e275849" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19082,8 +19081,7 @@ }, "application/single_app/functions_notifications.py::_read_notification_by_id": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "f918298e0067c78c9684cd86cc9dab7120cff40f0424e15bdf006880a7e4e3d0", "points": [], "queries": [ { @@ -19092,7 +19090,8 @@ "response": "consumed" } ], - "sha256": "f918298e0067c78c9684cd86cc9dab7120cff40f0424e15bdf006880a7e4e3d0" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19103,8 +19102,7 @@ }, "application/single_app/functions_notifications.py::_read_workflow_alert_page": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "c429d07f2582a2923b1f1256d001b5e09b29f83b038fdaaff979d6d35720d7e5", "points": [], "queries": [ { @@ -19118,7 +19116,8 @@ "response": "consumed" } ], - "sha256": "c429d07f2582a2923b1f1256d001b5e09b29f83b038fdaaff979d6d35720d7e5" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19129,8 +19128,7 @@ }, "application/single_app/functions_notifications.py::_write_notification_change": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "d7d2c599000ef6692485b174577169eca8250a18a4cc626c06377715153762bb", "points": [ { "method": "upsert_item", @@ -19144,7 +19142,8 @@ } ], "queries": [], - "sha256": "d7d2c599000ef6692485b174577169eca8250a18a4cc626c06377715153762bb" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19155,8 +19154,7 @@ }, "application/single_app/functions_notifications.py::create_m365_approval_notification": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "6d8edf59e166b10397125a57c21bbd95df7474f398cedde895a2070181011e0e", "points": [ { "method": "create_item", @@ -19170,7 +19168,8 @@ } ], "queries": [], - "sha256": "6d8edf59e166b10397125a57c21bbd95df7474f398cedde895a2070181011e0e" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19181,8 +19180,7 @@ }, "application/single_app/functions_notifications.py::create_notification": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "8e738c70a6351fbb5e9adaa84d12b29f7c9a1164ad47f8e9dbe3803e5da5a93d", "points": [ { "method": "create_item", @@ -19191,7 +19189,8 @@ } ], "queries": [], - "sha256": "8e738c70a6351fbb5e9adaa84d12b29f7c9a1164ad47f8e9dbe3803e5da5a93d" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19202,8 +19201,7 @@ }, "application/single_app/functions_notifications.py::delete_notification": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "0f4d57670580af7eb6750cba9bc6e2cf3a2055eae562b21d4f91e803500609be", "points": [ { "method": "delete_item", @@ -19218,7 +19216,8 @@ "response": "consumed" } ], - "sha256": "0f4d57670580af7eb6750cba9bc6e2cf3a2055eae562b21d4f91e803500609be" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19229,8 +19228,7 @@ }, "application/single_app/functions_notifications.py::delete_notifications_by_metadata": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "ebe696cf10fdad9ae9c3881ea6dc7272f38a2cbccec6d45433f0fc04e3b7ca9b", "points": [ { "method": "delete_item", @@ -19239,7 +19237,8 @@ } ], "queries": [], - "sha256": "ebe696cf10fdad9ae9c3881ea6dc7272f38a2cbccec6d45433f0fc04e3b7ca9b" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19250,8 +19249,7 @@ }, "application/single_app/functions_notifications.py::get_notifications_by_metadata": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "9a7f7f40b0ce2256a1d53f6b970370b3aa58a8d5edc42e3452858d6d6d9b3bac", "points": [], "queries": [ { @@ -19260,7 +19258,8 @@ "response": "consumed" } ], - "sha256": "9a7f7f40b0ce2256a1d53f6b970370b3aa58a8d5edc42e3452858d6d6d9b3bac" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19271,8 +19270,7 @@ }, "application/single_app/functions_notifications.py::get_recent_chat_response_notifications": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "d017f4aaeacc33f61e287bc31de8fc9d8334acd76c107981d5f1dee53918dd5d", "points": [], "queries": [ { @@ -19281,7 +19279,8 @@ "response": "consumed" } ], - "sha256": "d017f4aaeacc33f61e287bc31de8fc9d8334acd76c107981d5f1dee53918dd5d" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19292,8 +19291,7 @@ }, "application/single_app/functions_notifications.py::get_unread_workflow_priority_notifications": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "184a4fd4e4c2034403db1b273ceaed148f3169a9793015c5bcefcec3da455c4b", "points": [], "queries": [ { @@ -19302,7 +19300,8 @@ "response": "consumed" } ], - "sha256": "184a4fd4e4c2034403db1b273ceaed148f3169a9793015c5bcefcec3da455c4b" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19313,8 +19312,7 @@ }, "application/single_app/functions_notifications.py::get_user_notifications": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "4365755ffbdbfae671f831eb31a2ac4017b679db490241df0da22e29d5f4e418", "points": [], "queries": [ { @@ -19338,7 +19336,8 @@ "response": "consumed" } ], - "sha256": "4365755ffbdbfae671f831eb31a2ac4017b679db490241df0da22e29d5f4e418" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19349,8 +19348,7 @@ }, "application/single_app/functions_notifications.py::mark_chat_response_notifications_read_for_conversation": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "d4345ad54584954113bd610d8cbecb516021250745268e24d1abe3754cdf3008", "points": [ { "method": "upsert_item", @@ -19365,7 +19363,8 @@ "response": "consumed" } ], - "sha256": "d4345ad54584954113bd610d8cbecb516021250745268e24d1abe3754cdf3008" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19376,8 +19375,7 @@ }, "application/single_app/functions_notifications.py::mark_collaboration_message_notifications_read_for_conversation": { "boundary": { - "batches": [], - "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99", + "sha256": "fadb4f22b28bd0df02f7cb359cb4edb906b4273c086f6e40ce4ef53dfacebb46", "points": [ { "method": "upsert_item", @@ -19392,7 +19390,8 @@ "response": "consumed" } ], - "sha256": "fadb4f22b28bd0df02f7cb359cb4edb906b4273c086f6e40ce4ef53dfacebb46" + "batches": [], + "module_sha256": "b381d9d06d1daf58f62b1fc01c62727b23791856ea0e9db11cbd9d84b1c78b99" }, "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.", @@ -19403,8 +19402,7 @@ }, "application/single_app/functions_orchestration_artifacts.py::OrchestrationOutputCleanupService.cleanup": { "boundary": { - "batches": [], - "module_sha256": "6343386e8270a99dc9498847276b2fee744aafa59649ce788a34d4ed62eaf938", + "sha256": "24a8c72d38273b63e66bb7986d1c2b2ab8545f973722fb5051e97a420fc4a14a", "points": [ { "method": "read_item", @@ -19418,7 +19416,8 @@ } ], "queries": [], - "sha256": "24a8c72d38273b63e66bb7986d1c2b2ab8545f973722fb5051e97a420fc4a14a" + "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.", @@ -19429,8 +19428,7 @@ }, "application/single_app/functions_orchestration_bootstrap.py::build_document_transform_sources.list_artifacts": { "boundary": { - "batches": [], - "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf", + "sha256": "7350117c58451e842091874583a79713dc534f0b38780ddeecad86e1a5516f3b", "points": [], "queries": [ { @@ -19439,7 +19437,8 @@ "response": "returned" } ], - "sha256": "7350117c58451e842091874583a79713dc534f0b38780ddeecad86e1a5516f3b" + "batches": [], + "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf" }, "classification": "sdk-compatible", "contract": "Artifact enumeration returns plain query rows after a fresh normalized owner-conversation read; no point wrapper enters the transform candidate contract.", @@ -19451,8 +19450,7 @@ }, "application/single_app/functions_orchestration_bootstrap.py::build_external_identity_reader.read_user_settings": { "boundary": { - "batches": [], - "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf", + "sha256": "c3513ddf2681594794d04fa045494145d420157afb99e4ae5470d12681cb97b4", "points": [ { "method": "read_item", @@ -19461,21 +19459,21 @@ } ], "queries": [], - "sha256": "c3513ddf2681594794d04fa045494145d420157afb99e4ae5470d12681cb97b4" + "batches": [], + "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf" }, "classification": "normalized-strict", "contract": "The lazy identity reader normalizes the SDK user-settings point response through _document_response before the external-identity strict settings projection.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_orchestration_cosmos_response_contract.py", - "functional_tests/test_workflow_chat_execution.py", - "functional_tests/test_orchestration_external_bootstrap.py" + "functional_tests/test_orchestration_external_bootstrap.py", + "functional_tests/test_workflow_chat_execution.py" ] }, "application/single_app/functions_orchestration_bootstrap.py::build_image_asset_reader.read": { "boundary": { - "batches": [], - "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf", + "sha256": "47202ebe413ca6d176c35e1ef7285d3824404a5a69a125437659041232bb886c", "points": [ { "method": "read_item", @@ -19484,7 +19482,8 @@ } ], "queries": [], - "sha256": "47202ebe413ca6d176c35e1ef7285d3824404a5a69a125437659041232bb886c" + "batches": [], + "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf" }, "classification": "sdk-compatible", "contract": "The image reader consumes SDK message fields and nested plain metadata, verifies the retained blob binding, and returns bytes rather than the point wrapper.", @@ -19496,8 +19495,7 @@ }, "application/single_app/functions_orchestration_bootstrap.py::build_orchestration_cleanup_service": { "boundary": { - "batches": [], - "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf", + "sha256": "b0cf10f3177d20beddda6406241300f279045a5cf05a93fe0f6c7f34dcaed312", "points": [ { "method": "read_item", @@ -19511,20 +19509,20 @@ } ], "queries": [], - "sha256": "b0cf10f3177d20beddda6406241300f279045a5cf05a93fe0f6c7f34dcaed312" + "batches": [], + "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf" }, "classification": "normalized-strict", "contract": "Conversation and run-tombstone point callbacks normalize through _document_response before strict cleanup-source checks; write status contracts remain separate.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_orchestration_cosmos_response_contract.py", - "functional_tests/test_orchestration_cleanup_bootstrap.py" + "functional_tests/test_orchestration_cleanup_bootstrap.py", + "functional_tests/test_orchestration_cosmos_response_contract.py" ] }, "application/single_app/functions_orchestration_bootstrap.py::build_orchestration_services": { "boundary": { - "batches": [], - "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf", + "sha256": "493c77bd9c7ec4fb0cf26b221f51cbacf348d070571c31471aee03927f16dc5c", "points": [ { "method": "read_item", @@ -19533,22 +19531,22 @@ } ], "queries": [], - "sha256": "493c77bd9c7ec4fb0cf26b221f51cbacf348d070571c31471aee03927f16dc5c" + "batches": [], + "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf" }, "classification": "sdk-compatible", "contract": "The artifact transport callback supplies SDK point messages to Mapping-compatible binding checks. The selected-source reader returns bounded plain source context from authorized manifests and now receives the owner conversation ID only for hashed diagnostics; it retains screening, revision and conditional Blob-read fences.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_orchestration_cosmos_response_contract.py", - "functional_tests/test_workflow_chat_execution.py", "functional_tests/test_orchestration_selected_source_planning.py", - "functional_tests/test_orchestration_selected_source_sdk.py" + "functional_tests/test_orchestration_selected_source_sdk.py", + "functional_tests/test_workflow_chat_execution.py" ] }, "application/single_app/functions_orchestration_bootstrap.py::read_owned_conversation": { "boundary": { - "batches": [], - "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf", + "sha256": "1059384e6b69842cd0ef431c2d9d7bb51b22af4595abe669429e0ca94c71ecd5", "points": [ { "method": "read_item", @@ -19557,7 +19555,8 @@ } ], "queries": [], - "sha256": "1059384e6b69842cd0ef431c2d9d7bb51b22af4595abe669429e0ca94c71ecd5" + "batches": [], + "module_sha256": "f53be2a1060f247887474034db9ce181a5b4a3b652c4617bf127dd8cec7410bf" }, "classification": "normalized-strict", "contract": "Ownership and deletion flags are Mapping reads; normalize_cosmos_document produces the plain top-level document before strict orchestration consumers.", @@ -19569,8 +19568,7 @@ }, "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore._read": { "boundary": { - "batches": [], - "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19", + "sha256": "5240d1abae08904bce4c82e95d2e80647bc6cf9c51f5d680f0747cb08aedcf71", "points": [ { "method": "read_item", @@ -19579,7 +19577,8 @@ } ], "queries": [], - "sha256": "5240d1abae08904bce4c82e95d2e80647bc6cf9c51f5d680f0747cb08aedcf71" + "batches": [], + "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19" }, "classification": "sdk-compatible", "contract": "Checkpoint _verify accepts dict subclasses; nested manifests/state are plain SDK JSON and publication/control values use mapping fields. Review 0.261.380: Module-only addition of completeness helpers using existing chunked, lifecycle-fenced payload methods; this storage owner AST and response consumer are unchanged.", @@ -19590,6 +19589,9 @@ }, "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore._write": { "boundary": { + "sha256": "c14dda7787185d20244e86ae8d19a274dd302470c08c036ca8ee6eeec66b11e6", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -19597,10 +19599,7 @@ "response": "unused" } ], - "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19", - "points": [], - "queries": [], - "sha256": "c14dda7787185d20244e86ae8d19a274dd302470c08c036ca8ee6eeec66b11e6" + "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19" }, "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. Review 0.261.380: Module-only addition of completeness helpers using existing chunked, lifecycle-fenced payload methods; this storage owner AST and response consumer are unchanged.", @@ -19609,8 +19608,7 @@ }, "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.adopt_claim": { "boundary": { - "batches": [], - "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19", + "sha256": "fc2644e1034a7a6624f9ec9702367f2a5050a906d676881f7738d4c0c45eb00f", "points": [ { "method": "replace_item", @@ -19619,7 +19617,8 @@ } ], "queries": [], - "sha256": "fc2644e1034a7a6624f9ec9702367f2a5050a906d676881f7738d4c0c45eb00f" + "batches": [], + "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19" }, "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. Review 0.261.380: Module-only addition of completeness helpers using existing chunked, lifecycle-fenced payload methods; this storage owner AST and response consumer are unchanged.", @@ -19628,8 +19627,7 @@ }, "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.delete_payloads": { "boundary": { - "batches": [], - "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19", + "sha256": "4600e56ecdd0dd4cec8ef9a3c5132753730ba8b884032085730330a5d853a7c8", "points": [ { "method": "delete_item", @@ -19644,7 +19642,8 @@ "response": "consumed" } ], - "sha256": "4600e56ecdd0dd4cec8ef9a3c5132753730ba8b884032085730330a5d853a7c8" + "batches": [], + "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19" }, "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. Review 0.261.380: Module-only addition of completeness helpers using existing chunked, lifecycle-fenced payload methods; this storage owner AST and response consumer are unchanged.", @@ -19653,8 +19652,7 @@ }, "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.fence": { "boundary": { - "batches": [], - "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19", + "sha256": "a850b588741cdce1ef5e107b1ce5a69607a54c4ebe7fed9e3b297de094adbf76", "points": [ { "method": "read_item", @@ -19673,7 +19671,8 @@ } ], "queries": [], - "sha256": "a850b588741cdce1ef5e107b1ce5a69607a54c4ebe7fed9e3b297de094adbf76" + "batches": [], + "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19" }, "classification": "sdk-compatible", "contract": "Checkpoint _verify accepts dict subclasses; nested manifests/state are plain SDK JSON and publication/control values use mapping fields. Review 0.261.380: Module-only addition of completeness helpers using existing chunked, lifecycle-fenced payload methods; this storage owner AST and response consumer are unchanged.", @@ -19684,8 +19683,7 @@ }, "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.has_manifest": { "boundary": { - "batches": [], - "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19", + "sha256": "6911214220b455d1fb0b152a94834bf5ca01f714f37f3c57de7eabf19c9fcd3e", "points": [ { "method": "read_item", @@ -19694,7 +19692,8 @@ } ], "queries": [], - "sha256": "6911214220b455d1fb0b152a94834bf5ca01f714f37f3c57de7eabf19c9fcd3e" + "batches": [], + "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19" }, "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. Review 0.261.380: Module-only addition of completeness helpers using existing chunked, lifecycle-fenced payload methods; this storage owner AST and response consumer are unchanged.", @@ -19703,8 +19702,7 @@ }, "application/single_app/functions_orchestration_checkpoints.py::CheckpointStore.initialize": { "boundary": { - "batches": [], - "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19", + "sha256": "503c77d96ea92cd9866b27c5dc6dc93a8a4c8f74d5c911c136a0397feda68c7a", "points": [ { "method": "create_item", @@ -19713,7 +19711,8 @@ } ], "queries": [], - "sha256": "503c77d96ea92cd9866b27c5dc6dc93a8a4c8f74d5c911c136a0397feda68c7a" + "batches": [], + "module_sha256": "5b04fc802c5c09e74ad7fd14428f3f2257847295d3b2635d01ae069dcb995d19" }, "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. Review 0.261.380: Module-only addition of completeness helpers using existing chunked, lifecycle-fenced payload methods; this storage owner AST and response consumer are unchanged.", @@ -19722,8 +19721,7 @@ }, "application/single_app/functions_orchestration_collaboration.py::_refresh_mirrored_answer": { "boundary": { - "batches": [], - "module_sha256": "d91095101df3dc9c602599fcb80b8e8a19f814c7226cde580e6f3333dfd88ec5", + "sha256": "1f782fc2b6639e15dae1f04d5fde043113215127968a0c0bef0be0074a7926ca", "points": [ { "method": "replace_item", @@ -19732,7 +19730,8 @@ } ], "queries": [], - "sha256": "1f782fc2b6639e15dae1f04d5fde043113215127968a0c0bef0be0074a7926ca" + "batches": [], + "module_sha256": "d91095101df3dc9c602599fcb80b8e8a19f814c7226cde580e6f3333dfd88ec5" }, "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. Representative SDK-default runtime coverage now executes this shared-storage module; this does not claim exhaustive branch coverage for this unchanged owner.", @@ -19743,8 +19742,7 @@ }, "application/single_app/functions_orchestration_collaboration.py::delete_orchestration_backing": { "boundary": { - "batches": [], - "module_sha256": "d91095101df3dc9c602599fcb80b8e8a19f814c7226cde580e6f3333dfd88ec5", + "sha256": "a8817de98bbf75b2a8995081973562fd6f9b22adf3d7c3729b898186270b6ed3", "points": [ { "method": "upsert_item", @@ -19774,7 +19772,8 @@ "response": "consumed" } ], - "sha256": "a8817de98bbf75b2a8995081973562fd6f9b22adf3d7c3729b898186270b6ed3" + "batches": [], + "module_sha256": "d91095101df3dc9c602599fcb80b8e8a19f814c7226cde580e6f3333dfd88ec5" }, "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.", @@ -19783,8 +19782,7 @@ }, "application/single_app/functions_orchestration_collaboration.py::delete_orchestration_backing.read_backing": { "boundary": { - "batches": [], - "module_sha256": "d91095101df3dc9c602599fcb80b8e8a19f814c7226cde580e6f3333dfd88ec5", + "sha256": "f8f778555dec4c5f2269908800913371cf8e97e555ef9475a0e1719bea358477", "points": [ { "method": "read_item", @@ -19793,7 +19791,8 @@ } ], "queries": [], - "sha256": "f8f778555dec4c5f2269908800913371cf8e97e555ef9475a0e1719bea358477" + "batches": [], + "module_sha256": "d91095101df3dc9c602599fcb80b8e8a19f814c7226cde580e6f3333dfd88ec5" }, "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. Representative SDK-default runtime coverage now executes this shared-storage module; this does not claim exhaustive branch coverage for this unchanged owner.", @@ -19804,8 +19803,7 @@ }, "application/single_app/functions_orchestration_context.py::_authorize_references": { "boundary": { - "batches": [], - "module_sha256": "f900cc5f3e7de61d2e8305f11e1d6c8d7e0277542d439c9f0d1c9a722bc86bac", + "sha256": "95eac176b288373f2ddebfbcac3ec75936f7e998de84acbea8251077293fbfa7", "points": [], "queries": [ { @@ -19814,7 +19812,8 @@ "response": "consumed" } ], - "sha256": "95eac176b288373f2ddebfbcac3ec75936f7e998de84acbea8251077293fbfa7" + "batches": [], + "module_sha256": "f900cc5f3e7de61d2e8305f11e1d6c8d7e0277542d439c9f0d1c9a722bc86bac" }, "classification": "sdk-compatible", "contract": "Authorized chat-attachment readiness uses partitioned query rows, which remain plain dictionaries; workspace manifests and readiness checks consume field projections without changing strict reference validation.", @@ -19825,8 +19824,7 @@ }, "application/single_app/functions_orchestration_context.py::_image_reference_message_candidates": { "boundary": { - "batches": [], - "module_sha256": "f900cc5f3e7de61d2e8305f11e1d6c8d7e0277542d439c9f0d1c9a722bc86bac", + "sha256": "66285e0cfeceb1756f580e32d76e57894386a9e31ed1558f4fd0cc2a71c7acac", "points": [ { "method": "read_item", @@ -19835,7 +19833,8 @@ } ], "queries": [], - "sha256": "66285e0cfeceb1756f580e32d76e57894386a9e31ed1558f4fd0cc2a71c7acac" + "batches": [], + "module_sha256": "f900cc5f3e7de61d2e8305f11e1d6c8d7e0277542d439c9f0d1c9a722bc86bac" }, "classification": "sdk-compatible", "contract": "Partitioned message point mappings are checked for conversation identity, image/file role and supported filename; only a plain candidate DTO is emitted, never the SDK document.", @@ -19846,8 +19845,7 @@ }, "application/single_app/functions_orchestration_context.py::_owned_elicitation_conversation": { "boundary": { - "batches": [], - "module_sha256": "f900cc5f3e7de61d2e8305f11e1d6c8d7e0277542d439c9f0d1c9a722bc86bac", + "sha256": "6c47cd9daad92fe17aa4041abe7ba2f0d9eeaaeaf84c205f764a5b5ce80ea7f5", "points": [ { "method": "read_item", @@ -19856,7 +19854,8 @@ } ], "queries": [], - "sha256": "6c47cd9daad92fe17aa4041abe7ba2f0d9eeaaeaf84c205f764a5b5ce80ea7f5" + "batches": [], + "module_sha256": "f900cc5f3e7de61d2e8305f11e1d6c8d7e0277542d439c9f0d1c9a722bc86bac" }, "classification": "sdk-compatible", "contract": "The conversation point mapping is authorized through user_id and passed to Mapping-compatible scope-lock readers; missing or foreign conversations retain ElicitationContextError rather than an empty fallback.", @@ -19867,8 +19866,7 @@ }, "application/single_app/functions_orchestration_continuation.py::ContinuationExecutionLease._roll_guard": { "boundary": { - "batches": [], - "module_sha256": "f358cb141cdaceca2d63039ecad7f5ee9e09aa11a0318c8d5c902ff0f7acbd18", + "sha256": "15a656f94d617211faaf9dda9ae1dbec9c0ce2a1b006ae451368d45a4a1dcd32", "points": [ { "method": "read_item", @@ -19897,7 +19895,8 @@ } ], "queries": [], - "sha256": "15a656f94d617211faaf9dda9ae1dbec9c0ce2a1b006ae451368d45a4a1dcd32" + "batches": [], + "module_sha256": "f358cb141cdaceca2d63039ecad7f5ee9e09aa11a0318c8d5c902ff0f7acbd18" }, "classification": "sdk-compatible", "contract": "Point guards use mapping fields and plain metadata-stripping projections; inherited lease reads already normalize before strict continuation state. Review 0.261.380: Module-only addition retaining safe assessment metadata in terminal results; this storage owner AST and response consumer are unchanged.", @@ -19909,8 +19908,7 @@ }, "application/single_app/functions_orchestration_continuation.py::_continuation_guards": { "boundary": { - "batches": [], - "module_sha256": "f358cb141cdaceca2d63039ecad7f5ee9e09aa11a0318c8d5c902ff0f7acbd18", + "sha256": "3baddfbdca48611b98aac80cbcb5d1e4222f4f1fc1552990b72c4266f37a3a4a", "points": [ { "method": "read_item", @@ -19919,7 +19917,8 @@ } ], "queries": [], - "sha256": "3baddfbdca48611b98aac80cbcb5d1e4222f4f1fc1552990b72c4266f37a3a4a" + "batches": [], + "module_sha256": "f358cb141cdaceca2d63039ecad7f5ee9e09aa11a0318c8d5c902ff0f7acbd18" }, "classification": "sdk-compatible", "contract": "Point guards use mapping fields and plain metadata-stripping projections; inherited lease reads already normalize before strict continuation state. Review 0.261.380: Module-only addition retaining safe assessment metadata in terminal results; this storage owner AST and response consumer are unchanged.", @@ -19931,8 +19930,7 @@ }, "application/single_app/functions_orchestration_execution.py::HarnessExecution._finalize": { "boundary": { - "batches": [], - "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629", + "sha256": "e99d7c66721d46ed28a568200cbd63da99bb2b1cd2528a58208e72626ff3b421", "points": [ { "method": "read_item", @@ -19941,27 +19939,27 @@ } ], "queries": [], - "sha256": "e99d7c66721d46ed28a568200cbd63da99bb2b1cd2528a58208e72626ff3b421" + "batches": [], + "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629" }, "classification": "sdk-compatible", "contract": "Read-only retained-result projection ends before screening and publication; its operation cache never contains message responses or conditional publication state. The published SDK point mapping is projected with items() into plain message JSON and compared with publication_documents_match, accepting only lossless integral-float/integer round trips. Stored guard fingerprints, all domain fields and Mapping-compatible mirroring remain unchanged; durable outcome telemetry reads finalized scalar fields. Review renewed for 0.261.388: The added evidence_status is plain projected JSON from verified retained readers. The only direct SDK point response is still compared through saved.items() and publication_documents_match; ETags, lease authorization, and conditional publication are unchanged. Verified retained-analysis descriptors add plain JSON metadata before publication; the saved SDK point document is still consumed via mapping/comprehension before publication_documents_match, with no ETag or domain-value repair.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_orchestration_continuation.py", + "functional_tests/test_orchestration_analysis_citation_delivery.py", "functional_tests/test_orchestration_cosmos_response_contract.py", - "functional_tests/test_orchestration_harness_execution.py::test_selected_result_citations_reach_headless_message_cache_and_delivery", - "functional_tests/test_orchestration_harness_execution.py::test_context_edit_after_composition_does_not_publish_stale_content", "functional_tests/test_orchestration_failure_telemetry.py::test_durable_execution_outcome_is_recorded_once_not_on_sse_replay", + "functional_tests/test_orchestration_harness_execution.py::test_context_edit_after_composition_does_not_publish_stale_content", "functional_tests/test_orchestration_harness_execution.py::test_publication_numeric_roundtrip_completes_without_reexecution", "functional_tests/test_orchestration_harness_execution.py::test_publication_numeric_roundtrip_still_rejects_durable_damage", - "functional_tests/test_orchestration_analysis_citation_delivery.py", + "functional_tests/test_orchestration_harness_execution.py::test_selected_result_citations_reach_headless_message_cache_and_delivery", "functional_tests/test_orchestration_retained_analysis_publication.py" ] }, "application/single_app/functions_orchestration_execution.py::HarnessExecution._read_delivery_metadata": { "boundary": { - "batches": [], - "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629", + "sha256": "31156cb399a57d8289e3a5125f904261f6c15baa4316766ddb042297a9995942", "points": [ { "method": "read_item", @@ -19970,7 +19968,8 @@ } ], "queries": [], - "sha256": "31156cb399a57d8289e3a5125f904261f6c15baa4316766ddb042297a9995942" + "batches": [], + "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629" }, "classification": "sdk-compatible", "contract": "The previous assistant point mapping is checked for conversation/run ownership; model and reasoning fields are projected into plain dictionaries, without passing the SDK wrapper to an exact-dictionary contract. Read-operation reuse does not wrap this metadata lookup. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract.", @@ -19983,8 +19982,7 @@ }, "application/single_app/functions_orchestration_execution.py::HarnessExecution._regeneration_thread": { "boundary": { - "batches": [], - "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629", + "sha256": "ceca514e0da4bb42153c8c42d3d23cc863070e713df7518b2ac48c99b749bd61", "points": [ { "method": "read_item", @@ -19993,7 +19991,8 @@ } ], "queries": [], - "sha256": "ceca514e0da4bb42153c8c42d3d23cc863070e713df7518b2ac48c99b749bd61" + "batches": [], + "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629" }, "classification": "sdk-compatible", "contract": "The question point mapping supplies role and nested plain thread metadata; only a deepcopy of the validated nested thread dictionary is returned. Regeneration metadata is outside the retained-result read scope. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract.", @@ -20006,8 +20005,7 @@ }, "application/single_app/functions_orchestration_execution.py::HarnessExecution._touch_conversation": { "boundary": { - "batches": [], - "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629", + "sha256": "ebd2d57c650ecbf59f6533479ce7061ff203861f1ef2fdad4e385b941fff288a", "points": [ { "method": "replace_item", @@ -20016,7 +20014,8 @@ } ], "queries": [], - "sha256": "ebd2d57c650ecbf59f6533479ce7061ff203861f1ef2fdad4e385b941fff288a" + "batches": [], + "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629" }, "classification": "sdk-compatible", "contract": "A normalized owned conversation retains its _etag for IfNotModified replacement; the returned SDK mapping is consumed only by the Mapping-compatible cache invalidator. Lost-CAS retries retain current ownership. This write remains outside read-operation reuse. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract.", @@ -20029,8 +20028,7 @@ }, "application/single_app/functions_orchestration_execution.py::_conversation_context": { "boundary": { - "batches": [], - "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629", + "sha256": "1061ff490d079ee34c435d41190d6faedeae749043bf38cd1ddf02882344d632", "points": [ { "method": "read_item", @@ -20044,21 +20042,21 @@ } ], "queries": [], - "sha256": "1061ff490d079ee34c435d41190d6faedeae749043bf38cd1ddf02882344d632" + "batches": [], + "module_sha256": "239b8ca94ebc2b5d00af93d24d7329974868be36c6c282f68d994ddec67ae629" }, "classification": "sdk-compatible", "contract": "Partitioned turn/source point mappings are reauthorized, checked for visibility and converted by normalize_history_message before strict saved-snapshot validation. Full source messages are resolved only after fingerprint checks; history disablement and revoked shared access cannot broaden reads. Result-operation snapshots never replace these message reads. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_orchestration_continuation.py", - "functional_tests/test_orchestration_cosmos_response_contract.py", - "functional_tests/test_orchestration_conversation_sources.py" + "functional_tests/test_orchestration_conversation_sources.py", + "functional_tests/test_orchestration_cosmos_response_contract.py" ] }, "application/single_app/functions_orchestration_operations.py::OperationJournal._change": { "boundary": { - "batches": [], - "module_sha256": "f33f7431faef59bb042655228753c7a68f79254b6195097703a1f5ccdb412aaa", + "sha256": "37e251491172caaeb3e6696bd57a010ad3205c51a78781ecf44b3984ab700f29", "points": [ { "method": "read_item", @@ -20077,7 +20075,8 @@ } ], "queries": [], - "sha256": "37e251491172caaeb3e6696bd57a010ad3205c51a78781ecf44b3984ab700f29" + "batches": [], + "module_sha256": "f33f7431faef59bb042655228753c7a68f79254b6195097703a1f5ccdb412aaa" }, "classification": "normalized-strict", "contract": "The effect journal normalizes the SDK point mapping before deepcopy/canonical JSON. Conditional ETags and sticky unknown-effect outcomes are preserved; updated preparation prose is not delivery authority.", @@ -20088,6 +20087,9 @@ }, "application/single_app/functions_orchestration_output_store.py::OrchestrationOutputStore._batch": { "boundary": { + "sha256": "0f016711517c548e3c0c8f24c877c349b1f211755b9bc44e40a07aec65af7d35", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -20095,10 +20097,7 @@ "response": "consumed" } ], - "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3", - "points": [], - "queries": [], - "sha256": "0f016711517c548e3c0c8f24c877c349b1f211755b9bc44e40a07aec65af7d35" + "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3" }, "classification": "sdk-compatible", "contract": "Output point records normalize in _point before strict output validation; owner-injected conversation readers normalize before authorization.", @@ -20109,8 +20108,7 @@ }, "application/single_app/functions_orchestration_output_store.py::OrchestrationOutputStore._point": { "boundary": { - "batches": [], - "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3", + "sha256": "59458388fbd4013dff35a9b4e14782fc7071fb31ec7f57c9364cc4af4f5599af", "points": [ { "method": "read_item", @@ -20119,7 +20117,8 @@ } ], "queries": [], - "sha256": "59458388fbd4013dff35a9b4e14782fc7071fb31ec7f57c9364cc4af4f5599af" + "batches": [], + "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3" }, "classification": "normalized-strict", "contract": "Output point records normalize in _point before strict output validation; owner-injected conversation readers normalize before authorization.", @@ -20130,6 +20129,9 @@ }, "application/single_app/functions_orchestration_output_store.py::OrchestrationOutputStore.enroll_run_cleanup": { "boundary": { + "sha256": "b42e471dc45df344d84494dc28ab8699c80ecd6063317fa8d055b420d2b499dd", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -20137,10 +20139,7 @@ "response": "unused" } ], - "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3", - "points": [], - "queries": [], - "sha256": "b42e471dc45df344d84494dc28ab8699c80ecd6063317fa8d055b420d2b499dd" + "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3" }, "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.", @@ -20150,8 +20149,7 @@ }, "application/single_app/functions_orchestration_output_store.py::enumerate_due_outputs": { "boundary": { - "batches": [], - "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3", + "sha256": "0f6fafa26a06f152d25b0ab4e864c2781fd81717d260faa502e29bcb3a829ecf", "points": [], "queries": [ { @@ -20160,7 +20158,8 @@ "response": "consumed" } ], - "sha256": "0f6fafa26a06f152d25b0ab4e864c2781fd81717d260faa502e29bcb3a829ecf" + "batches": [], + "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3" }, "classification": "sdk-compatible", "contract": "Output point records normalize in _point before strict output validation; owner-injected conversation readers normalize before authorization.", @@ -20171,8 +20170,7 @@ }, "application/single_app/functions_orchestration_output_store.py::enumerate_output_cleanup_enrollments": { "boundary": { - "batches": [], - "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3", + "sha256": "93b9fe5c5c3734839e2b3ec30778c51caa1e0c003cb607de425c9a4f6a056519", "points": [], "queries": [ { @@ -20181,7 +20179,8 @@ "response": "consumed" } ], - "sha256": "93b9fe5c5c3734839e2b3ec30778c51caa1e0c003cb607de425c9a4f6a056519" + "batches": [], + "module_sha256": "be86d9b8ab666ef138935ef6a74d74a511bf874c1576abcbaee65944f62f0de3" }, "classification": "sdk-compatible", "contract": "Output point records normalize in _point before strict output validation; owner-injected conversation readers normalize before authorization.", @@ -20192,8 +20191,7 @@ }, "application/single_app/functions_orchestration_plan_revisions.py::_replace": { "boundary": { - "batches": [], - "module_sha256": "75cedc145f0f817c43fb3244baf9664fbe510d74017db3b695420b24fc6f30bf", + "sha256": "d48c8da9487caf2a375ea56f0355df20b8eec015084ee44088a6178585cfb247", "points": [ { "method": "replace_item", @@ -20202,7 +20200,8 @@ } ], "queries": [], - "sha256": "d48c8da9487caf2a375ea56f0355df20b8eec015084ee44088a6178585cfb247" + "batches": [], + "module_sha256": "75cedc145f0f817c43fb3244baf9664fbe510d74017db3b695420b24fc6f30bf" }, "classification": "sdk-compatible", "contract": "Owned revision reads and execution claims normalize the outer wrapper; ownership, lineage and ETag fencing stay in this owner.", @@ -20213,6 +20212,9 @@ }, "application/single_app/functions_orchestration_plan_revisions.py::complete_plan_revision": { "boundary": { + "sha256": "ad689ebdd5c616f0f049cebbf4f9b32fff4c6dcfe944d65e9730347042b096eb", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -20220,10 +20222,7 @@ "response": "consumed" } ], - "module_sha256": "75cedc145f0f817c43fb3244baf9664fbe510d74017db3b695420b24fc6f30bf", - "points": [], - "queries": [], - "sha256": "ad689ebdd5c616f0f049cebbf4f9b32fff4c6dcfe944d65e9730347042b096eb" + "module_sha256": "75cedc145f0f817c43fb3244baf9664fbe510d74017db3b695420b24fc6f30bf" }, "classification": "sdk-compatible", "contract": "Owned revision reads and execution claims normalize the outer wrapper; ownership, lineage and ETag fencing stay in this owner.", @@ -20234,8 +20233,7 @@ }, "application/single_app/functions_orchestration_plan_revisions.py::plan_editor_state": { "boundary": { - "batches": [], - "module_sha256": "75cedc145f0f817c43fb3244baf9664fbe510d74017db3b695420b24fc6f30bf", + "sha256": "0df7c567b3820a29a770e8adf3d4dfbc2e008e2a02db56a0613eefe831b10c28", "points": [], "queries": [ { @@ -20244,7 +20242,8 @@ "response": "consumed" } ], - "sha256": "0df7c567b3820a29a770e8adf3d4dfbc2e008e2a02db56a0613eefe831b10c28" + "batches": [], + "module_sha256": "75cedc145f0f817c43fb3244baf9664fbe510d74017db3b695420b24fc6f30bf" }, "classification": "sdk-compatible", "contract": "Owned revision reads and execution claims normalize the outer wrapper; ownership, lineage and ETag fencing stay in this owner.", @@ -20255,8 +20254,7 @@ }, "application/single_app/functions_orchestration_plan_revisions.py::read_revision_run": { "boundary": { - "batches": [], - "module_sha256": "75cedc145f0f817c43fb3244baf9664fbe510d74017db3b695420b24fc6f30bf", + "sha256": "1c59f77efe5e43d0223c6c484ca7b7f74cab044035e723dc94138b4fd0a4aefb", "points": [ { "method": "read_item", @@ -20265,7 +20263,8 @@ } ], "queries": [], - "sha256": "1c59f77efe5e43d0223c6c484ca7b7f74cab044035e723dc94138b4fd0a4aefb" + "batches": [], + "module_sha256": "75cedc145f0f817c43fb3244baf9664fbe510d74017db3b695420b24fc6f30bf" }, "classification": "normalized-strict", "contract": "Owned revision reads and execution claims normalize the outer wrapper; ownership, lineage and ETag fencing stay in this owner.", @@ -20276,8 +20275,7 @@ }, "application/single_app/functions_orchestration_recovery.py::ExecutionLease._published_message_matches": { "boundary": { - "batches": [], - "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c", + "sha256": "4609d59057d566547a1c6a28c20ea46a44e45a44667980aeebbff2c949f84062", "points": [ { "method": "read_item", @@ -20291,7 +20289,8 @@ } ], "queries": [], - "sha256": "4609d59057d566547a1c6a28c20ea46a44e45a44667980aeebbff2c949f84062" + "batches": [], + "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c" }, "classification": "sdk-compatible", "contract": "Guard and message SDK point mappings supply owner/token/claim/digest fields. The guard digest still exactly binds the expected publication; metadata-stripped plain projections use strict publication-only numeric equivalence without coercing booleans, strings or changed values. Lease ownership is checked before and after the probe.", @@ -20304,8 +20303,7 @@ }, "application/single_app/functions_orchestration_recovery.py::ExecutionLease.ensure_publication_guard": { "boundary": { - "batches": [], - "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c", + "sha256": "a28f3f8f2f654bd38de1c44f66e6bfdc7e86447d6406b3149cde27171b3494ca", "points": [ { "method": "create_item", @@ -20324,7 +20322,8 @@ } ], "queries": [], - "sha256": "a28f3f8f2f654bd38de1c44f66e6bfdc7e86447d6406b3149cde27171b3494ca" + "batches": [], + "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c" }, "classification": "sdk-compatible", "contract": "Guard-create and conditional-replace responses are discarded; a conflicting guard is read through mapping fields and its original _etag is used with IfNotModified before ownership is rechecked. Review 0.261.380: Module-only terminal-result assessment retention; this storage owner AST and response consumer are unchanged.", @@ -20335,14 +20334,7 @@ }, "application/single_app/functions_orchestration_recovery.py::ExecutionLease.publish_message": { "boundary": { - "batches": [ - { - "method": "execute_item_batch", - "receiver": "self.message_container", - "response": "unused" - } - ], - "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c", + "sha256": "157ea1dadb8e9af5a42b27b9f317b6f6b72276cd5edfecd7f77de6e5650e7234", "points": [ { "method": "read_item", @@ -20361,7 +20353,14 @@ } ], "queries": [], - "sha256": "157ea1dadb8e9af5a42b27b9f317b6f6b72276cd5edfecd7f77de6e5650e7234" + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.message_container", + "response": "unused" + } + ], + "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c" }, "classification": "sdk-compatible", "contract": "Guard/current-message point mappings feed ownership and retraction checks; metadata is stripped into plain batch bodies while original ETags fence atomic publication. Batch status/body responses remain separate from point documents. Review 0.261.380: Module-only terminal-result assessment retention; this storage owner AST and response consumer are unchanged.", @@ -20372,8 +20371,7 @@ }, "application/single_app/functions_orchestration_recovery.py::_replace": { "boundary": { - "batches": [], - "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c", + "sha256": "8abbba70c518957dcafe2d97733640677b43ac08ba15f8ecb542eddad207f8fe", "points": [ { "method": "replace_item", @@ -20382,7 +20380,8 @@ } ], "queries": [], - "sha256": "8abbba70c518957dcafe2d97733640677b43ac08ba15f8ecb542eddad207f8fe" + "batches": [], + "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c" }, "classification": "normalized-strict", "contract": "The run replacement preserves the input _etag with IfNotModified, rejects non-document responses through CheckpointError and normalizes the returned SDK document before lease/checkpoint strict contracts; domain values are not recursively repaired. Review 0.261.380: Module-only terminal-result assessment retention; this storage owner AST and response consumer are unchanged.", @@ -20393,8 +20392,7 @@ }, "application/single_app/functions_orchestration_recovery.py::claim_waiting_continuation": { "boundary": { - "batches": [], - "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c", + "sha256": "715768032cef5aebcaa27948a57244fd7604957d8a9daf0c81d8ea16991bd2ef", "points": [ { "method": "read_item", @@ -20403,7 +20401,8 @@ } ], "queries": [], - "sha256": "715768032cef5aebcaa27948a57244fd7604957d8a9daf0c81d8ea16991bd2ef" + "batches": [], + "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c" }, "classification": "sdk-compatible", "contract": "The publication-guard point mapping is checked for user/conversation/run identity before a plain claim descriptor is retained; run claims keep their normalized storage-owner boundary and conditional ETags. Review 0.261.380: Module-only terminal-result assessment retention; this storage owner AST and response consumer are unchanged.", @@ -20414,8 +20413,7 @@ }, "application/single_app/functions_orchestration_recovery.py::cleanup_conversation_checkpoints": { "boundary": { - "batches": [], - "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c", + "sha256": "26ebc929e28b8c78a14728240c791a4a5a30d896fad3d1570051c84e69edc6b6", "points": [ { "method": "read_item", @@ -20435,7 +20433,8 @@ "response": "consumed" } ], - "sha256": "26ebc929e28b8c78a14728240c791a4a5a30d896fad3d1570051c84e69edc6b6" + "batches": [], + "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c" }, "classification": "sdk-compatible", "contract": "Conversation point mappings provide owner and _etag for a conditional deletion fence; replacements are plain metadata-stripped projections and responses are discarded. Run discovery consumes plain partitioned query rows. Review 0.261.380: Module-only terminal-result assessment retention; this storage owner AST and response consumer are unchanged.", @@ -20446,8 +20445,7 @@ }, "application/single_app/functions_orchestration_recovery.py::fence_publication": { "boundary": { - "batches": [], - "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c", + "sha256": "380e7f08eb28d66200aafb75d020385a24066c8a086e41540034ad3be8f3a05a", "points": [ { "method": "read_item", @@ -20466,7 +20464,8 @@ } ], "queries": [], - "sha256": "380e7f08eb28d66200aafb75d020385a24066c8a086e41540034ad3be8f3a05a" + "batches": [], + "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c" }, "classification": "sdk-compatible", "contract": "The guard point mapping supplies run/user ownership and _etag; a plain metadata-stripped tombstone is conditionally replaced, with create/replace responses discarded and conflicts retried without borrowing another owner. Review 0.261.380: Module-only terminal-result assessment retention; this storage owner AST and response consumer are unchanged.", @@ -20477,6 +20476,9 @@ }, "application/single_app/functions_orchestration_recovery.py::prepare_retry": { "boundary": { + "sha256": "38538cae627d01b568dfccb75f188a4e1063313ec7124f03067aeed6511d6d5c", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -20484,30 +20486,20 @@ "response": "unused" } ], - "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c", - "points": [], - "queries": [], - "sha256": "38538cae627d01b568dfccb75f188a4e1063313ec7124f03067aeed6511d6d5c" + "module_sha256": "2433e312b18c4bb9c7a592fb1c296a935f6d3f55c713a04d041f48aae1eb505c" }, "classification": "response-unused", "contract": "Retry preparation ignores transactional batch response bodies. Owned run rereads normalize CosmosDict before strict binding and checkpoint contracts; output-only continuation verifies captured source digests, original production provenance, current actor scope and the approved narrative-only transition before creating its child.", "evidence_scope": "owner-runtime", "tests": [ + "functional_tests/test_orchestration_available_information.py::test_saved_complete_only_failure_can_continue_without_reanalyzing", "functional_tests/test_orchestration_cosmos_response_contract.py", - "functional_tests/test_orchestration_search_result_integrity.py", - "functional_tests/test_orchestration_available_information.py::test_saved_complete_only_failure_can_continue_without_reanalyzing" + "functional_tests/test_orchestration_search_result_integrity.py" ] }, "application/single_app/functions_orchestration_runs.py::_publish_replanned_run": { "boundary": { - "batches": [ - { - "method": "execute_item_batch", - "receiver": "cosmos_orchestration_runs_container", - "response": "unused" - } - ], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "9e47be34d5022955208842bf0e106a6777deb6f62ec20efeb216cb373a65c06e", "points": [ { "method": "read_item", @@ -20521,7 +20513,14 @@ } ], "queries": [], - "sha256": "9e47be34d5022955208842bf0e106a6777deb6f62ec20efeb216cb373a65c06e" + "batches": [ + { + "method": "execute_item_batch", + "receiver": "cosmos_orchestration_runs_container", + "response": "unused" + } + ], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20532,8 +20531,7 @@ }, "application/single_app/functions_orchestration_runs.py::_replace_pending": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "ba4c39af74125736bb555a105d72f4cd07961470f09b823ac23387998bf3804f", "points": [ { "method": "replace_item", @@ -20542,7 +20540,8 @@ } ], "queries": [], - "sha256": "ba4c39af74125736bb555a105d72f4cd07961470f09b823ac23387998bf3804f" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20553,8 +20552,7 @@ }, "application/single_app/functions_orchestration_runs.py::_replanned_outcome": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "ddb55064b1d96ea9daea5bfbdeebc53054809cf07c84f974768f4b0b6243a591", "points": [ { "method": "read_item", @@ -20563,7 +20561,8 @@ } ], "queries": [], - "sha256": "ddb55064b1d96ea9daea5bfbdeebc53054809cf07c84f974768f4b0b6243a591" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20574,8 +20573,7 @@ }, "application/single_app/functions_orchestration_runs.py::_update_run_decision": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "49bcd43ea80aa0ae067257690d5d2421467d6bdce15069573368b412fe2dbad9", "points": [ { "method": "read_item", @@ -20589,7 +20587,8 @@ } ], "queries": [], - "sha256": "49bcd43ea80aa0ae067257690d5d2421467d6bdce15069573368b412fe2dbad9" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20600,8 +20599,7 @@ }, "application/single_app/functions_orchestration_runs.py::clear_pending_turn_context": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "6a5d90b1a76bfabe7ee52da73f89700f13f9bc4ac2d6924c3961f6f4ed9824e9", "points": [ { "method": "delete_item", @@ -20610,7 +20608,8 @@ } ], "queries": [], - "sha256": "6a5d90b1a76bfabe7ee52da73f89700f13f9bc4ac2d6924c3961f6f4ed9824e9" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20619,8 +20618,7 @@ }, "application/single_app/functions_orchestration_runs.py::create_orchestration_run": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "410bed68d219f97c50a0bef1f218c1af8cb94f03f6ce2a67bcf37d6ca71d107d", "points": [ { "method": "create_item", @@ -20634,7 +20632,8 @@ } ], "queries": [], - "sha256": "410bed68d219f97c50a0bef1f218c1af8cb94f03f6ce2a67bcf37d6ca71d107d" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20643,8 +20642,7 @@ }, "application/single_app/functions_orchestration_runs.py::create_pending_elicitation": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "05e307f66bb95f147a155f973406c663201e5a09bbec48b9813747f653e1023c", "points": [ { "method": "create_item", @@ -20653,7 +20651,8 @@ } ], "queries": [], - "sha256": "05e307f66bb95f147a155f973406c663201e5a09bbec48b9813747f653e1023c" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20664,8 +20663,7 @@ }, "application/single_app/functions_orchestration_runs.py::get_latest_turn_run": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "b6629b6374ab8a901a412456558e0b274b64e176128a6c9dbdcdcf818e680d22", "points": [], "queries": [ { @@ -20674,7 +20672,8 @@ "response": "consumed" } ], - "sha256": "b6629b6374ab8a901a412456558e0b274b64e176128a6c9dbdcdcf818e680d22" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20685,8 +20684,7 @@ }, "application/single_app/functions_orchestration_runs.py::get_orchestration_run": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "566a28d0677d6e22aa48723039c795b9d1aab1fd2e601459d512033a918e4a8f", "points": [ { "method": "read_item", @@ -20701,7 +20699,8 @@ "response": "consumed" } ], - "sha256": "566a28d0677d6e22aa48723039c795b9d1aab1fd2e601459d512033a918e4a8f" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20712,8 +20711,7 @@ }, "application/single_app/functions_orchestration_runs.py::get_orchestration_step_record": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "6b4cd0bae280ae372685c29b6ff0a86311293e2b697c1d6ad944c529b19dad76", "points": [ { "method": "read_item", @@ -20722,7 +20720,8 @@ } ], "queries": [], - "sha256": "6b4cd0bae280ae372685c29b6ff0a86311293e2b697c1d6ad944c529b19dad76" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20733,8 +20732,7 @@ }, "application/single_app/functions_orchestration_runs.py::get_pending_elicitation": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "d0d0266ee7766d8af42a88159b5af471df9c3d3c53e29633291fcbb3cbeccdf3", "points": [ { "method": "read_item", @@ -20743,7 +20741,8 @@ } ], "queries": [], - "sha256": "d0d0266ee7766d8af42a88159b5af471df9c3d3c53e29633291fcbb3cbeccdf3" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20754,8 +20753,7 @@ }, "application/single_app/functions_orchestration_runs.py::get_pending_turn_context": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "2261aa80f66b799f26236d08bba3e6f78bb7c1833eaca9dc03100017b3e8eb59", "points": [ { "method": "read_item", @@ -20764,7 +20762,8 @@ } ], "queries": [], - "sha256": "2261aa80f66b799f26236d08bba3e6f78bb7c1833eaca9dc03100017b3e8eb59" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20775,8 +20774,7 @@ }, "application/single_app/functions_orchestration_runs.py::list_conversation_runs": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "d433b88b1c76d947af0b7c5f28a2ec32c458723f3f4027a0238b578c65bf2d18", "points": [], "queries": [ { @@ -20785,7 +20783,8 @@ "response": "consumed" } ], - "sha256": "d433b88b1c76d947af0b7c5f28a2ec32c458723f3f4027a0238b578c65bf2d18" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20796,8 +20795,7 @@ }, "application/single_app/functions_orchestration_runs.py::list_run_steps": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "38db69fbdbe5226c6fbebe158945c3a1a2b4604b325777e71b2ad199b380bfcc", "points": [], "queries": [ { @@ -20806,7 +20804,8 @@ "response": "consumed" } ], - "sha256": "38db69fbdbe5226c6fbebe158945c3a1a2b4604b325777e71b2ad199b380bfcc" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20817,8 +20816,7 @@ }, "application/single_app/functions_orchestration_runs.py::next_turn_index": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "27f66d4f9f6773a5402c4d6202b60ee9aabf6227be0516389a314896c2ca0af6", "points": [], "queries": [ { @@ -20827,7 +20825,8 @@ "response": "consumed" } ], - "sha256": "27f66d4f9f6773a5402c4d6202b60ee9aabf6227be0516389a314896c2ca0af6" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20838,8 +20837,7 @@ }, "application/single_app/functions_orchestration_runs.py::save_orchestration_step": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "18f35b2cfd173d75c13efd05a9f815f6f67e26f16fc17be6bbe7dbfbd165bc63", "points": [ { "method": "upsert_item", @@ -20848,7 +20846,8 @@ } ], "queries": [], - "sha256": "18f35b2cfd173d75c13efd05a9f815f6f67e26f16fc17be6bbe7dbfbd165bc63" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20859,8 +20858,7 @@ }, "application/single_app/functions_orchestration_runs.py::save_pending_turn_context": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "e83fb3547eed7add20f742c362102f2a3d014c428d4157c22a0601802d08c871", "points": [ { "method": "replace_item", @@ -20874,7 +20872,8 @@ } ], "queries": [], - "sha256": "e83fb3547eed7add20f742c362102f2a3d014c428d4157c22a0601802d08c871" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20883,8 +20882,7 @@ }, "application/single_app/functions_orchestration_runs.py::update_orchestration_run": { "boundary": { - "batches": [], - "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039", + "sha256": "9e6146a64875676f993aeadf6d179736d27fd19d1af367f23db700d735b6425b", "points": [ { "method": "read_item", @@ -20898,7 +20896,8 @@ } ], "queries": [], - "sha256": "9e6146a64875676f993aeadf6d179736d27fd19d1af367f23db700d735b6425b" + "batches": [], + "module_sha256": "35c21893df6d9283bae90a67752a6b28ecebb4fb650671017568aaea5c807039" }, "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. Review 0.261.380: Module-only public step metadata allowlist extension; this storage owner AST, ownership guards and conditional ETag semantics are unchanged.", @@ -20909,8 +20908,7 @@ }, "application/single_app/functions_orchestration_scheduler.py::enumerate_due_runs": { "boundary": { - "batches": [], - "module_sha256": "0d442d45b7e1e7383233a2fcfcdbef5eb04273f8fcc3e086a3d634ec85c865eb", + "sha256": "e89b1134b8d9b318baeb5772f41bcf07e9404c4dbd9e086a37807ad43df1efbe", "points": [], "queries": [ { @@ -20919,7 +20917,8 @@ "response": "consumed" } ], - "sha256": "e89b1134b8d9b318baeb5772f41bcf07e9404c4dbd9e086a37807ad43df1efbe" + "batches": [], + "module_sha256": "0d442d45b7e1e7383233a2fcfcdbef5eb04273f8fcc3e086a3d634ec85c865eb" }, "classification": "sdk-compatible", "contract": "The bounded SQL/iterator selector scan consumes plain Cosmos query rows. Workflow-owned children are excluded in SQL and rechecked by run/output processing.", @@ -20931,8 +20930,7 @@ }, "application/single_app/functions_orchestration_workflow_context.py::_read_global_agents": { "boundary": { - "batches": [], - "module_sha256": "2d2ad8dc7be873f2b942194f26344b31f8c8866484c03ebb2591d1efd1dff05c", + "sha256": "45b55354ec653ccd5afa52e398746d8c8f04c1fef8899a88eeec56cac1785b6c", "points": [], "queries": [ { @@ -20941,7 +20939,8 @@ "response": "consumed" } ], - "sha256": "45b55354ec653ccd5afa52e398746d8c8f04c1fef8899a88eeec56cac1785b6c" + "batches": [], + "module_sha256": "2d2ad8dc7be873f2b942194f26344b31f8c8866484c03ebb2591d1efd1dff05c" }, "classification": "sdk-compatible", "contract": "Enabled global-agent discovery materializes plain cross-partition query rows; nested catalog shape checks do not consume a point wrapper.", @@ -20952,8 +20951,7 @@ }, "application/single_app/functions_orchestration_workflow_context.py::_read_personal_agents": { "boundary": { - "batches": [], - "module_sha256": "2d2ad8dc7be873f2b942194f26344b31f8c8866484c03ebb2591d1efd1dff05c", + "sha256": "0906e7c2325148feb77c91723ecf29f5f88d734b1d99de2ea202c043cb822866", "points": [], "queries": [ { @@ -20962,7 +20960,8 @@ "response": "consumed" } ], - "sha256": "0906e7c2325148feb77c91723ecf29f5f88d734b1d99de2ea202c043cb822866" + "batches": [], + "module_sha256": "2d2ad8dc7be873f2b942194f26344b31f8c8866484c03ebb2591d1efd1dff05c" }, "classification": "sdk-compatible", "contract": "Projected personal-agent query rows are plain dictionaries materialized into a list in the user partition; no point document reaches the planning catalog.", @@ -20973,8 +20972,7 @@ }, "application/single_app/functions_orchestration_workflow_context.py::_read_wait_workflows": { "boundary": { - "batches": [], - "module_sha256": "2d2ad8dc7be873f2b942194f26344b31f8c8866484c03ebb2591d1efd1dff05c", + "sha256": "e2340bd8034c2590807413acb493988fe8692e07f2e3fdf40b3eac3cea72120c", "points": [], "queries": [ { @@ -20983,7 +20981,8 @@ "response": "consumed" } ], - "sha256": "e2340bd8034c2590807413acb493988fe8692e07f2e3fdf40b3eac3cea72120c" + "batches": [], + "module_sha256": "2d2ad8dc7be873f2b942194f26344b31f8c8866484c03ebb2591d1efd1dff05c" }, "classification": "sdk-compatible", "contract": "The explicit workflow-id selection returns a list of plain query rows from the user partition, or an empty list before storage for an empty selection.", @@ -20994,8 +20993,7 @@ }, "application/single_app/functions_orchestration_workflow_context.py::_read_workflows": { "boundary": { - "batches": [], - "module_sha256": "2d2ad8dc7be873f2b942194f26344b31f8c8866484c03ebb2591d1efd1dff05c", + "sha256": "b352f70af4c3ae5845d5fc6fd8ebfa464b915520b149a6ac0652ce61fdbe31a7", "points": [], "queries": [ { @@ -21004,7 +21002,8 @@ "response": "consumed" } ], - "sha256": "b352f70af4c3ae5845d5fc6fd8ebfa464b915520b149a6ac0652ce61fdbe31a7" + "batches": [], + "module_sha256": "2d2ad8dc7be873f2b942194f26344b31f8c8866484c03ebb2591d1efd1dff05c" }, "classification": "sdk-compatible", "contract": "The bounded personal-workflow catalog is a list of plain projected query rows in the user partition, not a point-response normalization boundary.", @@ -21015,8 +21014,7 @@ }, "application/single_app/functions_orchestration_workflow_handoff_decisions.py::_read_workflow": { "boundary": { - "batches": [], - "module_sha256": "9c33fd634a1bb72f2c5af417932b94a11e4162cdd9bdefad57b857bea91d30f1", + "sha256": "7046771aae4163c50a6a75812ed9c5b6cf93d7a994c803a5026e4b5f68faebd1", "points": [ { "method": "read_item", @@ -21025,7 +21023,8 @@ } ], "queries": [], - "sha256": "7046771aae4163c50a6a75812ed9c5b6cf93d7a994c803a5026e4b5f68faebd1" + "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.", @@ -21036,8 +21035,7 @@ }, "application/single_app/functions_orchestration_workflow_handoff_decisions.py::_read_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "9c33fd634a1bb72f2c5af417932b94a11e4162cdd9bdefad57b857bea91d30f1", + "sha256": "2958aa37adb6b4a35103f111c710730a2642354a40689423a7df6a37119133cb", "points": [ { "method": "read_item", @@ -21046,7 +21044,8 @@ } ], "queries": [], - "sha256": "2958aa37adb6b4a35103f111c710730a2642354a40689423a7df6a37119133cb" + "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.", @@ -21057,8 +21056,7 @@ }, "application/single_app/functions_orchestration_workflow_proposals.py::_read_workflow": { "boundary": { - "batches": [], - "module_sha256": "dd1ea4cedf89874f6826fe112f7163eb5ec98ef9a56e0811699200b8ab3fe282", + "sha256": "9fd6a30bf07ccf1d641c0c1906e91590873116ae4bcc28d7afb089a79da198e8", "points": [ { "method": "read_item", @@ -21067,7 +21065,8 @@ } ], "queries": [], - "sha256": "9fd6a30bf07ccf1d641c0c1906e91590873116ae4bcc28d7afb089a79da198e8" + "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.", @@ -21078,8 +21077,7 @@ }, "application/single_app/functions_orchestration_workflow_results.py::_point_read": { "boundary": { - "batches": [], - "module_sha256": "a2b558c3b5f49091cc64dcc3baa0347c900c362b5e307c5ef20ba25b56580162", + "sha256": "6fa766ae95769ada7b35c40e690442afab1fd62bf50122d398e32315f480bb73", "points": [ { "method": "read_item", @@ -21088,7 +21086,8 @@ } ], "queries": [], - "sha256": "6fa766ae95769ada7b35c40e690442afab1fd62bf50122d398e32315f480bb73" + "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.", @@ -21099,8 +21098,7 @@ }, "application/single_app/functions_orchestration_workflow_results.py::_query_runs": { "boundary": { - "batches": [], - "module_sha256": "a2b558c3b5f49091cc64dcc3baa0347c900c362b5e307c5ef20ba25b56580162", + "sha256": "7c46cc5f8775b087ed97063980d342a012e38f8ee4917a5f9f0539ad5bb2dd26", "points": [], "queries": [ { @@ -21109,7 +21107,8 @@ "response": "consumed" } ], - "sha256": "7c46cc5f8775b087ed97063980d342a012e38f8ee4917a5f9f0539ad5bb2dd26" + "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.", @@ -21120,8 +21119,7 @@ }, "application/single_app/functions_orchestration_workflow_run_links.py::_point_read": { "boundary": { - "batches": [], - "module_sha256": "dccc59a97c88abeae9582ca8534dfdc88e02065e3428b5ab1420c9e7b36c0f78", + "sha256": "a98f78276f1e644076a80c55d0fcf2409f629c8191a8a4046ddc3768c3d6ef85", "points": [ { "method": "read_item", @@ -21130,7 +21128,8 @@ } ], "queries": [], - "sha256": "a98f78276f1e644076a80c55d0fcf2409f629c8191a8a4046ddc3768c3d6ef85" + "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.", @@ -21141,8 +21140,7 @@ }, "application/single_app/functions_orchestration_workflow_runs.py::_point_read": { "boundary": { - "batches": [], - "module_sha256": "e5dafb70ae7505bddb42f98995f576e7845a1709c887238e2574c69fc71b216a", + "sha256": "db3c40849fc4470d14db15dd7f4bf5c8275df0612db5ec1ef1df4309a820f8f6", "points": [ { "method": "read_item", @@ -21151,7 +21149,8 @@ } ], "queries": [], - "sha256": "db3c40849fc4470d14db15dd7f4bf5c8275df0612db5ec1ef1df4309a820f8f6" + "batches": [], + "module_sha256": "e5dafb70ae7505bddb42f98995f576e7845a1709c887238e2574c69fc71b216a" }, "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.", @@ -21164,8 +21163,7 @@ }, "application/single_app/functions_orchestration_workflow_runs.py::_write_plan_wait": { "boundary": { - "batches": [], - "module_sha256": "e5dafb70ae7505bddb42f98995f576e7845a1709c887238e2574c69fc71b216a", + "sha256": "2e849c7d0aec76c8ba714e0279c8d17205b25abb46bdb58172ae923e97f62f4f", "points": [ { "method": "read_item", @@ -21179,7 +21177,8 @@ } ], "queries": [], - "sha256": "2e849c7d0aec76c8ba714e0279c8d17205b25abb46bdb58172ae923e97f62f4f" + "batches": [], + "module_sha256": "e5dafb70ae7505bddb42f98995f576e7845a1709c887238e2574c69fc71b216a" }, "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.", @@ -21192,8 +21191,7 @@ }, "application/single_app/functions_personal_actions.py::_ensure_personal_secret_name_available": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "3df83bab95634d15119e2ea5dfbf35a1989dc025158117bc018f423835912ba5", "points": [], "queries": [ { @@ -21202,7 +21200,8 @@ "response": "consumed" } ], - "sha256": "3df83bab95634d15119e2ea5dfbf35a1989dc025158117bc018f423835912ba5" + "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.", @@ -21213,8 +21212,7 @@ }, "application/single_app/functions_personal_actions.py::_find_personal_action_record": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "99cd4c13818d7dea5ac11b425f8bd83f5f5218636ec1147fa563b8a9789e1626", "points": [], "queries": [ { @@ -21223,7 +21221,8 @@ "response": "consumed" } ], - "sha256": "99cd4c13818d7dea5ac11b425f8bd83f5f5218636ec1147fa563b8a9789e1626" + "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.", @@ -21234,14 +21233,7 @@ }, "application/single_app/functions_personal_actions.py::_migrate_historical_msgraph_action": { "boundary": { - "batches": [ - { - "method": "execute_item_batch", - "receiver": "cosmos_personal_actions_container", - "response": "unused" - } - ], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "ec28c39932d1d73699e1632f07299537dfa8d0895aa0b94d8050898a8db9aa5e", "points": [ { "method": "read_item", @@ -21266,7 +21258,14 @@ "response": "consumed" } ], - "sha256": "ec28c39932d1d73699e1632f07299537dfa8d0895aa0b94d8050898a8db9aa5e" + "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.", @@ -21277,8 +21276,7 @@ }, "application/single_app/functions_personal_actions.py::_read_legacy_settings_document": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "966450ea66c071dc40a40962cf5b4111958cdcb16ca375832a2561614b755e34", "points": [ { "method": "read_item", @@ -21287,7 +21285,8 @@ } ], "queries": [], - "sha256": "966450ea66c071dc40a40962cf5b4111958cdcb16ca375832a2561614b755e34" + "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.", @@ -21298,8 +21297,7 @@ }, "application/single_app/functions_personal_actions.py::_read_legacy_settings_for_preflight": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "a4f794ede4d12fea4c27cebd0b8570cece6125cab5461d5c6061346b341abf14", "points": [ { "method": "read_item", @@ -21308,7 +21306,8 @@ } ], "queries": [], - "sha256": "a4f794ede4d12fea4c27cebd0b8570cece6125cab5461d5c6061346b341abf14" + "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.", @@ -21319,8 +21318,7 @@ }, "application/single_app/functions_personal_actions.py::_read_personal_action_record": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "33433fddfbbff8cdb1ed4732e03d87a91800a0a88801e19df0060f9571da5b0b", "points": [ { "method": "read_item", @@ -21329,7 +21327,8 @@ } ], "queries": [], - "sha256": "33433fddfbbff8cdb1ed4732e03d87a91800a0a88801e19df0060f9571da5b0b" + "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.", @@ -21340,8 +21339,7 @@ }, "application/single_app/functions_personal_actions.py::_remove_legacy_snapshot": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "5b8605b91fdf2c2670dcb26fb5b2ed5c382524b061cf63305627d65e3b770055", "points": [ { "method": "replace_item", @@ -21350,7 +21348,8 @@ } ], "queries": [], - "sha256": "5b8605b91fdf2c2670dcb26fb5b2ed5c382524b061cf63305627d65e3b770055" + "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.", @@ -21361,8 +21360,7 @@ }, "application/single_app/functions_personal_actions.py::_save_personal_action": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "e50b7a7507eb4657ba87ee41e68c8a6734df5d713dc360fa81086a250942734f", "points": [ { "method": "replace_item", @@ -21381,7 +21379,8 @@ } ], "queries": [], - "sha256": "e50b7a7507eb4657ba87ee41e68c8a6734df5d713dc360fa81086a250942734f" + "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.", @@ -21392,8 +21391,7 @@ }, "application/single_app/functions_personal_actions.py::delete_personal_action": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "90848722b373be749fef5850885aff8b92a48b710acb901ae84052e688389eaa", "points": [ { "method": "delete_item", @@ -21402,7 +21400,8 @@ } ], "queries": [], - "sha256": "90848722b373be749fef5850885aff8b92a48b710acb901ae84052e688389eaa" + "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.", @@ -21411,8 +21410,7 @@ }, "application/single_app/functions_personal_actions.py::get_actions_by_names": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "006ccb8772101c4705d843106e65867d90bf3264b7898c92ee48512f5d7fa38f", "points": [], "queries": [ { @@ -21421,7 +21419,8 @@ "response": "consumed" } ], - "sha256": "006ccb8772101c4705d843106e65867d90bf3264b7898c92ee48512f5d7fa38f" + "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.", @@ -21432,8 +21431,7 @@ }, "application/single_app/functions_personal_actions.py::get_actions_by_type": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "0745aacc64d9a74633de8194b14f83771b6bf0c9a561edb035eec65bae9bc46c", "points": [], "queries": [ { @@ -21442,7 +21440,8 @@ "response": "consumed" } ], - "sha256": "0745aacc64d9a74633de8194b14f83771b6bf0c9a561edb035eec65bae9bc46c" + "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.", @@ -21453,8 +21452,7 @@ }, "application/single_app/functions_personal_actions.py::get_personal_actions": { "boundary": { - "batches": [], - "module_sha256": "aeee3190c8114944170758908567125e54d729739e28d671da4c50b5077f9620", + "sha256": "2e73277210b65a3da0c8cd5ec553817110c5c28770711916c2637a217f91f8e2", "points": [], "queries": [ { @@ -21463,7 +21461,8 @@ "response": "consumed" } ], - "sha256": "2e73277210b65a3da0c8cd5ec553817110c5c28770711916c2637a217f91f8e2" + "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.", @@ -21474,8 +21473,7 @@ }, "application/single_app/functions_personal_agents.py::delete_personal_agent": { "boundary": { - "batches": [], - "module_sha256": "268f813605323b0b8c5a8a3d20c55c5ad565446ffb598f9780b5bed39130ccef", + "sha256": "cbb121927feadb63ba7f080a826508abc07a35a7ecc723ceb4eb7e2074f3bca7", "points": [ { "method": "delete_item", @@ -21484,7 +21482,8 @@ } ], "queries": [], - "sha256": "cbb121927feadb63ba7f080a826508abc07a35a7ecc723ceb4eb7e2074f3bca7" + "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.", @@ -21493,8 +21492,7 @@ }, "application/single_app/functions_personal_agents.py::get_personal_agent": { "boundary": { - "batches": [], - "module_sha256": "268f813605323b0b8c5a8a3d20c55c5ad565446ffb598f9780b5bed39130ccef", + "sha256": "a16c10ff47895f40cbaf4273c95077c7dc6690a860d678472e5e988fd79be025", "points": [ { "method": "read_item", @@ -21503,7 +21501,8 @@ } ], "queries": [], - "sha256": "a16c10ff47895f40cbaf4273c95077c7dc6690a860d678472e5e988fd79be025" + "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.", @@ -21514,8 +21513,7 @@ }, "application/single_app/functions_personal_agents.py::get_personal_agents": { "boundary": { - "batches": [], - "module_sha256": "268f813605323b0b8c5a8a3d20c55c5ad565446ffb598f9780b5bed39130ccef", + "sha256": "87d9137a5a0113b91068f517e5adf55fc8d2465bbc6708bd241ecacee3badf62", "points": [], "queries": [ { @@ -21524,7 +21522,8 @@ "response": "consumed" } ], - "sha256": "87d9137a5a0113b91068f517e5adf55fc8d2465bbc6708bd241ecacee3badf62" + "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.", @@ -21535,8 +21534,7 @@ }, "application/single_app/functions_personal_agents.py::save_personal_agent": { "boundary": { - "batches": [], - "module_sha256": "268f813605323b0b8c5a8a3d20c55c5ad565446ffb598f9780b5bed39130ccef", + "sha256": "16a81cf2e270c861a742292e849958a06994e393b91e328cd121aa49192acda9", "points": [ { "method": "read_item", @@ -21550,7 +21548,8 @@ } ], "queries": [], - "sha256": "16a81cf2e270c861a742292e849958a06994e393b91e328cd121aa49192acda9" + "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.", @@ -21561,8 +21560,7 @@ }, "application/single_app/functions_personal_workflows.py::_normalize_personal_workflow_conversation_id": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "5e40d033f27436cf47e80fb448236c229886e5934fbfb68068b9f10ccc89e6bc", "points": [ { "method": "read_item", @@ -21571,7 +21569,8 @@ } ], "queries": [], - "sha256": "5e40d033f27436cf47e80fb448236c229886e5934fbfb68068b9f10ccc89e6bc" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Conversation point Mapping is consumed through get for workflow type, owner and group-scope authorization; no strict dict gate.", @@ -21582,8 +21581,7 @@ }, "application/single_app/functions_personal_workflows.py::_save_chat_started_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "511c71bc730dc14b9ba099ffde4d9ac8b7f8a418cd6a90d7a29bb48fd81cbf13", "points": [ { "method": "read_item", @@ -21617,7 +21615,8 @@ } ], "queries": [], - "sha256": "511c71bc730dc14b9ba099ffde4d9ac8b7f8a418cd6a90d7a29bb48fd81cbf13" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Stored SDK Mapping is merged via Mapping-compatible delivery helpers and get(_etag); conditional replacement returns a Mapping consumed by the enclosing metadata projection. Upsert fallback uses the same projection.", @@ -21628,8 +21627,7 @@ }, "application/single_app/functions_personal_workflows.py::count_personal_handoff_workflows_since": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "eaafb6ad237a0068595e305c0ea94c12cf8868581cff5edce2980c1eea0e8f9a", "points": [], "queries": [ { @@ -21638,7 +21636,8 @@ "response": "consumed" } ], - "sha256": "eaafb6ad237a0068595e305c0ea94c12cf8868581cff5edce2980c1eea0e8f9a" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "SELECT VALUE COUNT query yields scalar integers, not Cosmos point documents; the first scalar is converted to int and storage failures propagate.", @@ -21649,8 +21648,7 @@ }, "application/single_app/functions_personal_workflows.py::count_personal_orchestration_workflows": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "6936e5a68535e2feb61598b7ee5f8972ce7fe4201ee5449261fe5eca22bc16f3", "points": [], "queries": [ { @@ -21659,7 +21657,8 @@ "response": "consumed" } ], - "sha256": "6936e5a68535e2feb61598b7ee5f8972ce7fe4201ee5449261fe5eca22bc16f3" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "SELECT VALUE COUNT query yields scalar integers, not Cosmos point documents; the first scalar is converted to int and storage failures propagate.", @@ -21670,8 +21669,7 @@ }, "application/single_app/functions_personal_workflows.py::delete_personal_workflow": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "bcb28cca6eb2ab10b8ed03c4353f0bb92aa9a6725fd6b8915e00ea221ea64ef8", "points": [ { "method": "delete_item", @@ -21701,7 +21699,8 @@ "response": "consumed" } ], - "sha256": "bcb28cca6eb2ab10b8ed03c4353f0bb92aa9a6725fd6b8915e00ea221ea64ef8" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "response-unused", "contract": "Delete point responses are unused. Run/item query projections are ordinary SDK dictionary rows consumed only with get; workflow point read is normalized by get_personal_workflow.", @@ -21709,8 +21708,7 @@ }, "application/single_app/functions_personal_workflows.py::get_due_personal_workflows": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "6f75b0a51958e7b20774e4f13635d9e082cefcb4e0f9aaf646c3ada307947908", "points": [], "queries": [ { @@ -21719,7 +21717,8 @@ "response": "consumed" } ], - "sha256": "6f75b0a51958e7b20774e4f13635d9e082cefcb4e0f9aaf646c3ada307947908" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Query yields SDK ordinary dictionary rows; each is projected through _strip_cosmos_metadata into a domain dictionary.", @@ -21730,8 +21729,7 @@ }, "application/single_app/functions_personal_workflows.py::get_latest_personal_workflow_run_for_conversation": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "15bfd6ef0164f2b0cecc09f174ea59e7603c28bbfa2449b5f46419e512da1ed0", "points": [], "queries": [ { @@ -21740,7 +21738,8 @@ "response": "consumed" } ], - "sha256": "15bfd6ef0164f2b0cecc09f174ea59e7603c28bbfa2449b5f46419e512da1ed0" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Latest-run query row is an ordinary dictionary and is metadata-projected; no strict point-response assumption.", @@ -21751,8 +21750,7 @@ }, "application/single_app/functions_personal_workflows.py::get_personal_workflow": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "e4d69b9a01898a394367b60bbd789c8b35459c66315135b3b03160685e4baa1b", "points": [ { "method": "read_item", @@ -21761,7 +21759,8 @@ } ], "queries": [], - "sha256": "e4d69b9a01898a394367b60bbd789c8b35459c66315135b3b03160685e4baa1b" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "SDK CosmosDict point response passes through metadata projection using Mapping.items, yielding an ordinary dictionary without a strict dict gate.", @@ -21772,8 +21771,7 @@ }, "application/single_app/functions_personal_workflows.py::get_personal_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "7949285738d3746f20d3612f307f5743972d1d7cb80aed5765fb29ed29d9aaa2", "points": [ { "method": "read_item", @@ -21782,7 +21780,8 @@ } ], "queries": [], - "sha256": "7949285738d3746f20d3612f307f5743972d1d7cb80aed5765fb29ed29d9aaa2" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "SDK CosmosDict point response is metadata-projected into a plain domain dictionary; missing scoped points return None.", @@ -21793,8 +21792,7 @@ }, "application/single_app/functions_personal_workflows.py::get_personal_workflow_run_item": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "df27269210c84bd6330118096dad40ab0a83e668b92c8335f91959478a37e4fd", "points": [ { "method": "read_item", @@ -21803,7 +21801,8 @@ } ], "queries": [], - "sha256": "df27269210c84bd6330118096dad40ab0a83e668b92c8335f91959478a37e4fd" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "SDK point Mapping is checked for public item type using get, then metadata-projected to a dictionary; internal chunk points remain hidden.", @@ -21814,8 +21813,7 @@ }, "application/single_app/functions_personal_workflows.py::get_personal_workflows": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "905773d0f45b8da0ea7267122256674ef6f28e6fb5c8e5dda1b8d213d8f61fe8", "points": [], "queries": [ { @@ -21824,7 +21822,8 @@ "response": "consumed" } ], - "sha256": "905773d0f45b8da0ea7267122256674ef6f28e6fb5c8e5dda1b8d213d8f61fe8" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Query rows are plain SDK dictionaries; metadata projection returns ordinary domain dictionaries in the requested owner partition.", @@ -21835,8 +21834,7 @@ }, "application/single_app/functions_personal_workflows.py::list_personal_workflow_run_items": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "0d8f662f26ab5c5170c1ce9fb7385dfd0652391181098849024c892767fbe26b", "points": [], "queries": [ { @@ -21845,7 +21843,8 @@ "response": "consumed" } ], - "sha256": "0d8f662f26ab5c5170c1ce9fb7385dfd0652391181098849024c892767fbe26b" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Plain query rows are checked using Mapping.get, internal result chunks are excluded, and public rows become metadata-free dictionaries.", @@ -21856,8 +21855,7 @@ }, "application/single_app/functions_personal_workflows.py::list_personal_workflow_runs": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "6d2d86fa5267db9e57e7c731107031050c8e56d398fad237a5763c670f2a8d7a", "points": [], "queries": [ { @@ -21866,7 +21864,8 @@ "response": "consumed" } ], - "sha256": "6d2d86fa5267db9e57e7c731107031050c8e56d398fad237a5763c670f2a8d7a" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Run query rows use metadata projection and list slicing, accepting SDK ordinary dictionary query rows.", @@ -21877,8 +21876,7 @@ }, "application/single_app/functions_personal_workflows.py::save_personal_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "fe26c875be74be57211c0d7af42e7533a39273af3aac438fa97a994b3a2bfb98", "points": [ { "method": "upsert_item", @@ -21887,20 +21885,20 @@ } ], "queries": [], - "sha256": "fe26c875be74be57211c0d7af42e7533a39273af3aac438fa97a994b3a2bfb98" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Upsert or guarded-write CosmosDict response is metadata-projected into an ordinary domain dictionary before downstream consumers.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_workflow_configuration.py::test_workflow_storage_owners_accept_sdk_points_and_plain_query_rows", - "functional_tests/test_workflow_configuration.py::test_personal_guarded_run_save_preserves_sdk_point_metadata_and_conditional_writes" + "functional_tests/test_workflow_configuration.py::test_personal_guarded_run_save_preserves_sdk_point_metadata_and_conditional_writes", + "functional_tests/test_workflow_configuration.py::test_workflow_storage_owners_accept_sdk_points_and_plain_query_rows" ] }, "application/single_app/functions_personal_workflows.py::save_personal_workflow_run_item": { "boundary": { - "batches": [], - "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854", + "sha256": "82054fc1eaa6329001278d6b54792a208f848ec5e21b51abfadc7a3b99085175", "points": [ { "method": "upsert_item", @@ -21909,7 +21907,8 @@ } ], "queries": [], - "sha256": "82054fc1eaa6329001278d6b54792a208f848ec5e21b51abfadc7a3b99085175" + "batches": [], + "module_sha256": "c7745f199c123d338ae794c0ef1f164de7cf639e1720ba240b9ee46459add854" }, "classification": "sdk-compatible", "contract": "Upsert CosmosDict response is immediately projected using Mapping.items into a metadata-free public item dictionary.", @@ -21920,8 +21919,7 @@ }, "application/single_app/functions_prompt_variables.py::_authorize_conversation": { "boundary": { - "batches": [], - "module_sha256": "73b406b394dd9d1f32f9079a9d367c83155832ffa4de65143ada2631a71d1cec", + "sha256": "f73d52df0fcf271a72ed466c359a908179d42f1f7b235037f11f97ffd24b6ec7", "points": [ { "method": "read_item", @@ -21930,7 +21928,8 @@ } ], "queries": [], - "sha256": "f73d52df0fcf271a72ed466c359a908179d42f1f7b235037f11f97ffd24b6ec7" + "batches": [], + "module_sha256": "73b406b394dd9d1f32f9079a9d367c83155832ffa4de65143ada2631a71d1cec" }, "classification": "sdk-compatible", "contract": "The personal conversation CosmosDict is checked through id/user_id fields; success returns None and missing/wrong-owner points follow the existing 403 error path. Collaboration remains with its participation owner.", @@ -21941,8 +21940,7 @@ }, "application/single_app/functions_prompts.py::_query_prompt_items": { "boundary": { - "batches": [], - "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9", + "sha256": "50059c1a04f465ebd370975bc34207e64b2856f8a2b3ffe387c05b795637c276", "points": [], "queries": [ { @@ -21951,7 +21949,8 @@ "response": "consumed" } ], - "sha256": "50059c1a04f465ebd370975bc34207e64b2856f8a2b3ffe387c05b795637c276" + "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.", @@ -21962,8 +21961,7 @@ }, "application/single_app/functions_prompts.py::_read_prompt_from_container": { "boundary": { - "batches": [], - "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9", + "sha256": "16caa9c766d1dea027b30a0f2c5a8ea0c92ec1b6478c02ff673f45d74f66ae18", "points": [ { "method": "read_item", @@ -21972,7 +21970,8 @@ } ], "queries": [], - "sha256": "16caa9c766d1dea027b30a0f2c5a8ea0c92ec1b6478c02ff673f45d74f66ae18" + "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.", @@ -21983,8 +21982,7 @@ }, "application/single_app/functions_prompts.py::create_prompt_doc": { "boundary": { - "batches": [], - "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9", + "sha256": "b464693e2669b8267778bd4d7883514c587a60151eda3b6528f501f39a72b23c", "points": [ { "method": "create_item", @@ -21993,7 +21991,8 @@ } ], "queries": [], - "sha256": "b464693e2669b8267778bd4d7883514c587a60151eda3b6528f501f39a72b23c" + "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.", @@ -22004,8 +22003,7 @@ }, "application/single_app/functions_prompts.py::delete_prompt_doc": { "boundary": { - "batches": [], - "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9", + "sha256": "cfbbb31f8f281c65f967af29c78bbe6ed7a36b5348c44ae202ebda73a636a67c", "points": [ { "method": "delete_item", @@ -22019,7 +22017,8 @@ } ], "queries": [], - "sha256": "cfbbb31f8f281c65f967af29c78bbe6ed7a36b5348c44ae202ebda73a636a67c" + "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.", @@ -22028,8 +22027,7 @@ }, "application/single_app/functions_prompts.py::update_prompt_doc": { "boundary": { - "batches": [], - "module_sha256": "5f7a27f3398bbde6b85c2df1c85b59e01bf4da73805c925713a457db890cffe9", + "sha256": "7ae83bcad6788d077d497aa5eb71f70011a174faba0428fa5b0571db5d705e84", "points": [ { "method": "replace_item", @@ -22043,7 +22041,8 @@ } ], "queries": [], - "sha256": "7ae83bcad6788d077d497aa5eb71f70011a174faba0428fa5b0571db5d705e84" + "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.", @@ -22054,8 +22053,7 @@ }, "application/single_app/functions_public_directory.py::list_public_directory": { "boundary": { - "batches": [], - "module_sha256": "216c19080c4ed2630f1b5009c59ddf991d7be30414428765a77a776535ca3f75", + "sha256": "a29a206b814ae898df118ae2f34f500380698d7aa6fc833770213c039f8a8a51", "points": [], "queries": [ { @@ -22064,7 +22062,8 @@ "response": "consumed" } ], - "sha256": "a29a206b814ae898df118ae2f34f500380698d7aa6fc833770213c039f8a8a51" + "batches": [], + "module_sha256": "216c19080c4ed2630f1b5009c59ddf991d7be30414428765a77a776535ca3f75" }, "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.", @@ -22075,8 +22074,7 @@ }, "application/single_app/functions_public_document_access.py::public_document_cleanup_allowed": { "boundary": { - "batches": [], - "module_sha256": "fa73a3ff6e35be847c43d5e414c9a4a5a6b876f203954122af3ae0c6a33ce07b", + "sha256": "d54c84a3e7b03bd312355685e436db98c6fc7746437f32ec578e46da8e90813b", "points": [ { "method": "read_item", @@ -22085,7 +22083,8 @@ } ], "queries": [], - "sha256": "d54c84a3e7b03bd312355685e436db98c6fc7746437f32ec578e46da8e90813b" + "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.", @@ -22096,8 +22095,7 @@ }, "application/single_app/functions_public_document_access.py::public_document_family_records": { "boundary": { - "batches": [], - "module_sha256": "fa73a3ff6e35be847c43d5e414c9a4a5a6b876f203954122af3ae0c6a33ce07b", + "sha256": "a57b3bb90045a3720be29222d474968b47bbd61ff597c0b4cd68c560b0f520c3", "points": [], "queries": [ { @@ -22106,7 +22104,8 @@ "response": "consumed" } ], - "sha256": "a57b3bb90045a3720be29222d474968b47bbd61ff597c0b4cd68c560b0f520c3" + "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.", @@ -22117,8 +22116,7 @@ }, "application/single_app/functions_public_document_access.py::read_public_document_record": { "boundary": { - "batches": [], - "module_sha256": "fa73a3ff6e35be847c43d5e414c9a4a5a6b876f203954122af3ae0c6a33ce07b", + "sha256": "d7c75804089aedace1f88f63393612453420b0d4707d5c09b34ec34055cc4c86", "points": [ { "method": "read_item", @@ -22127,7 +22125,8 @@ } ], "queries": [], - "sha256": "d7c75804089aedace1f88f63393612453420b0d4707d5c09b34ec34055cc4c86" + "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.", @@ -22138,8 +22137,7 @@ }, "application/single_app/functions_public_document_collaboration.py::_replace": { "boundary": { - "batches": [], - "module_sha256": "6afc61319c9c7443e166787d14212d7a8d6d591622c0eccd74bec3f4fdba3676", + "sha256": "672682a5122e71c121ed9cc808119d7d7752783b1b66f81055b0dac310515e7e", "points": [ { "method": "replace_item", @@ -22148,7 +22146,8 @@ } ], "queries": [], - "sha256": "672682a5122e71c121ed9cc808119d7d7752783b1b66f81055b0dac310515e7e" + "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.", @@ -22159,8 +22158,7 @@ }, "application/single_app/functions_public_document_management.py::_current_owned_documents": { "boundary": { - "batches": [], - "module_sha256": "8b0e9942726918283c85af09bcea20d43f4244f35030639721834b0211f31782", + "sha256": "1d08e7d455643773474eda546bfe06a5ee78d059c5850c4f8ebe45a9db74a3bb", "points": [], "queries": [ { @@ -22169,7 +22167,8 @@ "response": "consumed" } ], - "sha256": "1d08e7d455643773474eda546bfe06a5ee78d059c5850c4f8ebe45a9db74a3bb" + "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.", @@ -22180,8 +22179,7 @@ }, "application/single_app/functions_public_document_management.py::_patch_tag_definitions": { "boundary": { - "batches": [], - "module_sha256": "8b0e9942726918283c85af09bcea20d43f4244f35030639721834b0211f31782", + "sha256": "119f15ade791e0f6d8994a24e50f287d40e8028953905c0a8a48a8351077a113", "points": [ { "method": "patch_item", @@ -22190,7 +22188,8 @@ } ], "queries": [], - "sha256": "119f15ade791e0f6d8994a24e50f287d40e8028953905c0a8a48a8351077a113" + "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.", @@ -22201,8 +22200,7 @@ }, "application/single_app/functions_public_document_publication.py::decide_public_document_publication": { "boundary": { - "batches": [], - "module_sha256": "dd1c1aeb9dbe27b30aed1a983b7f5713c6a989008dda1cf3b2d4d61086bac117", + "sha256": "696887923d17f3ba3fb12f7feb1f6223108468f73b1790daa01f6cf18f285a9d", "points": [ { "method": "read_item", @@ -22211,7 +22209,8 @@ } ], "queries": [], - "sha256": "696887923d17f3ba3fb12f7feb1f6223108468f73b1790daa01f6cf18f285a9d" + "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.", @@ -22244,8 +22243,7 @@ }, "application/single_app/functions_public_insights.py::read_public_activity": { "boundary": { - "batches": [], - "module_sha256": "0acb8da162c6bb235ed058b3119f9b34d6e62b83cde230de1005d8ca9666caf6", + "sha256": "eeaa9a30b6ecd8d071579a2116b2cac62c3aa28d7fb75aa50da97da2e77db37a", "points": [], "queries": [ { @@ -22254,7 +22252,8 @@ "response": "consumed" } ], - "sha256": "eeaa9a30b6ecd8d071579a2116b2cac62c3aa28d7fb75aa50da97da2e77db37a" + "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.", @@ -22265,8 +22264,7 @@ }, "application/single_app/functions_public_insights.py::read_public_stats_rows": { "boundary": { - "batches": [], - "module_sha256": "0acb8da162c6bb235ed058b3119f9b34d6e62b83cde230de1005d8ca9666caf6", + "sha256": "88d3d7d8de304bb9368581b68fb3f36d0e9851a5b347dc8275c6ec8d4b9ce8ba", "points": [], "queries": [ { @@ -22275,7 +22273,8 @@ "response": "consumed" } ], - "sha256": "88d3d7d8de304bb9368581b68fb3f36d0e9851a5b347dc8275c6ec8d4b9ce8ba" + "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.", @@ -22286,8 +22285,7 @@ }, "application/single_app/functions_public_membership_audit.py::log_public_member_added": { "boundary": { - "batches": [], - "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661", + "sha256": "7d04cc19ef192e99455b1b5c5cc6a9a440384873a773fdefd3cdb2d2c1ed0e36", "points": [ { "method": "create_item", @@ -22296,7 +22294,8 @@ } ], "queries": [], - "sha256": "7d04cc19ef192e99455b1b5c5cc6a9a440384873a773fdefd3cdb2d2c1ed0e36" + "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.", @@ -22305,8 +22304,7 @@ }, "application/single_app/functions_public_membership_audit.py::log_public_member_removed": { "boundary": { - "batches": [], - "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661", + "sha256": "f56bc80fc78ee5347c9c35b92f05df8bee1d79a2b20390be0b76d48191776004", "points": [ { "method": "create_item", @@ -22315,7 +22313,8 @@ } ], "queries": [], - "sha256": "f56bc80fc78ee5347c9c35b92f05df8bee1d79a2b20390be0b76d48191776004" + "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.", @@ -22324,8 +22323,7 @@ }, "application/single_app/functions_public_membership_audit.py::log_public_member_role_change": { "boundary": { - "batches": [], - "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661", + "sha256": "ff22a336fe4ca041c508e48b8e91ccb39aa00a1961be4d2a6d31d1c80c54892e", "points": [ { "method": "create_item", @@ -22334,7 +22332,8 @@ } ], "queries": [], - "sha256": "ff22a336fe4ca041c508e48b8e91ccb39aa00a1961be4d2a6d31d1c80c54892e" + "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.", @@ -22343,8 +22342,7 @@ }, "application/single_app/functions_public_membership_audit.py::log_public_membership_request_canceled": { "boundary": { - "batches": [], - "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661", + "sha256": "650ad92185797a83ae1ba52dab481f395839f0f640acb7432ee16c9114afa32c", "points": [ { "method": "create_item", @@ -22353,7 +22351,8 @@ } ], "queries": [], - "sha256": "650ad92185797a83ae1ba52dab481f395839f0f640acb7432ee16c9114afa32c" + "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.", @@ -22362,8 +22361,7 @@ }, "application/single_app/functions_public_membership_audit.py::log_public_membership_requested": { "boundary": { - "batches": [], - "module_sha256": "360b861f437ea48aa329330c51b14a59c490e696264195b0d048477f5a64e661", + "sha256": "095446611779beaadb5e651ef9ebf64f8e710d33ee7b5bc49237d61648871e84", "points": [ { "method": "create_item", @@ -22372,7 +22370,8 @@ } ], "queries": [], - "sha256": "095446611779beaadb5e651ef9ebf64f8e710d33ee7b5bc49237d61648871e84" + "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.", @@ -22381,8 +22380,7 @@ }, "application/single_app/functions_public_workspaces.py::count_public_workspace_documents": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "6d54684e6ce3f85bc6f530b4344b5303511a5456e4c7a0e232ca98e46147b2d7", "points": [], "queries": [ { @@ -22391,7 +22389,8 @@ "response": "consumed" } ], - "sha256": "6d54684e6ce3f85bc6f530b4344b5303511a5456e4c7a0e232ca98e46147b2d7" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22402,8 +22401,7 @@ }, "application/single_app/functions_public_workspaces.py::create_public_workspace": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "f771a4ed7031479868648bf305225df607ca877dca902008c8bb4d3748ee4d89", "points": [ { "method": "create_item", @@ -22412,7 +22410,8 @@ } ], "queries": [], - "sha256": "f771a4ed7031479868648bf305225df607ca877dca902008c8bb4d3748ee4d89" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22423,8 +22422,7 @@ }, "application/single_app/functions_public_workspaces.py::delete_public_workspace": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "d6762367be43696282fe5c08a702eaa819909893eed092a315afbc457cb174f0", "points": [ { "method": "delete_item", @@ -22433,7 +22431,8 @@ } ], "queries": [], - "sha256": "d6762367be43696282fe5c08a702eaa819909893eed092a315afbc457cb174f0" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22444,8 +22443,7 @@ }, "application/single_app/functions_public_workspaces.py::find_public_workspace_by_id": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "51391e2c9dcf31628d67639d75b067189cfba5122566e78fd57bbc6c58f1cdd4", "points": [ { "method": "read_item", @@ -22454,7 +22452,8 @@ } ], "queries": [], - "sha256": "51391e2c9dcf31628d67639d75b067189cfba5122566e78fd57bbc6c58f1cdd4" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22465,8 +22464,7 @@ }, "application/single_app/functions_public_workspaces.py::find_public_workspaces_by_ids": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "847a67116c24f82b5a20ef8929580a2fbbe4bd802a4d1e4af896bbab54399b29", "points": [], "queries": [ { @@ -22475,7 +22473,8 @@ "response": "consumed" } ], - "sha256": "847a67116c24f82b5a20ef8929580a2fbbe4bd802a4d1e4af896bbab54399b29" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22486,8 +22485,7 @@ }, "application/single_app/functions_public_workspaces.py::get_all_public_workspaces": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "36fd96d6cc2d924619639600479ff82e5c1deaa44f47e7beefea27a254c7d411", "points": [], "queries": [ { @@ -22496,7 +22494,8 @@ "response": "consumed" } ], - "sha256": "36fd96d6cc2d924619639600479ff82e5c1deaa44f47e7beefea27a254c7d411" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22507,8 +22506,7 @@ }, "application/single_app/functions_public_workspaces.py::get_user_public_workspaces": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "96c0182f3d2fb2240330cef8e9bd08d74d247a85480eed811cf121b5bd0e3814", "points": [], "queries": [ { @@ -22517,7 +22515,8 @@ "response": "consumed" } ], - "sha256": "96c0182f3d2fb2240330cef8e9bd08d74d247a85480eed811cf121b5bd0e3814" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22528,8 +22527,7 @@ }, "application/single_app/functions_public_workspaces.py::list_public_workspaces_for_admin_directory": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "8f24fb4f8c9ed4a07a03e3c23f1c5635de54ed6a303283a492cf2ddc8a858e25", "points": [], "queries": [ { @@ -22538,7 +22536,8 @@ "response": "consumed" } ], - "sha256": "8f24fb4f8c9ed4a07a03e3c23f1c5635de54ed6a303283a492cf2ddc8a858e25" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22549,8 +22548,7 @@ }, "application/single_app/functions_public_workspaces.py::search_all_public_workspaces": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "3e413a713ed954bd0a3a0ad9af7fce5be104ab37e5ee7ecd2ce67829f67eeab0", "points": [], "queries": [ { @@ -22559,7 +22557,8 @@ "response": "consumed" } ], - "sha256": "3e413a713ed954bd0a3a0ad9af7fce5be104ab37e5ee7ecd2ce67829f67eeab0" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22570,8 +22569,7 @@ }, "application/single_app/functions_public_workspaces.py::search_public_workspaces": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "4fe527f7c3f0f7d4aef8b38f78675f6ff5669301a79b87399e5f7feb1d117381", "points": [], "queries": [ { @@ -22580,7 +22578,8 @@ "response": "consumed" } ], - "sha256": "4fe527f7c3f0f7d4aef8b38f78675f6ff5669301a79b87399e5f7feb1d117381" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22591,8 +22590,7 @@ }, "application/single_app/functions_public_workspaces.py::update_public_workspace_document_with_etag_guard": { "boundary": { - "batches": [], - "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797", + "sha256": "21417c1f98a2e416e48b97380319f576bd576cfdba219d80b8d7558084ead1e4", "points": [ { "method": "read_item", @@ -22606,7 +22604,8 @@ } ], "queries": [], - "sha256": "21417c1f98a2e416e48b97380319f576bd576cfdba219d80b8d7558084ead1e4" + "batches": [], + "module_sha256": "8755e3aa04cc24000ebab9454bffe57b46d0492e4390dce9c6eefad3811ec797" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", @@ -22617,8 +22616,7 @@ }, "application/single_app/functions_retention_policy.py::_delete_standard_conversation_for_retention": { "boundary": { - "batches": [], - "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b", + "sha256": "6ec4882d48aa8b3748c928459c2e7eeb07a134b539287310e75b2a1ebf30fd21", "points": [ { "method": "read_item", @@ -22653,7 +22651,8 @@ "response": "consumed" } ], - "sha256": "6ec4882d48aa8b3748c928459c2e7eeb07a134b539287310e75b2a1ebf30fd21" + "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.", @@ -22664,8 +22663,7 @@ }, "application/single_app/functions_retention_policy.py::_get_existing_public_workspace_ids": { "boundary": { - "batches": [], - "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b", + "sha256": "a010abf781e7ca52560e3e6d87f5492ef48cf891cda2dc1665fac20a0c6d1687", "points": [], "queries": [ { @@ -22674,7 +22672,8 @@ "response": "consumed" } ], - "sha256": "a010abf781e7ca52560e3e6d87f5492ef48cf891cda2dc1665fac20a0c6d1687" + "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.", @@ -22685,8 +22684,7 @@ }, "application/single_app/functions_retention_policy.py::delete_aged_conversations": { "boundary": { - "batches": [], - "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b", + "sha256": "b827d1a88c7e6de360b85d8e1485347f5c16032bceec34b61220d78a1186c8be", "points": [], "queries": [ { @@ -22695,7 +22693,8 @@ "response": "consumed" } ], - "sha256": "b827d1a88c7e6de360b85d8e1485347f5c16032bceec34b61220d78a1186c8be" + "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.", @@ -22706,8 +22705,7 @@ }, "application/single_app/functions_retention_policy.py::delete_aged_documents": { "boundary": { - "batches": [], - "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b", + "sha256": "2fa9b05c204b4c4d702e47933257a10c25611ae382d598ba548dee84a82b41e8", "points": [], "queries": [ { @@ -22716,7 +22714,8 @@ "response": "consumed" } ], - "sha256": "2fa9b05c204b4c4d702e47933257a10c25611ae382d598ba548dee84a82b41e8" + "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.", @@ -22727,8 +22726,7 @@ }, "application/single_app/functions_retention_policy.py::get_all_groups": { "boundary": { - "batches": [], - "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b", + "sha256": "7984194905e1f9c7f366d96dfdcab319d3f93c86540a681b76e32994ae87ec2b", "points": [], "queries": [ { @@ -22737,7 +22735,8 @@ "response": "consumed" } ], - "sha256": "7984194905e1f9c7f366d96dfdcab319d3f93c86540a681b76e32994ae87ec2b" + "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.", @@ -22748,8 +22747,7 @@ }, "application/single_app/functions_retention_policy.py::get_all_public_workspaces": { "boundary": { - "batches": [], - "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b", + "sha256": "5fbf9bdfb1b05af3266c9f4133b5182f18496f004e126fad8e57e2f00fb1bf27", "points": [], "queries": [ { @@ -22758,7 +22756,8 @@ "response": "consumed" } ], - "sha256": "5fbf9bdfb1b05af3266c9f4133b5182f18496f004e126fad8e57e2f00fb1bf27" + "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.", @@ -22769,8 +22768,7 @@ }, "application/single_app/functions_retention_policy.py::get_all_user_settings": { "boundary": { - "batches": [], - "module_sha256": "9b0256da2f032c98f6cfd089b618e1ef404aa1d28586adb30477644a46db730b", + "sha256": "bc530227c13ce510b35848e9f89fa4739fcf9a74495357263fbf9ec05a084fdc", "points": [], "queries": [ { @@ -22779,7 +22777,8 @@ "response": "consumed" } ], - "sha256": "bc530227c13ce510b35848e9f89fa4739fcf9a74495357263fbf9ec05a084fdc" + "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.", @@ -22790,8 +22789,7 @@ }, "application/single_app/functions_review_assist_runtime.py::_read_record": { "boundary": { - "batches": [], - "module_sha256": "1ad30bd2fd0176512faec80cb0ac6bec898c6c53f6431c8d7f7a168b650ed5ff", + "sha256": "4041d61e4cbd67b0b1e3c33d3e2f650fb21e797aa5726cf559af630e2a44a4aa", "points": [ { "method": "read_item", @@ -22800,7 +22798,8 @@ } ], "queries": [], - "sha256": "4041d61e4cbd67b0b1e3c33d3e2f650fb21e797aa5726cf559af630e2a44a4aa" + "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.", @@ -22811,8 +22810,7 @@ }, "application/single_app/functions_review_assist_runtime.py::count_prior_violations": { "boundary": { - "batches": [], - "module_sha256": "1ad30bd2fd0176512faec80cb0ac6bec898c6c53f6431c8d7f7a168b650ed5ff", + "sha256": "a363db28ec0e32ced89ac88a15fe06a37be54662672091d247cb94235521f43d", "points": [], "queries": [ { @@ -22821,7 +22819,8 @@ "response": "consumed" } ], - "sha256": "a363db28ec0e32ced89ac88a15fe06a37be54662672091d247cb94235521f43d" + "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.", @@ -22832,8 +22831,7 @@ }, "application/single_app/functions_review_center.py::_read_review_record": { "boundary": { - "batches": [], - "module_sha256": "5f0806ecc99697c866ce1112a97c8defc684b68c9bcb4c6661c3ba56d0058f35", + "sha256": "08cdb9ab8e06fa307b2299ee7dc957d754c99b9ec73b5fa7f65181a359ea0d74", "points": [ { "method": "read_item", @@ -22842,7 +22840,8 @@ } ], "queries": [], - "sha256": "08cdb9ab8e06fa307b2299ee7dc957d754c99b9ec73b5fa7f65181a359ea0d74" + "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.", @@ -22853,8 +22852,7 @@ }, "application/single_app/functions_review_center.py::replace_review_record": { "boundary": { - "batches": [], - "module_sha256": "5f0806ecc99697c866ce1112a97c8defc684b68c9bcb4c6661c3ba56d0058f35", + "sha256": "c3055cfdd1fb60dedf4f259f7ec6605cc4da83aaff88ea60fce06650802a7d23", "points": [ { "method": "read_item", @@ -22873,7 +22871,8 @@ } ], "queries": [], - "sha256": "c3055cfdd1fb60dedf4f259f7ec6605cc4da83aaff88ea60fce06650802a7d23" + "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.", @@ -22884,8 +22883,7 @@ }, "application/single_app/functions_review_center.py::resolve_review_users": { "boundary": { - "batches": [], - "module_sha256": "5f0806ecc99697c866ce1112a97c8defc684b68c9bcb4c6661c3ba56d0058f35", + "sha256": "aa9509db53619973f70937d6bb5b6e3e8cd9529e5d79306f6a08892ca74a0999", "points": [], "queries": [ { @@ -22894,7 +22892,8 @@ "response": "consumed" } ], - "sha256": "aa9509db53619973f70937d6bb5b6e3e8cd9529e5d79306f6a08892ca74a0999" + "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.", @@ -22905,8 +22904,7 @@ }, "application/single_app/functions_safety_remediation.py::_lookup_remediation_requests": { "boundary": { - "batches": [], - "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9", + "sha256": "59ab629791a167e5533e7d992e6b51606c33c40f7621f962a0673ccfa76cefde", "points": [], "queries": [ { @@ -22915,7 +22913,8 @@ "response": "consumed" } ], - "sha256": "59ab629791a167e5533e7d992e6b51606c33c40f7621f962a0673ccfa76cefde" + "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.", @@ -22926,8 +22925,7 @@ }, "application/single_app/functions_safety_remediation.py::_replace_safety_log_if_unchanged": { "boundary": { - "batches": [], - "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9", + "sha256": "395eea46a51192e55e326c7f50ca31a83a89fb0335f212688a754ae8bb53ae0a", "points": [ { "method": "upsert_item", @@ -22941,7 +22939,8 @@ } ], "queries": [], - "sha256": "395eea46a51192e55e326c7f50ca31a83a89fb0335f212688a754ae8bb53ae0a" + "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.", @@ -22952,8 +22951,7 @@ }, "application/single_app/functions_safety_remediation.py::acknowledge_safety_warning": { "boundary": { - "batches": [], - "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9", + "sha256": "bebbcf46be575953b76a32aa0d8bd0e822ede442de94c6c12476645eab972a5f", "points": [ { "method": "read_item", @@ -22972,7 +22970,8 @@ } ], "queries": [], - "sha256": "bebbcf46be575953b76a32aa0d8bd0e822ede442de94c6c12476645eab972a5f" + "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.", @@ -22983,8 +22982,7 @@ }, "application/single_app/functions_safety_remediation.py::count_pending_safety_warnings": { "boundary": { - "batches": [], - "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9", + "sha256": "8b28156825a8df2bdb68774229871250238e2c89a09e3ae1d4c96a1c6bcce3ae", "points": [], "queries": [ { @@ -22993,7 +22991,8 @@ "response": "consumed" } ], - "sha256": "8b28156825a8df2bdb68774229871250238e2c89a09e3ae1d4c96a1c6bcce3ae" + "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.", @@ -23004,8 +23003,7 @@ }, "application/single_app/functions_safety_remediation.py::get_safety_log_item": { "boundary": { - "batches": [], - "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9", + "sha256": "4bb6ceb875d0da3ea0f215132a08764868740a24030401231d718c8eaa107c83", "points": [ { "method": "read_item", @@ -23014,7 +23012,8 @@ } ], "queries": [], - "sha256": "4bb6ceb875d0da3ea0f215132a08764868740a24030401231d718c8eaa107c83" + "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.", @@ -23025,8 +23024,7 @@ }, "application/single_app/functions_safety_remediation.py::list_pending_safety_warnings": { "boundary": { - "batches": [], - "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9", + "sha256": "64ecc9bcefda3996d4029b5cbc42f621f0e310053687c1e09175f48131cfd69e", "points": [], "queries": [ { @@ -23035,7 +23033,8 @@ "response": "consumed" } ], - "sha256": "64ecc9bcefda3996d4029b5cbc42f621f0e310053687c1e09175f48131cfd69e" + "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.", @@ -23046,8 +23045,7 @@ }, "application/single_app/functions_safety_remediation.py::record_safety_warning_send": { "boundary": { - "batches": [], - "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9", + "sha256": "34f43fecd386f220a3147a02d46a7cae5e1606094191e52d42e7ab9060652d9b", "points": [ { "method": "read_item", @@ -23056,7 +23054,8 @@ } ], "queries": [], - "sha256": "34f43fecd386f220a3147a02d46a7cae5e1606094191e52d42e7ab9060652d9b" + "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.", @@ -23067,8 +23066,7 @@ }, "application/single_app/functions_safety_remediation.py::write_safety_log_updates": { "boundary": { - "batches": [], - "module_sha256": "79b7b8cf5c7d0aa4e7604128f7bee867b88c305e3a89ceb8b4d9f5112a651af9", + "sha256": "138b3e448a8ccbb2c407e1b6644d403ba21d2496ff1fa0938b6dd222311a6737", "points": [ { "method": "read_item", @@ -23087,7 +23085,8 @@ } ], "queries": [], - "sha256": "138b3e448a8ccbb2c407e1b6644d403ba21d2496ff1fa0938b6dd222311a6737" + "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.", @@ -23098,8 +23097,7 @@ }, "application/single_app/functions_saved_analysis.py::_analysis_artifact_parents": { "boundary": { - "batches": [], - "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3", + "sha256": "120f9ce8e7ffd69bbf1db054bef665a354136e157cbbc7f8c981df8716097657", "points": [], "queries": [ { @@ -23108,7 +23106,8 @@ "response": "consumed" } ], - "sha256": "120f9ce8e7ffd69bbf1db054bef665a354136e157cbbc7f8c981df8716097657" + "batches": [], + "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3" }, "classification": "sdk-compatible", "contract": "The conversation-partitioned parameterized query returns plain JSON rows; artifact/native selectors remain query parameters and no point-response conversion is inferred.", @@ -23119,8 +23118,7 @@ }, "application/single_app/functions_saved_analysis.py::_authorize_conversation": { "boundary": { - "batches": [], - "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3", + "sha256": "d1b19e615b58caeb8af0ecf974dcd298d8c3221523ce899690f4a8a1d5079595", "points": [ { "method": "read_item", @@ -23129,7 +23127,8 @@ } ], "queries": [], - "sha256": "d1b19e615b58caeb8af0ecf974dcd298d8c3221523ce899690f4a8a1d5079595" + "batches": [], + "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3" }, "classification": "sdk-compatible", "contract": "SDK point mappings retain owner/id/ETag fields and pass through the participation authorization boundary; no strict-dict assumption or identity default is added.", @@ -23140,8 +23139,7 @@ }, "application/single_app/functions_saved_analysis.py::_bind_analysis_projection_contexts": { "boundary": { - "batches": [], - "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3", + "sha256": "baa8499ae9304680634fcdeecd576a7627b2a845c385808e74daea677904a45d", "points": [ { "method": "read_item", @@ -23155,7 +23153,8 @@ } ], "queries": [], - "sha256": "baa8499ae9304680634fcdeecd576a7627b2a845c385808e74daea677904a45d" + "batches": [], + "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3" }, "classification": "sdk-compatible", "contract": "SDK point mapping is checked against the exact artifact conversation and producer; context metadata is patched using IfNotModified and its retained ETag without copying a wrapper into a strict JSON consumer.", @@ -23166,8 +23165,7 @@ }, "application/single_app/functions_saved_analysis.py::_load_authorized_message": { "boundary": { - "batches": [], - "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3", + "sha256": "333a176776ca22bbb19306afdde16dea7711ce3ad1314f9320da16b0359b19da", "points": [ { "method": "read_item", @@ -23176,7 +23174,8 @@ } ], "queries": [], - "sha256": "333a176776ca22bbb19306afdde16dea7711ce3ad1314f9320da16b0359b19da" + "batches": [], + "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3" }, "classification": "sdk-compatible", "contract": "SDK message mappings are read only after conversation participation is authorized, checked for exact message/conversation identity, and remain mapping-compatible for saved readers.", @@ -23187,8 +23186,7 @@ }, "application/single_app/functions_saved_analysis.py::_read_personal_conversation": { "boundary": { - "batches": [], - "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3", + "sha256": "5ae8ec8e1432b308ed386ee16a337be099a4a0888068ae01eb96bf817e072d1c", "points": [ { "method": "read_item", @@ -23197,7 +23195,8 @@ } ], "queries": [], - "sha256": "5ae8ec8e1432b308ed386ee16a337be099a4a0888068ae01eb96bf817e072d1c" + "batches": [], + "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3" }, "classification": "sdk-compatible", "contract": "The point response is returned as an SDK-compatible Mapping for private-conversation lineage checks, preserving identity and ETag.", @@ -23208,8 +23207,7 @@ }, "application/single_app/functions_saved_analysis.py::bind_chat_analysis_attempt": { "boundary": { - "batches": [], - "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3", + "sha256": "2bc004b90e5e208b915c2f5d644bc08b868c784b4a347bd295521554b8cb4d4e", "points": [ { "method": "read_item", @@ -23223,21 +23221,21 @@ } ], "queries": [], - "sha256": "2bc004b90e5e208b915c2f5d644bc08b868c784b4a347bd295521554b8cb4d4e" + "batches": [], + "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3" }, "classification": "sdk-compatible", "contract": "SDK point metadata and actor ownership are checked before a dictionary replacement; CAS preserves a concurrent assistant pointer and the function returns only the previous pointer.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_attempt_binding_uses_sdk_actor_metadata_and_conditional_replace", + "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_attempt_binding_keeps_a_concurrent_attempt_instead_of_replacing_it", "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_attempt_binding_rejects_another_actor_without_writing", - "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_attempt_binding_keeps_a_concurrent_attempt_instead_of_replacing_it" + "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_attempt_binding_uses_sdk_actor_metadata_and_conditional_replace" ] }, "application/single_app/functions_saved_analysis.py::bind_native_analysis_artifacts": { "boundary": { - "batches": [], - "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3", + "sha256": "a17bc97196452aa15ca361acf8d595861e24f68903bdfea4dcfe62596735618d", "points": [ { "method": "read_item", @@ -23251,20 +23249,20 @@ } ], "queries": [], - "sha256": "a17bc97196452aa15ca361acf8d595861e24f68903bdfea4dcfe62596735618d" + "batches": [], + "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3" }, "classification": "sdk-compatible", "contract": "SDK point metadata is checked for file/conversation/native-run/producer binding before nested metadata set operations with IfNotModified and the stored ETag; returned write documents are unused.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_native_artifact_binding_patches_sdk_document_with_its_etag", - "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_native_artifact_binding_does_not_overwrite_a_concurrent_sdk_document" + "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_native_artifact_binding_does_not_overwrite_a_concurrent_sdk_document", + "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_native_artifact_binding_patches_sdk_document_with_its_etag" ] }, "application/single_app/functions_saved_analysis.py::update_analysis_conversation": { "boundary": { - "batches": [], - "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3", + "sha256": "daa5dd01599c40363697e8d59579f0ccfc5c2f95064ac57a84f87f5eed62433d", "points": [ { "method": "replace_item", @@ -23273,20 +23271,20 @@ } ], "queries": [], - "sha256": "daa5dd01599c40363697e8d59579f0ccfc5c2f95064ac57a84f87f5eed62433d" + "batches": [], + "module_sha256": "877eb258682a1dfce83b5cb076b30d8f90fda087af9b2979381e88d9032527b3" }, "classification": "sdk-compatible", "contract": "Current authorized SDK mapping is unpacked into a replacement body; IfNotModified uses the current ETag and 404/412 cannot overwrite a concurrent deletion fence.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_conversation_update_uses_current_sdk_etag", - "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_conversation_update_does_not_overwrite_a_concurrent_deletion_fence" + "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_conversation_update_does_not_overwrite_a_concurrent_deletion_fence", + "functional_tests/test_saved_analysis_cosmos_owner_contract.py::test_conversation_update_uses_current_sdk_etag" ] }, "application/single_app/functions_search_service.py::_authorize_chat_upload_conversation": { "boundary": { - "batches": [], - "module_sha256": "30fd9ba3399ef45d3fe895558850c901e45d3a5895295d7db5f4e6c4968a33eb", + "sha256": "3c3492a4d44ec21724c0682922e0f6fbd3dc68894ec4bdacf20d82294159d42e", "points": [ { "method": "read_item", @@ -23295,10 +23293,11 @@ } ], "queries": [], - "sha256": "3c3492a4d44ec21724c0682922e0f6fbd3dc68894ec4bdacf20d82294159d42e" + "batches": [], + "module_sha256": "0afaa631fb35d52b9022fa8c7e777695aa84a450fc6fcbff2e7b6f1b04636a77" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", + "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_workflow_authoring_sdk_boundaries.py::test_search_upload_owners_consume_real_sdk_point_documents" @@ -23306,8 +23305,7 @@ }, "application/single_app/functions_search_service.py::_resolve_chat_upload_context": { "boundary": { - "batches": [], - "module_sha256": "30fd9ba3399ef45d3fe895558850c901e45d3a5895295d7db5f4e6c4968a33eb", + "sha256": "e795483e3a90794e3268e2833ba72694964ea9173814a9cd6a1f7e4b045e23ee", "points": [ { "method": "read_item", @@ -23322,10 +23320,11 @@ "response": "consumed" } ], - "sha256": "e795483e3a90794e3268e2833ba72694964ea9173814a9cd6a1f7e4b045e23ee" + "batches": [], + "module_sha256": "0afaa631fb35d52b9022fa8c7e777695aa84a450fc6fcbff2e7b6f1b04636a77" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", + "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_workflow_authoring_sdk_boundaries.py::test_search_upload_owners_consume_real_sdk_point_documents" @@ -23333,8 +23332,7 @@ }, "application/single_app/functions_settings.py::_clear_stale_active_group": { "boundary": { - "batches": [], - "module_sha256": "62ba13df47d0fd207cfbb2729994125fb18c1f91dc6518ace19dc7f3b8ee1359", + "sha256": "8056026bd02ac3384eb8dab465006a366b652bd48d8aafde5a586cf9eab7444d", "points": [ { "method": "read_item", @@ -23348,7 +23346,8 @@ } ], "queries": [], - "sha256": "8056026bd02ac3384eb8dab465006a366b652bd48d8aafde5a586cf9eab7444d" + "batches": [], + "module_sha256": "8011b2e5de9a15654552e4c6bff2b43ee315ee6a1014e71df03fc0c1763eea03" }, "classification": "sdk-compatible", "contract": "Fresh SDK mappings are consumed via get/item access; nested settings remain plain JSON, ETags are preserved for conditional replace, and the returned SDK mapping refreshes the request cache with the committed ETag. Real-owner recovery tests cover persisted null, request/UI caches and matching ETags, SDK representation, missing ETags, authorization, conflicts and concurrent selections. Review 0.261.380: Module-only four completeness defaults; this storage owner AST and response consumer are unchanged. Review renewed for 0.261.389: The connection-list normalizer projects only nested JSON endpoint records, preserving the SDK settings document, revision/ETag, OCC and cache-publication contracts. The selected API boolean and canonical URL are validated before the normal save path.", @@ -23359,8 +23358,7 @@ }, "application/single_app/functions_settings.py::_get_app_settings_store": { "boundary": { - "batches": [], - "module_sha256": "62ba13df47d0fd207cfbb2729994125fb18c1f91dc6518ace19dc7f3b8ee1359", + "sha256": "bc6d3efd58cae9b3e1b692f5b541b9c385fbe1ee6ce71a0ad64fff5df44f7748", "points": [ { "method": "read_item", @@ -23369,7 +23367,8 @@ } ], "queries": [], - "sha256": "bc6d3efd58cae9b3e1b692f5b541b9c385fbe1ee6ce71a0ad64fff5df44f7748" + "batches": [], + "module_sha256": "8011b2e5de9a15654552e4c6bff2b43ee315ee6a1014e71df03fc0c1763eea03" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Review 0.261.380: Module-only four completeness defaults; this storage owner AST and response consumer are unchanged. Review renewed for 0.261.389: The connection-list normalizer projects only nested JSON endpoint records, preserving the SDK settings document, revision/ETag, OCC and cache-publication contracts. The selected API boolean and canonical URL are validated before the normal save path.", @@ -23380,8 +23379,7 @@ }, "application/single_app/functions_settings.py::add_search_to_history": { "boundary": { - "batches": [], - "module_sha256": "62ba13df47d0fd207cfbb2729994125fb18c1f91dc6518ace19dc7f3b8ee1359", + "sha256": "4b3c61716e5517b6dfc5f67cbb532a034281458e33c20375ddddb3dd2cfad6a8", "points": [ { "method": "read_item", @@ -23395,7 +23393,8 @@ } ], "queries": [], - "sha256": "4b3c61716e5517b6dfc5f67cbb532a034281458e33c20375ddddb3dd2cfad6a8" + "batches": [], + "module_sha256": "8011b2e5de9a15654552e4c6bff2b43ee315ee6a1014e71df03fc0c1763eea03" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Review 0.261.380: Module-only four completeness defaults; this storage owner AST and response consumer are unchanged. Review renewed for 0.261.389: The connection-list normalizer projects only nested JSON endpoint records, preserving the SDK settings document, revision/ETag, OCC and cache-publication contracts. The selected API boolean and canonical URL are validated before the normal save path.", @@ -23406,8 +23405,7 @@ }, "application/single_app/functions_settings.py::clear_user_search_history": { "boundary": { - "batches": [], - "module_sha256": "62ba13df47d0fd207cfbb2729994125fb18c1f91dc6518ace19dc7f3b8ee1359", + "sha256": "2ec265bcf42c91c40cce1b307cdd449f453755c1c7c5b9219fc4e1212f1cc867", "points": [ { "method": "read_item", @@ -23421,7 +23419,8 @@ } ], "queries": [], - "sha256": "2ec265bcf42c91c40cce1b307cdd449f453755c1c7c5b9219fc4e1212f1cc867" + "batches": [], + "module_sha256": "8011b2e5de9a15654552e4c6bff2b43ee315ee6a1014e71df03fc0c1763eea03" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Review 0.261.380: Module-only four completeness defaults; this storage owner AST and response consumer are unchanged. Review renewed for 0.261.389: The connection-list normalizer projects only nested JSON endpoint records, preserving the SDK settings document, revision/ETag, OCC and cache-publication contracts. The selected API boolean and canonical URL are validated before the normal save path.", @@ -23432,8 +23431,7 @@ }, "application/single_app/functions_settings.py::get_user_search_history": { "boundary": { - "batches": [], - "module_sha256": "62ba13df47d0fd207cfbb2729994125fb18c1f91dc6518ace19dc7f3b8ee1359", + "sha256": "6037312077f10d0f3a4fee3eab19d7f4be707853317ee1d4a7765d4e0e956471", "points": [ { "method": "read_item", @@ -23442,7 +23440,8 @@ } ], "queries": [], - "sha256": "6037312077f10d0f3a4fee3eab19d7f4be707853317ee1d4a7765d4e0e956471" + "batches": [], + "module_sha256": "8011b2e5de9a15654552e4c6bff2b43ee315ee6a1014e71df03fc0c1763eea03" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Review 0.261.380: Module-only four completeness defaults; this storage owner AST and response consumer are unchanged. Review renewed for 0.261.389: The connection-list normalizer projects only nested JSON endpoint records, preserving the SDK settings document, revision/ETag, OCC and cache-publication contracts. The selected API boolean and canonical URL are validated before the normal save path.", @@ -23453,8 +23452,7 @@ }, "application/single_app/functions_settings.py::get_user_settings": { "boundary": { - "batches": [], - "module_sha256": "62ba13df47d0fd207cfbb2729994125fb18c1f91dc6518ace19dc7f3b8ee1359", + "sha256": "e63e62388d227292584451585cef9d22de7f5e5bb633569d9b85fcdf0aa75f1a", "points": [ { "method": "read_item", @@ -23473,7 +23471,8 @@ } ], "queries": [], - "sha256": "e63e62388d227292584451585cef9d22de7f5e5bb633569d9b85fcdf0aa75f1a" + "batches": [], + "module_sha256": "8011b2e5de9a15654552e4c6bff2b43ee315ee6a1014e71df03fc0c1763eea03" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Review 0.261.380: Module-only four completeness defaults; this storage owner AST and response consumer are unchanged. Review renewed for 0.261.389: The connection-list normalizer projects only nested JSON endpoint records, preserving the SDK settings document, revision/ETag, OCC and cache-publication contracts. The selected API boolean and canonical URL are validated before the normal save path.", @@ -23484,8 +23483,7 @@ }, "application/single_app/functions_settings.py::read_user_settings_snapshot": { "boundary": { - "batches": [], - "module_sha256": "62ba13df47d0fd207cfbb2729994125fb18c1f91dc6518ace19dc7f3b8ee1359", + "sha256": "c45411751c857573b8d0ec86a6a340a8e060204799d9d92915cd9e2866e3eda8", "points": [ { "method": "read_item", @@ -23494,7 +23492,8 @@ } ], "queries": [], - "sha256": "c45411751c857573b8d0ec86a6a340a8e060204799d9d92915cd9e2866e3eda8" + "batches": [], + "module_sha256": "8011b2e5de9a15654552e4c6bff2b43ee315ee6a1014e71df03fc0c1763eea03" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Review 0.261.380: Module-only four completeness defaults; this storage owner AST and response consumer are unchanged. Review renewed for 0.261.389: The connection-list normalizer projects only nested JSON endpoint records, preserving the SDK settings document, revision/ETag, OCC and cache-publication contracts. The selected API boolean and canonical URL are validated before the normal save path.", @@ -23505,8 +23504,7 @@ }, "application/single_app/functions_settings.py::update_user_settings": { "boundary": { - "batches": [], - "module_sha256": "62ba13df47d0fd207cfbb2729994125fb18c1f91dc6518ace19dc7f3b8ee1359", + "sha256": "5ae0242813730da6df2ed1328d4ea632f081d8a082a7ebe828b57cf62a284123", "points": [ { "method": "read_item", @@ -23530,7 +23528,8 @@ } ], "queries": [], - "sha256": "5ae0242813730da6df2ed1328d4ea632f081d8a082a7ebe828b57cf62a284123" + "batches": [], + "module_sha256": "8011b2e5de9a15654552e4c6bff2b43ee315ee6a1014e71df03fc0c1763eea03" }, "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. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Review 0.261.380: Module-only four completeness defaults; this storage owner AST and response consumer are unchanged. Review renewed for 0.261.389: The connection-list normalizer projects only nested JSON endpoint records, preserving the SDK settings document, revision/ETag, OCC and cache-publication contracts. The selected API boolean and canonical URL are validated before the normal save path.", @@ -23541,8 +23540,7 @@ }, "application/single_app/functions_shared_cache.py::bump_shared_cache_version": { "boundary": { - "batches": [], - "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0", + "sha256": "803868a1b5ea3baec17e3208b594b04fd7aef1d90e49597192211bbb127013b7", "points": [ { "method": "read_item", @@ -23556,7 +23554,8 @@ } ], "queries": [], - "sha256": "803868a1b5ea3baec17e3208b594b04fd7aef1d90e49597192211bbb127013b7" + "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.", @@ -23567,8 +23566,7 @@ }, "application/single_app/functions_shared_cache.py::delete_shared_cache_entry": { "boundary": { - "batches": [], - "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0", + "sha256": "37529eeee47374229895daff545719757ccfcfe7d25bbeb00fcee10da5ea0ad4", "points": [ { "method": "delete_item", @@ -23577,7 +23575,8 @@ } ], "queries": [], - "sha256": "37529eeee47374229895daff545719757ccfcfe7d25bbeb00fcee10da5ea0ad4" + "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.", @@ -23586,8 +23585,7 @@ }, "application/single_app/functions_shared_cache.py::ensure_shared_cache_version_doc": { "boundary": { - "batches": [], - "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0", + "sha256": "4d714875e63aadd9e70e1e2c9a1940322decb19a409f8a98500b5fa4a23ab533", "points": [ { "method": "read_item", @@ -23606,7 +23604,8 @@ } ], "queries": [], - "sha256": "4d714875e63aadd9e70e1e2c9a1940322decb19a409f8a98500b5fa4a23ab533" + "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.", @@ -23617,8 +23616,7 @@ }, "application/single_app/functions_shared_cache.py::get_shared_cache_entry": { "boundary": { - "batches": [], - "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0", + "sha256": "c69d5b5e16e8d88540f80d76acbf06b05f028d570fca59d1a1930f2a44374f93", "points": [ { "method": "read_item", @@ -23627,7 +23625,8 @@ } ], "queries": [], - "sha256": "c69d5b5e16e8d88540f80d76acbf06b05f028d570fca59d1a1930f2a44374f93" + "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.", @@ -23638,8 +23637,7 @@ }, "application/single_app/functions_shared_cache.py::get_shared_cache_version": { "boundary": { - "batches": [], - "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0", + "sha256": "014b42bfb0d1c442035e0def7076faff80e0595fd6d8e58029a83abf902b20c1", "points": [ { "method": "read_item", @@ -23648,7 +23646,8 @@ } ], "queries": [], - "sha256": "014b42bfb0d1c442035e0def7076faff80e0595fd6d8e58029a83abf902b20c1" + "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.", @@ -23659,8 +23658,7 @@ }, "application/single_app/functions_shared_cache.py::set_shared_cache_entry": { "boundary": { - "batches": [], - "module_sha256": "1ffe2b4f2b2ba4cfe8c831f5576c09328bea473a3850c3ba00d30d9046ed36b0", + "sha256": "e893e542a4a578f66fd78a17ca0ce90b2e3731945fd104f5844cd1726b55e722", "points": [ { "method": "upsert_item", @@ -23669,7 +23667,8 @@ } ], "queries": [], - "sha256": "e893e542a4a578f66fd78a17ca0ce90b2e3731945fd104f5844cd1726b55e722" + "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.", @@ -23678,8 +23677,7 @@ }, "application/single_app/functions_simplechat_operations.py::_cleanup_failed_fork": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "bfecba7b3f17e38bbbe1a63f7c9787d6a01caf968cbf28b39b6fce8ca91ad8e0", "points": [ { "method": "delete_item", @@ -23693,7 +23691,8 @@ } ], "queries": [], - "sha256": "bfecba7b3f17e38bbbe1a63f7c9787d6a01caf968cbf28b39b6fce8ca91ad8e0" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23704,8 +23703,7 @@ }, "application/single_app/functions_simplechat_operations.py::_get_latest_personal_thread_id": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "a67efd9fc9a5f5f315bb3d611d8c4586bf80f38c6f1e095242fe26e3761fd05f", "points": [], "queries": [ { @@ -23714,7 +23712,8 @@ "response": "consumed" } ], - "sha256": "a67efd9fc9a5f5f315bb3d611d8c4586bf80f38c6f1e095242fe26e3761fd05f" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23725,8 +23724,7 @@ }, "application/single_app/functions_simplechat_operations.py::_log_group_member_addition": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "94f1a69594b714c9890021aed786cb192074f1966237c4df082d8191e4a46f1e", "points": [ { "method": "create_item", @@ -23735,7 +23733,8 @@ } ], "queries": [], - "sha256": "94f1a69594b714c9890021aed786cb192074f1966237c4df082d8191e4a46f1e" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23746,8 +23745,7 @@ }, "application/single_app/functions_simplechat_operations.py::_persist_personal_conversation_message": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "5290e5a1e696c001282790000ea11a896524b84c53d46c7ab76076bb7c2e8a56", "points": [ { "method": "upsert_item", @@ -23761,7 +23759,8 @@ } ], "queries": [], - "sha256": "5290e5a1e696c001282790000ea11a896524b84c53d46c7ab76076bb7c2e8a56" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23772,8 +23771,7 @@ }, "application/single_app/functions_simplechat_operations.py::_upload_generated_chat_artifact_for_current_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "5d469f1035aabda3a82128c3c8fc3782d143797d9dd3b44635aa5723a5a37fa9", "points": [ { "method": "read_item", @@ -23802,7 +23800,8 @@ } ], "queries": [], - "sha256": "5d469f1035aabda3a82128c3c8fc3782d143797d9dd3b44635aa5723a5a37fa9" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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. Missing-container recovery retries only the replayable Blob stream after reauthorization; Cosmos point projections and immutable message identity remain SDK-compatible.", @@ -23814,8 +23813,7 @@ }, "application/single_app/functions_simplechat_operations.py::_upload_generated_chat_artifact_for_current_user.reauthorize_write": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "4a10b59df2b5b52844e8d67817619d64d04ad814240e7d50fbf620ac74a089f8", "points": [ { "method": "read_item", @@ -23824,7 +23822,8 @@ } ], "queries": [], - "sha256": "4a10b59df2b5b52844e8d67817619d64d04ad814240e7d50fbf620ac74a089f8" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23835,8 +23834,7 @@ }, "application/single_app/functions_simplechat_operations.py::add_conversation_message_for_current_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "693cc6280702a2a25f1bbf49014844ba9184edd086efd6656558a017612e0849", "points": [ { "method": "read_item", @@ -23845,7 +23843,8 @@ } ], "queries": [], - "sha256": "693cc6280702a2a25f1bbf49014844ba9184edd086efd6656558a017612e0849" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23856,8 +23855,7 @@ }, "application/single_app/functions_simplechat_operations.py::assert_generated_chat_artifact_is_published_for_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "6f5107b7ed0f82fa97e0398fcdf920749f28c39d5120d15ac3a1fa68263da2de", "points": [ { "method": "read_item", @@ -23866,7 +23864,8 @@ } ], "queries": [], - "sha256": "6f5107b7ed0f82fa97e0398fcdf920749f28c39d5120d15ac3a1fa68263da2de" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23877,8 +23876,7 @@ }, "application/single_app/functions_simplechat_operations.py::attach_generated_file_approval_state": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "097f0b2426f9f7b8947ef01da77c60a7d36946c709bbcda3b028306745ea4666", "points": [], "queries": [ { @@ -23887,7 +23885,8 @@ "response": "consumed" } ], - "sha256": "097f0b2426f9f7b8947ef01da77c60a7d36946c709bbcda3b028306745ea4666" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23898,8 +23897,7 @@ }, "application/single_app/functions_simplechat_operations.py::auto_deny_expired_generated_file_approvals": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "42a08d53f01608922dc4098d9f8ad95e73704ce4a5c2e9b6361b3300e75278ff", "points": [ { "method": "upsert_item", @@ -23908,7 +23906,8 @@ } ], "queries": [], - "sha256": "42a08d53f01608922dc4098d9f8ad95e73704ce4a5c2e9b6361b3300e75278ff" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23919,8 +23918,7 @@ }, "application/single_app/functions_simplechat_operations.py::commit_generated_chat_artifact_publication_for_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "58eb69bf4d85b1ca10a68c739861e319c3293d5f08135578798ee6c2bc17c5a8", "points": [ { "method": "read_item", @@ -23939,7 +23937,8 @@ } ], "queries": [], - "sha256": "58eb69bf4d85b1ca10a68c739861e319c3293d5f08135578798ee6c2bc17c5a8" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -23950,8 +23949,7 @@ }, "application/single_app/functions_simplechat_operations.py::create_personal_conversation_for_current_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "d955470c2470b2b14d404ecdb6c03b43daccf4bd943d8a588987fe74d404e719", "points": [ { "method": "create_item", @@ -23975,7 +23973,8 @@ } ], "queries": [], - "sha256": "d955470c2470b2b14d404ecdb6c03b43daccf4bd943d8a588987fe74d404e719" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "classification": "sdk-compatible", "contract": "SDK conflict reads validate deterministic result ownership, group scope and provenance; normal creation ignores write responses and retains manual titles.", @@ -23986,8 +23985,7 @@ }, "application/single_app/functions_simplechat_operations.py::delete_blob_backed_chat_message_files": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "68675d5404a8406b9907975fcbd20efb1e55680cb6b6ba20276170e76b357e8b", "points": [ { "method": "read_item", @@ -23996,7 +23994,8 @@ } ], "queries": [], - "sha256": "68675d5404a8406b9907975fcbd20efb1e55680cb6b6ba20276170e76b357e8b" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -24007,8 +24006,7 @@ }, "application/single_app/functions_simplechat_operations.py::delete_generated_chat_artifact_for_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "7caeb1655962bad3e4dd1349722c5d14bd83aa620b897006a8f6fd2f4a0ff100", "points": [ { "method": "read_item", @@ -24027,7 +24025,8 @@ } ], "queries": [], - "sha256": "7caeb1655962bad3e4dd1349722c5d14bd83aa620b897006a8f6fd2f4a0ff100" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -24038,8 +24037,7 @@ }, "application/single_app/functions_simplechat_operations.py::delete_staged_orchestration_chat_artifact_for_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "1f85fdd29870262b79bf0d2ba82028bce78d4c8627297810c5201558d57ad827", "points": [ { "method": "read_item", @@ -24058,7 +24056,8 @@ } ], "queries": [], - "sha256": "1f85fdd29870262b79bf0d2ba82028bce78d4c8627297810c5201558d57ad827" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -24069,8 +24068,7 @@ }, "application/single_app/functions_simplechat_operations.py::fork_personal_conversation_for_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "9ea61c64c44d4d0fd561face73a793bb6acf5c19368c7366f513bc766d6afa24", "points": [ { "method": "read_item", @@ -24105,7 +24103,8 @@ "response": "consumed" } ], - "sha256": "9ea61c64c44d4d0fd561face73a793bb6acf5c19368c7366f513bc766d6afa24" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -24116,8 +24115,7 @@ }, "application/single_app/functions_simplechat_operations.py::list_pending_generated_file_approvals_for_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "567a1350247b61ef5a33b7ff484590aa6a9d0c75e7d99841a0d0d8fe37ee043e", "points": [], "queries": [ { @@ -24126,7 +24124,8 @@ "response": "consumed" } ], - "sha256": "567a1350247b61ef5a33b7ff484590aa6a9d0c75e7d99841a0d0d8fe37ee043e" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -24137,8 +24136,7 @@ }, "application/single_app/functions_simplechat_operations.py::resolve_generated_file_approval_for_user": { "boundary": { - "batches": [], - "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3", + "sha256": "4907d47d45012968698cf7e0bc4e48650b2366f3f7d5ad2463d366eb6044bb18", "points": [ { "method": "read_item", @@ -24152,7 +24150,8 @@ } ], "queries": [], - "sha256": "4907d47d45012968698cf7e0bc4e48650b2366f3f7d5ad2463d366eb6044bb18" + "batches": [], + "module_sha256": "c96ef709bd07e56f1d903164a3f856dfc49c6570fbb9009a8d311c6a56d04ef3" }, "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.", @@ -24163,8 +24162,7 @@ }, "application/single_app/functions_tabular_generated_exports.py::_authorize_tabular_export_run_conversation": { "boundary": { - "batches": [], - "module_sha256": "0946bdc93ce63940e2e61ef2f3483c0e230e589a2ecafa0e3de6291401fc5893", + "sha256": "2db7ce9752384889b7e3c88a920b73086d376abad2b561cc916be2fcb67be600", "points": [ { "method": "read_item", @@ -24173,10 +24171,11 @@ } ], "queries": [], - "sha256": "2db7ce9752384889b7e3c88a920b73086d376abad2b561cc916be2fcb67be600" + "batches": [], + "module_sha256": "6c105b2f4f84d1fb3fdb0fce5f3a9d2d39b37c98dee01215ade1deaa1fb8b911" }, "classification": "sdk-compatible", - "contract": "The partitioned conversation CosmosDict is checked through its user_id and returned unchanged; missing conversations and ownership changes remain PermissionError refusals. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical.", + "contract": "The partitioned conversation CosmosDict is checked through its user_id and returned unchanged; missing conversations and ownership changes remain PermissionError refusals. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_public_source_owner_sdk.py::test_tabular_export_owner_keeps_sdk_etags_and_public_scope_fences" @@ -24184,8 +24183,7 @@ }, "application/single_app/functions_tabular_generated_exports.py::_authorize_tabular_export_run_execution": { "boundary": { - "batches": [], - "module_sha256": "0946bdc93ce63940e2e61ef2f3483c0e230e589a2ecafa0e3de6291401fc5893", + "sha256": "7d4f6e9fff2a09cfdadff4a52acea40827b6c3b75fdbab423bc5ccf804ce7f72", "points": [ { "method": "read_item", @@ -24194,10 +24192,11 @@ } ], "queries": [], - "sha256": "7d4f6e9fff2a09cfdadff4a52acea40827b6c3b75fdbab423bc5ccf804ce7f72" + "batches": [], + "module_sha256": "6c105b2f4f84d1fb3fdb0fce5f3a9d2d39b37c98dee01215ade1deaa1fb8b911" }, "classification": "sdk-compatible", - "contract": "The conversation and optional producer point mappings feed field-based owner/native-compute checks. Public source ids and blob provenance are revalidated separately, and the authorized conversation mapping is returned. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical.", + "contract": "The conversation and optional producer point mappings feed field-based owner/native-compute checks. Public source ids and blob provenance are revalidated separately, and the authorized conversation mapping is returned. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_public_source_owner_sdk.py::test_tabular_export_owner_keeps_sdk_etags_and_public_scope_fences" @@ -24205,8 +24204,7 @@ }, "application/single_app/functions_tabular_generated_exports.py::_query_scheduler_candidates_by_status": { "boundary": { - "batches": [], - "module_sha256": "0946bdc93ce63940e2e61ef2f3483c0e230e589a2ecafa0e3de6291401fc5893", + "sha256": "95dd3db2bdbcca82dcbad9eb846bcc46410a5043892925275d0b97976ef1241e", "points": [], "queries": [ { @@ -24215,10 +24213,11 @@ "response": "consumed" } ], - "sha256": "95dd3db2bdbcca82dcbad9eb846bcc46410a5043892925275d0b97976ef1241e" + "batches": [], + "module_sha256": "6c105b2f4f84d1fb3fdb0fce5f3a9d2d39b37c98dee01215ade1deaa1fb8b911" }, "classification": "sdk-compatible", - "contract": "Scheduler discovery iterates plain projected query rows, applies eligibility before the bounded result limit and returns those rows; query failures are logged and re-raised. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical.", + "contract": "Scheduler discovery iterates plain projected query rows, applies eligibility before the bounded result limit and returns those rows; query failures are logged and re-raised. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_public_source_owner_sdk.py::test_tabular_export_owner_keeps_sdk_etags_and_public_scope_fences" @@ -24226,8 +24225,7 @@ }, "application/single_app/functions_tabular_generated_exports.py::_read_run": { "boundary": { - "batches": [], - "module_sha256": "0946bdc93ce63940e2e61ef2f3483c0e230e589a2ecafa0e3de6291401fc5893", + "sha256": "64e6ce341659ab2caf67081615f6fdcb6f5cf08a6a00adbb2c79bae62ebbbf00", "points": [ { "method": "read_item", @@ -24236,10 +24234,11 @@ } ], "queries": [], - "sha256": "64e6ce341659ab2caf67081615f6fdcb6f5cf08a6a00adbb2c79bae62ebbbf00" + "batches": [], + "module_sha256": "6c105b2f4f84d1fb3fdb0fce5f3a9d2d39b37c98dee01215ade1deaa1fb8b911" }, "classification": "sdk-compatible", - "contract": "The exact user/run partitioned read returns the SDK mapping unchanged to field-based run consumers, preserving nested source descriptors and ETags. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical.", + "contract": "The exact user/run partitioned read returns the SDK mapping unchanged to field-based run consumers, preserving nested source descriptors and ETags. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_public_source_owner_sdk.py::test_tabular_export_owner_keeps_sdk_etags_and_public_scope_fences" @@ -24247,8 +24246,7 @@ }, "application/single_app/functions_tabular_generated_exports.py::_replace_run": { "boundary": { - "batches": [], - "module_sha256": "0946bdc93ce63940e2e61ef2f3483c0e230e589a2ecafa0e3de6291401fc5893", + "sha256": "c5bbea5e76c5ff60dfbb2bc32fc91949ec38988b5630578ea0cc1dafbc9c973a", "points": [ { "method": "replace_item", @@ -24257,10 +24255,11 @@ } ], "queries": [], - "sha256": "c5bbea5e76c5ff60dfbb2bc32fc91949ec38988b5630578ea0cc1dafbc9c973a" + "batches": [], + "module_sha256": "6c105b2f4f84d1fb3fdb0fce5f3a9d2d39b37c98dee01215ade1deaa1fb8b911" }, "classification": "sdk-compatible", - "contract": "The existing run mapping and its ETag are passed to IfNotModified replacement; the returned CosmosDict and fresh ETag remain available to the caller, and stale ETags still fail. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical.", + "contract": "The existing run mapping and its ETag are passed to IfNotModified replacement; the returned CosmosDict and fresh ETag remain available to the caller, and stale ETags still fail. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_public_source_owner_sdk.py::test_tabular_export_owner_keeps_sdk_etags_and_public_scope_fences" @@ -24268,8 +24267,7 @@ }, "application/single_app/functions_tabular_generated_exports.py::get_tabular_generated_output_run_status": { "boundary": { - "batches": [], - "module_sha256": "0946bdc93ce63940e2e61ef2f3483c0e230e589a2ecafa0e3de6291401fc5893", + "sha256": "37033d74b534cb3d85ef135810b7eb61d429c05cf514899562a5e1ea9dc5a548", "points": [ { "method": "read_item", @@ -24278,10 +24276,11 @@ } ], "queries": [], - "sha256": "37033d74b534cb3d85ef135810b7eb61d429c05cf514899562a5e1ea9dc5a548" + "batches": [], + "module_sha256": "6c105b2f4f84d1fb3fdb0fce5f3a9d2d39b37c98dee01215ade1deaa1fb8b911" }, "classification": "sdk-compatible", - "contract": "The user-partitioned SDK run mapping feeds field-based screening and bounded completion repair; the status builder accepts dict subclasses and constructs an explicit plain public projection. Representative runtime evidence exercises this module's read/replace/authorization/query boundaries, not every status branch. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical.", + "contract": "The user-partitioned SDK run mapping feeds field-based screening and bounded completion repair; the status builder accepts dict subclasses and constructs an explicit plain public projection. Representative runtime evidence exercises this module's read/replace/authorization/query boundaries, not every status branch. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_public_source_owner_sdk.py::test_tabular_export_owner_keeps_sdk_etags_and_public_scope_fences" @@ -24289,8 +24288,7 @@ }, "application/single_app/functions_tabular_generated_exports.py::queue_tabular_generated_output_run": { "boundary": { - "batches": [], - "module_sha256": "0946bdc93ce63940e2e61ef2f3483c0e230e589a2ecafa0e3de6291401fc5893", + "sha256": "eb5b3df6fef7c091dcea83e7295773d6f7d483cf18bff0fbba16fcaf42b10dd8", "points": [ { "method": "create_item", @@ -24304,17 +24302,17 @@ } ], "queries": [], - "sha256": "eb5b3df6fef7c091dcea83e7295773d6f7d483cf18bff0fbba16fcaf42b10dd8" + "batches": [], + "module_sha256": "6c105b2f4f84d1fb3fdb0fce5f3a9d2d39b37c98dee01215ade1deaa1fb8b911" }, "classification": "response-unused", - "contract": "Both queue create responses are discarded; the constructed plain run is returned for new work. The data-only replay/collision branches use _read_run mappings, compare exact compute/source fields and reauthorize before returning the existing SDK run. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical.", + "contract": "Both queue create responses are discarded; the constructed plain run is returned for new work. The data-only replay/collision branches use _read_run mappings, compare exact compute/source fields and reauthorize before returning the existing SDK run. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Only model protocol selection in the budget helper changed. Point/query/batch consumers, source authorization, ETags, publication ownership and conditional storage updates remain identical. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "source-review", "tests": [] }, "application/single_app/functions_thoughts.py::ThoughtTracker.add_thought": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "f2f09a0fa64a3ad68b44d18171b6ccb50588c88ab2211139430bf03382434f7c", "points": [ { "method": "upsert_item", @@ -24323,7 +24321,8 @@ } ], "queries": [], - "sha256": "f2f09a0fa64a3ad68b44d18171b6ccb50588c88ab2211139430bf03382434f7c" + "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.", @@ -24332,8 +24331,7 @@ }, "application/single_app/functions_thoughts.py::ThoughtTracker.complete_thought": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "94fe05a760579b371a7de682c470bd413d6f2b55cc7b7397f85c7d95b00c3eb3", "points": [ { "method": "read_item", @@ -24347,7 +24345,8 @@ } ], "queries": [], - "sha256": "94fe05a760579b371a7de682c470bd413d6f2b55cc7b7397f85c7d95b00c3eb3" + "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.", @@ -24358,8 +24357,7 @@ }, "application/single_app/functions_thoughts.py::_visible_chat_thoughts": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "1fc21c1a497b944936d3667dc4f6fe81b7e38ed1aabc8c21cf0ac67cd0c015fc", "points": [ { "method": "read_item", @@ -24368,7 +24366,8 @@ } ], "queries": [], - "sha256": "1fc21c1a497b944936d3667dc4f6fe81b7e38ed1aabc8c21cf0ac67cd0c015fc" + "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.", @@ -24379,8 +24378,7 @@ }, "application/single_app/functions_thoughts.py::archive_thoughts_for_conversation": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "91915c00823924719e3a1162e3816e3fd6493c8d21da0de206bbd1734b9bae7e", "points": [ { "method": "upsert_item", @@ -24394,7 +24392,8 @@ } ], "queries": [], - "sha256": "91915c00823924719e3a1162e3816e3fd6493c8d21da0de206bbd1734b9bae7e" + "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.", @@ -24403,8 +24402,7 @@ }, "application/single_app/functions_thoughts.py::delete_scoped_thoughts_for_message": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "72b1e8a6ce5b4a287a7d7e70b80eb283736e3b44b8a467db6036fd62eab26c0b", "points": [ { "method": "delete_item", @@ -24419,7 +24417,8 @@ "response": "consumed" } ], - "sha256": "72b1e8a6ce5b4a287a7d7e70b80eb283736e3b44b8a467db6036fd62eab26c0b" + "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.", @@ -24428,8 +24427,7 @@ }, "application/single_app/functions_thoughts.py::delete_thoughts_for_conversation": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "d2d004c344acfb0043a929fb2760868ddc066494bbbc351f05d444eba7a4dea7", "points": [ { "method": "delete_item", @@ -24438,7 +24436,8 @@ } ], "queries": [], - "sha256": "d2d004c344acfb0043a929fb2760868ddc066494bbbc351f05d444eba7a4dea7" + "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.", @@ -24447,8 +24446,7 @@ }, "application/single_app/functions_thoughts.py::delete_thoughts_for_message": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "3ca279147884bfcc851445b3e8372db1c9d49b7540cb12dba44959c399e48628", "points": [ { "method": "delete_item", @@ -24463,7 +24461,8 @@ "response": "consumed" } ], - "sha256": "3ca279147884bfcc851445b3e8372db1c9d49b7540cb12dba44959c399e48628" + "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.", @@ -24472,8 +24471,7 @@ }, "application/single_app/functions_thoughts.py::get_pending_thoughts": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "7680ee4ea6ed71d4e8d3baa58410132dc5b1a5268e7f0d845662d349fc3ced56", "points": [], "queries": [ { @@ -24482,7 +24480,8 @@ "response": "consumed" } ], - "sha256": "7680ee4ea6ed71d4e8d3baa58410132dc5b1a5268e7f0d845662d349fc3ced56" + "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.", @@ -24493,8 +24492,7 @@ }, "application/single_app/functions_thoughts.py::get_thoughts_for_conversation": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "89242cc68d8108032b11dccd291a2bc860ac296a21a17fc4cefbdc7fa4ea920d", "points": [], "queries": [ { @@ -24503,7 +24501,8 @@ "response": "consumed" } ], - "sha256": "89242cc68d8108032b11dccd291a2bc860ac296a21a17fc4cefbdc7fa4ea920d" + "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.", @@ -24514,8 +24513,7 @@ }, "application/single_app/functions_thoughts.py::get_thoughts_for_message": { "boundary": { - "batches": [], - "module_sha256": "6c27b69af4ae04530ef4f81b33fb7cbd686704067aa20a9f7fe612aa0092cd4b", + "sha256": "b779b47553c15b1f6b96a8c11669d6e16eb505de16434bdf6cda17b050eeb8db", "points": [], "queries": [ { @@ -24524,7 +24522,8 @@ "response": "consumed" } ], - "sha256": "b779b47553c15b1f6b96a8c11669d6e16eb505de16434bdf6cda17b050eeb8db" + "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.", @@ -24535,8 +24534,7 @@ }, "application/single_app/functions_workflow_assist_limits.py::CosmosAssistLimitStore.create": { "boundary": { - "batches": [], - "module_sha256": "0fd04eb6bc92eac13793adde066dffade5cbebab3ab28d28bfa20dfe193944a8", + "sha256": "32fcb10e98824abe508b3906381710ebf0c486dbc5477315c308b53b6454d039", "points": [ { "method": "create_item", @@ -24545,7 +24543,8 @@ } ], "queries": [], - "sha256": "32fcb10e98824abe508b3906381710ebf0c486dbc5477315c308b53b6454d039" + "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.", @@ -24554,8 +24553,7 @@ }, "application/single_app/functions_workflow_assist_limits.py::CosmosAssistLimitStore.read": { "boundary": { - "batches": [], - "module_sha256": "0fd04eb6bc92eac13793adde066dffade5cbebab3ab28d28bfa20dfe193944a8", + "sha256": "a18f5fb1e5f4a5145bf71fbbfe4670f4ac0cafa692dfd9ed7e9fbc1fb3d131f7", "points": [ { "method": "read_item", @@ -24564,7 +24562,8 @@ } ], "queries": [], - "sha256": "a18f5fb1e5f4a5145bf71fbbfe4670f4ac0cafa692dfd9ed7e9fbc1fb3d131f7" + "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.", @@ -24575,8 +24574,7 @@ }, "application/single_app/functions_workflow_assist_limits.py::CosmosAssistLimitStore.replace": { "boundary": { - "batches": [], - "module_sha256": "0fd04eb6bc92eac13793adde066dffade5cbebab3ab28d28bfa20dfe193944a8", + "sha256": "d9b7a4e99e0410d49b0a5217174d90f3a889aaaa01828a52475c840665f3fa3d", "points": [ { "method": "replace_item", @@ -24585,7 +24583,8 @@ } ], "queries": [], - "sha256": "d9b7a4e99e0410d49b0a5217174d90f3a889aaaa01828a52475c840665f3fa3d" + "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.", @@ -24594,8 +24593,7 @@ }, "application/single_app/functions_workflow_assist_runtime.py::read_workflow_base": { "boundary": { - "batches": [], - "module_sha256": "69de95458aa9619d5b432496dfc9c5672d57ff44c72924497927b9b2d74f9d0d", + "sha256": "8206e1b7d08e7b7cc5c73baaef25ceefc44a604ad9ddc3683c7575d944cae425", "points": [ { "method": "read_item", @@ -24604,7 +24602,8 @@ } ], "queries": [], - "sha256": "8206e1b7d08e7b7cc5c73baaef25ceefc44a604ad9ddc3683c7575d944cae425" + "batches": [], + "module_sha256": "69de95458aa9619d5b432496dfc9c5672d57ff44c72924497927b9b2d74f9d0d" }, "classification": "sdk-compatible", "contract": "read_workflow_base reads a real SDK CosmosDict in the authorized personal or route-bound group partition, projects a plain editor dictionary without Cosmos metadata, sanitizes alert diagnostics, and recomputes the authored revision without writes. Group creator identity is retained; foreign groups, missing items and invalid ids are unavailable. Group services revalidate current management before each adapter and dry-run with the authorized actor.", @@ -24616,8 +24615,7 @@ }, "application/single_app/functions_workflow_chat_delivery_status.py::_RequestReads._read_workflow": { "boundary": { - "batches": [], - "module_sha256": "4d3920a486b7ba6ab66675757c160220c96750ae2b6441d244d05b465abb0679", + "sha256": "4918c28aa34588dccf309addf9de423c8abeac5d4ed5da45ab7342e99a2159f8", "points": [ { "method": "read_item", @@ -24626,7 +24624,8 @@ } ], "queries": [], - "sha256": "4918c28aa34588dccf309addf9de423c8abeac5d4ed5da45ab7342e99a2159f8" + "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.", @@ -24637,8 +24636,7 @@ }, "application/single_app/functions_workflow_chat_delivery_status.py::workflow_run_status_payload": { "boundary": { - "batches": [], - "module_sha256": "4d3920a486b7ba6ab66675757c160220c96750ae2b6441d244d05b465abb0679", + "sha256": "2a14578dee997a853ff322b8bbe15fd09a6cd9bc528d2787e2e447b0ab68a565", "points": [], "queries": [ { @@ -24647,7 +24645,8 @@ "response": "consumed" } ], - "sha256": "2a14578dee997a853ff322b8bbe15fd09a6cd9bc528d2787e2e447b0ab68a565" + "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.", @@ -24658,8 +24657,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_conversation_title": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "7f2330c18f46d92a7d677e0a03af430f46e0216ca39fcc6710d45f03b969d22e", "points": [ { "method": "read_item", @@ -24668,7 +24666,8 @@ } ], "queries": [], - "sha256": "7f2330c18f46d92a7d677e0a03af430f46e0216ca39fcc6710d45f03b969d22e" + "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.", @@ -24679,8 +24678,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_create_message": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "40c36845dc8e90c10cfb21dc2d6d7778e457f47d3a18951e58e271bfcb53b146", "points": [ { "method": "create_item", @@ -24689,7 +24687,8 @@ } ], "queries": [], - "sha256": "40c36845dc8e90c10cfb21dc2d6d7778e457f47d3a18951e58e271bfcb53b146" + "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.", @@ -24698,8 +24697,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_message_exists": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "35e728b00cfd4b7e16fceb0323561242ec7dcf5b01d563b84ad082dbb361e438", "points": [ { "method": "read_item", @@ -24708,7 +24706,8 @@ } ], "queries": [], - "sha256": "35e728b00cfd4b7e16fceb0323561242ec7dcf5b01d563b84ad082dbb361e438" + "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.", @@ -24719,8 +24718,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_newest_message": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "736b126674b344581792cefad6c5e53388599df215208500d5664fae1ff8b237", "points": [], "queries": [ { @@ -24729,7 +24727,8 @@ "response": "consumed" } ], - "sha256": "736b126674b344581792cefad6c5e53388599df215208500d5664fae1ff8b237" + "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.", @@ -24740,8 +24739,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_question": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "9e185629660669cdbbeeab49179f84b373bfa9514620320892a105b8306f4629", "points": [ { "method": "read_item", @@ -24750,7 +24748,8 @@ } ], "queries": [], - "sha256": "9e185629660669cdbbeeab49179f84b373bfa9514620320892a105b8306f4629" + "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.", @@ -24761,8 +24760,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_read_conversation": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "43ec4802bb6f1612419aeb4913a332fb5d6bb6a98bec0b668563dd9511971a3f", "points": [ { "method": "read_item", @@ -24771,7 +24769,8 @@ } ], "queries": [], - "sha256": "43ec4802bb6f1612419aeb4913a332fb5d6bb6a98bec0b668563dd9511971a3f" + "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.", @@ -24782,8 +24781,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_read_run": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "277cd44165557a6c5955d0feb62259b5643cdba91665d2b57e2bc417860b88b2", "points": [ { "method": "read_item", @@ -24792,7 +24790,8 @@ } ], "queries": [], - "sha256": "277cd44165557a6c5955d0feb62259b5643cdba91665d2b57e2bc417860b88b2" + "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.", @@ -24803,8 +24802,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_read_workflow": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "ee70bfbf1b42c9e0d56cdb53a8822ed5932ba2ac86b14b89fe637c18828cd46d", "points": [ { "method": "read_item", @@ -24813,7 +24811,8 @@ } ], "queries": [], - "sha256": "ee70bfbf1b42c9e0d56cdb53a8822ed5932ba2ac86b14b89fe637c18828cd46d" + "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.", @@ -24824,8 +24823,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::_replace_run": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "be465d660014c8d7a07961be323f2fabfa8456ffcb526344a509f716a363160e", "points": [ { "method": "replace_item", @@ -24834,7 +24832,8 @@ } ], "queries": [], - "sha256": "be465d660014c8d7a07961be323f2fabfa8456ffcb526344a509f716a363160e" + "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.", @@ -24845,8 +24844,7 @@ }, "application/single_app/functions_workflow_chat_delivery_worker.py::run_workflow_chat_delivery_sweep": { "boundary": { - "batches": [], - "module_sha256": "ccedfc51279f551e840aaa89e7dc5de9422f9da76e0db981bb33ed349e61c769", + "sha256": "1009b5ce991b7601591920b3891b29ac5136fa08a97c760d877a0e2dc8a20994", "points": [], "queries": [ { @@ -24855,7 +24853,8 @@ "response": "consumed" } ], - "sha256": "1009b5ce991b7601591920b3891b29ac5136fa08a97c760d877a0e2dc8a20994" + "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.", @@ -24866,8 +24865,7 @@ }, "application/single_app/functions_workflow_chat_execution.py::_application_runtime.plan": { "boundary": { - "batches": [], - "module_sha256": "42616043993bf5e4d3a887ed69c911919ac97fd1401e052e7a15b6bae098379e", + "sha256": "496f37a30f7045b28baa50b940b09d32d9658d6624334053524469a72179cdd8", "points": [ { "method": "create_item", @@ -24881,7 +24879,8 @@ } ], "queries": [], - "sha256": "496f37a30f7045b28baa50b940b09d32d9658d6624334053524469a72179cdd8" + "batches": [], + "module_sha256": "42616043993bf5e4d3a887ed69c911919ac97fd1401e052e7a15b6bae098379e" }, "classification": "sdk-compatible", "contract": "The task request create response is unused. On an idempotent conflict, the SDK point message is compared by Mapping fields; planner input is the newly constructed plain message.", @@ -24892,8 +24891,7 @@ }, "application/single_app/functions_workflow_chat_execution.py::_application_runtime.read_message": { "boundary": { - "batches": [], - "module_sha256": "42616043993bf5e4d3a887ed69c911919ac97fd1401e052e7a15b6bae098379e", + "sha256": "005434d852a2ef1ea725a4fc224d03a6c9b5bad9c478b1fbc8d1b4cb95ee056d", "points": [ { "method": "read_item", @@ -24902,7 +24900,8 @@ } ], "queries": [], - "sha256": "005434d852a2ef1ea725a4fc224d03a6c9b5bad9c478b1fbc8d1b4cb95ee056d" + "batches": [], + "module_sha256": "42616043993bf5e4d3a887ed69c911919ac97fd1401e052e7a15b6bae098379e" }, "classification": "normalized-strict", "contract": "The saved assistant point response is normalized before workflow_chat_result validates the exact bound assistant document and projects outputs.", @@ -24913,8 +24912,7 @@ }, "application/single_app/functions_workflow_chat_execution.py::cancel_workflow_chat_executions": { "boundary": { - "batches": [], - "module_sha256": "42616043993bf5e4d3a887ed69c911919ac97fd1401e052e7a15b6bae098379e", + "sha256": "9b744534c457db175b6b82e4ff8213b9b3f1c8677b0bc0efd67dcf632eafef1c", "points": [], "queries": [ { @@ -24923,7 +24921,8 @@ "response": "consumed" } ], - "sha256": "9b744534c457db175b6b82e4ff8213b9b3f1c8677b0bc0efd67dcf632eafef1c" + "batches": [], + "module_sha256": "42616043993bf5e4d3a887ed69c911919ac97fd1401e052e7a15b6bae098379e" }, "classification": "sdk-compatible", "contract": "Plain query selectors are restricted by audit partition, user and workflow/run binding, then re-read through the normalized orchestration-run owner before cancellation/fencing.", @@ -24934,8 +24933,7 @@ }, "application/single_app/functions_workflow_definition_store.py::create_workflow_definition_record_if_absent": { "boundary": { - "batches": [], - "module_sha256": "b363895390b6a4f1f5a513b797356bd4da3924313d69c1475856815589d7b048", + "sha256": "739152491251985ee67686ca9cbaac07190d2a241e8fa352303febf514ecc784", "points": [ { "method": "create_item", @@ -24949,7 +24947,8 @@ } ], "queries": [], - "sha256": "739152491251985ee67686ca9cbaac07190d2a241e8fa352303febf514ecc784" + "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.", @@ -24960,8 +24959,7 @@ }, "application/single_app/functions_workflow_definition_store.py::refuse_save_of_deleted_workflow": { "boundary": { - "batches": [], - "module_sha256": "b363895390b6a4f1f5a513b797356bd4da3924313d69c1475856815589d7b048", + "sha256": "57767c3c4d23c4a0c0731aca3f5a4546954cef151f1f5c544b906d78a518c7cd", "points": [ { "method": "read_item", @@ -24970,7 +24968,8 @@ } ], "queries": [], - "sha256": "57767c3c4d23c4a0c0731aca3f5a4546954cef151f1f5c544b906d78a518c7cd" + "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.", @@ -24979,8 +24978,7 @@ }, "application/single_app/functions_workflow_definition_store.py::save_workflow_definition_record": { "boundary": { - "batches": [], - "module_sha256": "b363895390b6a4f1f5a513b797356bd4da3924313d69c1475856815589d7b048", + "sha256": "4bfab13ee42d1966d699fd75c99c66edc9232a09c18cb6d95dfa85ad2b1e6202", "points": [ { "method": "create_item", @@ -24999,7 +24997,8 @@ } ], "queries": [], - "sha256": "4bfab13ee42d1966d699fd75c99c66edc9232a09c18cb6d95dfa85ad2b1e6202" + "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.", @@ -25010,8 +25009,7 @@ }, "application/single_app/functions_workflow_definition_store.py::update_workflow_runtime_record": { "boundary": { - "batches": [], - "module_sha256": "b363895390b6a4f1f5a513b797356bd4da3924313d69c1475856815589d7b048", + "sha256": "69ecef53ba0e035589abcf90e505f685c7f0eb7593fe827da38cc0a876543a51", "points": [ { "method": "read_item", @@ -25025,7 +25023,8 @@ } ], "queries": [], - "sha256": "69ecef53ba0e035589abcf90e505f685c7f0eb7593fe827da38cc0a876543a51" + "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.", @@ -25036,6 +25035,9 @@ }, "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_commit": { "boundary": { + "sha256": "7802606a24180625608cb9fb299d8ccebd29841891a247f6ef7f12ed0f83831f", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -25043,10 +25045,7 @@ "response": "unused" } ], - "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6", - "points": [], - "queries": [], - "sha256": "7802606a24180625608cb9fb299d8ccebd29841891a247f6ef7f12ed0f83831f" + "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.", @@ -25055,6 +25054,9 @@ }, "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_commit_many": { "boundary": { + "sha256": "76be0e82056e88bf278012769b6dd38b8dc40670135c74d086aebf851986a55e", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -25062,10 +25064,7 @@ "response": "unused" } ], - "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6", - "points": [], - "queries": [], - "sha256": "76be0e82056e88bf278012769b6dd38b8dc40670135c74d086aebf851986a55e" + "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.", @@ -25074,6 +25073,9 @@ }, "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_decide": { "boundary": { + "sha256": "78c5787bd238a93595f12e364c355d04af9f19d16048237206ec7c77bf748a5f", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -25081,10 +25083,7 @@ "response": "unused" } ], - "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6", - "points": [], - "queries": [], - "sha256": "78c5787bd238a93595f12e364c355d04af9f19d16048237206ec7c77bf748a5f" + "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.", @@ -25093,8 +25092,7 @@ }, "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_page": { "boundary": { - "batches": [], - "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6", + "sha256": "690c8da2b5607a0b9391160d9ef61687ef6e4298996c31b379d6fe835caff5a7", "points": [], "queries": [ { @@ -25103,7 +25101,8 @@ "response": "consumed" } ], - "sha256": "690c8da2b5607a0b9391160d9ef61687ef6e4298996c31b379d6fe835caff5a7" + "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.", @@ -25114,8 +25113,7 @@ }, "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_read": { "boundary": { - "batches": [], - "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6", + "sha256": "0e7fb77a51acff91267a563ac4ec3a2633a945fc7dc34ec85b687e24eaba7c75", "points": [ { "method": "read_item", @@ -25124,7 +25122,8 @@ } ], "queries": [], - "sha256": "0e7fb77a51acff91267a563ac4ec3a2633a945fc7dc34ec85b687e24eaba7c75" + "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.", @@ -25135,6 +25134,9 @@ }, "application/single_app/functions_workflow_journal.py::WorkflowJournalMixin.journal_request": { "boundary": { + "sha256": "ebd1ff632967d8104191240ee511f3af5fb59d800013670c367bf9b2bcbbf5c6", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -25142,10 +25144,7 @@ "response": "unused" } ], - "module_sha256": "b2d6c7fa5d5d7f92123f141e84a14e25755996c38b138de8ae764b122e995ac6", - "points": [], - "queries": [], - "sha256": "ebd1ff632967d8104191240ee511f3af5fb59d800013670c367bf9b2bcbbf5c6" + "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.", @@ -25154,8 +25153,7 @@ }, "application/single_app/functions_workflow_plan_replay.py::_read_conversation": { "boundary": { - "batches": [], - "module_sha256": "b2d8cd612ddbf83ac1f627b5611dbee93badced5c9e71a0ac5484fbb7231ad24", + "sha256": "7b4e209d54227517fe831b536b97d745427b0c514074468db4ca5a819faef5d6", "points": [ { "method": "read_item", @@ -25164,7 +25162,8 @@ } ], "queries": [], - "sha256": "7b4e209d54227517fe831b536b97d745427b0c514074468db4ca5a819faef5d6" + "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.", @@ -25175,8 +25174,7 @@ }, "application/single_app/functions_workflow_plan_replay.py::_read_message": { "boundary": { - "batches": [], - "module_sha256": "b2d8cd612ddbf83ac1f627b5611dbee93badced5c9e71a0ac5484fbb7231ad24", + "sha256": "31fd9586f6e3dcf1b4ebf281c629f61a494891b1b0fbe0514af41b8e83babdd6", "points": [ { "method": "read_item", @@ -25185,7 +25183,8 @@ } ], "queries": [], - "sha256": "31fd9586f6e3dcf1b4ebf281c629f61a494891b1b0fbe0514af41b8e83babdd6" + "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.", @@ -25196,8 +25195,7 @@ }, "application/single_app/functions_workflow_result_followup.py::_discard_answer": { "boundary": { - "batches": [], - "module_sha256": "98859b10b350cebda30047969d35c29e29eb6a6cd40e92d4e1405163cf4c8999", + "sha256": "2234671490f2ecb9e51172a52ffd04612e10c300efd3122b070918f9ace1060c", "points": [ { "method": "delete_item", @@ -25206,7 +25204,8 @@ } ], "queries": [], - "sha256": "2234671490f2ecb9e51172a52ffd04612e10c300efd3122b070918f9ace1060c" + "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.", @@ -25215,8 +25214,7 @@ }, "application/single_app/functions_workflow_result_followup.py::_latest_thread_id": { "boundary": { - "batches": [], - "module_sha256": "98859b10b350cebda30047969d35c29e29eb6a6cd40e92d4e1405163cf4c8999", + "sha256": "e1cad6036054f7a15527580880d4be3170fed502554db9484488a6a018281363", "points": [], "queries": [ { @@ -25225,7 +25223,8 @@ "response": "consumed" } ], - "sha256": "e1cad6036054f7a15527580880d4be3170fed502554db9484488a6a018281363" + "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.", @@ -25236,8 +25235,7 @@ }, "application/single_app/functions_workflow_result_followup.py::run_workflow_result_follow_up": { "boundary": { - "batches": [], - "module_sha256": "98859b10b350cebda30047969d35c29e29eb6a6cd40e92d4e1405163cf4c8999", + "sha256": "f9f18ac76172b80a987628c2a2f2497e7b75ec7168487443a02800da6245f7bc", "points": [ { "method": "upsert_item", @@ -25252,7 +25250,8 @@ "response": "consumed" } ], - "sha256": "f9f18ac76172b80a987628c2a2f2497e7b75ec7168487443a02800da6245f7bc" + "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.", @@ -25261,8 +25260,7 @@ }, "application/single_app/functions_workflow_result_reader.py::_point_read": { "boundary": { - "batches": [], - "module_sha256": "0f32f66cbe8a09ef70282e28b587fe4d76cab601b348e6166b6c278cbe7a4252", + "sha256": "a8c328dd8d85e7c973c4ba8a529be184407de37243504ab6919368cbf882fd46", "points": [ { "method": "read_item", @@ -25271,7 +25269,8 @@ } ], "queries": [], - "sha256": "a8c328dd8d85e7c973c4ba8a529be184407de37243504ab6919368cbf882fd46" + "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.", @@ -25282,8 +25281,7 @@ }, "application/single_app/functions_workflow_result_reader.py::_task_rows": { "boundary": { - "batches": [], - "module_sha256": "0f32f66cbe8a09ef70282e28b587fe4d76cab601b348e6166b6c278cbe7a4252", + "sha256": "2fdd50432261ec86dce3d4cdd39ae916db63484927734a4614f9f68b5af19a19", "points": [], "queries": [ { @@ -25292,7 +25290,8 @@ "response": "consumed" } ], - "sha256": "2fdd50432261ec86dce3d4cdd39ae916db63484927734a4614f9f68b5af19a19" + "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.", @@ -25303,8 +25302,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._analysis_control": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "a106ee76ee7d0f75b53306e7304ecfb3214619cb1718340ee7a522c393eb90c6", "points": [ { "method": "read_item", @@ -25313,7 +25311,8 @@ } ], "queries": [], - "sha256": "a106ee76ee7d0f75b53306e7304ecfb3214619cb1718340ee7a522c393eb90c6" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25324,8 +25323,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._analysis_guard": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "bf0be658cc9f8519b139fc7368a7ad115cdaeaf7f8c4af4f4b2cb1a89eebb7bb", "points": [ { "method": "read_item", @@ -25334,7 +25332,8 @@ } ], "queries": [], - "sha256": "bf0be658cc9f8519b139fc7368a7ad115cdaeaf7f8c4af4f4b2cb1a89eebb7bb" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25345,8 +25344,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._analysis_scope_rows": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "fe5c54f69e50b44f69eb2e181ec442757ec3030b6844191af6c2a79bc4b1eedc", "points": [], "queries": [ { @@ -25355,7 +25353,8 @@ "response": "returned" } ], - "sha256": "fe5c54f69e50b44f69eb2e181ec442757ec3030b6844191af6c2a79bc4b1eedc" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25366,8 +25365,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._create_immutable_record": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "3e2145b1d8bf7e6ec417fece48f7abdb9a706dd639425742903aff760eedb1b9", "points": [ { "method": "create_item", @@ -25381,7 +25379,8 @@ } ], "queries": [], - "sha256": "3e2145b1d8bf7e6ec417fece48f7abdb9a706dd639425742903aff760eedb1b9" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25392,8 +25391,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._delete_analysis_controls": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "0b220005d832a0c205ffef9dd66b618d7a8ee098047ba994b8f244f47a08d57d", "points": [ { "method": "delete_item", @@ -25402,7 +25400,8 @@ } ], "queries": [], - "sha256": "0b220005d832a0c205ffef9dd66b618d7a8ee098047ba994b8f244f47a08d57d" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25411,8 +25410,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._delete_conversation_results": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "e7cf762bbd6ffde7d430c82b6f9ff6de95b1d0c8b99de09b1e50de7ebaa9f004", "points": [], "queries": [ { @@ -25421,7 +25419,8 @@ "response": "consumed" } ], - "sha256": "e7cf762bbd6ffde7d430c82b6f9ff6de95b1d0c8b99de09b1e50de7ebaa9f004" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25432,8 +25431,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._delete_records": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "d28b179322cb5b860ca4092e1301c96c12e9644a5d36e974004cb8fd81b98620", "points": [ { "method": "delete_item", @@ -25442,7 +25440,8 @@ } ], "queries": [], - "sha256": "d28b179322cb5b860ca4092e1301c96c12e9644a5d36e974004cb8fd81b98620" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25451,8 +25450,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._link_analysis_parent": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "741cea63ef3a225783a012aab31be5c4c6a3f6faf7caed7cb5881929bbf01f1d", "points": [ { "method": "replace_item", @@ -25461,7 +25459,8 @@ } ], "queries": [], - "sha256": "741cea63ef3a225783a012aab31be5c4c6a3f6faf7caed7cb5881929bbf01f1d" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25472,8 +25471,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._read_chunk": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "91f7fee588a6c8264aa57f543bdd0f0c2600b9ab8c1bfee5fba9cbd6af0dd4b0", "points": [ { "method": "read_item", @@ -25482,7 +25480,8 @@ } ], "queries": [], - "sha256": "91f7fee588a6c8264aa57f543bdd0f0c2600b9ab8c1bfee5fba9cbd6af0dd4b0" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25493,8 +25492,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._read_manifest": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "1d4312f5c6bc3f188e38cdde26f5380b400c0cd6047dad58ccc46d1334cba0dc", "points": [ { "method": "read_item", @@ -25503,7 +25501,8 @@ } ], "queries": [], - "sha256": "1d4312f5c6bc3f188e38cdde26f5380b400c0cd6047dad58ccc46d1334cba0dc" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25514,14 +25513,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._write_analysis_lifecycle": { "boundary": { - "batches": [ - { - "method": "execute_item_batch", - "receiver": "self.container", - "response": "returned" - } - ], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "8a37397701955b25c178262a038316e8234c91eb102d76a12881bf6c6f517e48", "points": [ { "method": "create_item", @@ -25540,7 +25532,14 @@ } ], "queries": [], - "sha256": "8a37397701955b25c178262a038316e8234c91eb102d76a12881bf6c6f517e48" + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "returned" + } + ], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25551,14 +25550,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore._write_analysis_record": { "boundary": { - "batches": [ - { - "method": "execute_item_batch", - "receiver": "self.container", - "response": "unused" - } - ], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "c6eefb7957109f068c667737aa4722198ac1740077018e084cbee8075e9ba189", "points": [ { "method": "read_item", @@ -25572,7 +25564,14 @@ } ], "queries": [], - "sha256": "c6eefb7957109f068c667737aa4722198ac1740077018e084cbee8075e9ba189" + "batches": [ + { + "method": "execute_item_batch", + "receiver": "self.container", + "response": "unused" + } + ], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25583,8 +25582,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore.cancel_analysis_attempt": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "f7a503c0fb52c40ed4b259dee9b29a89f183432534de75bdd9c157d33026b382", "points": [ { "method": "create_item", @@ -25598,7 +25596,8 @@ } ], "queries": [], - "sha256": "f7a503c0fb52c40ed4b259dee9b29a89f183432534de75bdd9c157d33026b382" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25607,8 +25606,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore.delete_run_results": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "acdb106e2cef98335485d90b31dc3d29367801e5dd823a876892f8fc40eba9d8", "points": [ { "method": "delete_item", @@ -25628,7 +25626,8 @@ "response": "consumed" } ], - "sha256": "acdb106e2cef98335485d90b31dc3d29367801e5dd823a876892f8fc40eba9d8" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25637,8 +25636,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore.fence_analysis_attempt": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "9f5515ccd7092bf4d8f2bc39fecbdc1e1d55ba8829cdfd4c829b04f540101446", "points": [ { "method": "create_item", @@ -25652,7 +25650,8 @@ } ], "queries": [], - "sha256": "9f5515ccd7092bf4d8f2bc39fecbdc1e1d55ba8829cdfd4c829b04f540101446" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25661,8 +25660,7 @@ }, "application/single_app/functions_workflow_result_store.py::WorkflowResultStore.rollover_orchestration_result_guard": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "8fdec4ad9449440ec6c32497f6c1e4e2277de52c0b2b54aea5286cadfb1b4b7d", "points": [ { "method": "replace_item", @@ -25671,7 +25669,8 @@ } ], "queries": [], - "sha256": "8fdec4ad9449440ec6c32497f6c1e4e2277de52c0b2b54aea5286cadfb1b4b7d" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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.", @@ -25680,8 +25679,7 @@ }, "application/single_app/functions_workflow_result_store.py::_configured_result_store": { "boundary": { - "batches": [], - "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950", + "sha256": "2817247ecbab5e346ae8ca01bd4c255bb2971a0e38a185e3c9aa6b73e066ac00", "points": [ { "method": "read_item", @@ -25690,7 +25688,8 @@ } ], "queries": [], - "sha256": "2817247ecbab5e346ae8ca01bd4c255bb2971a0e38a185e3c9aa6b73e066ac00" + "batches": [], + "module_sha256": "4598405991267f90cdd20209bb3cb620145f535f533d05b94b16e179aab57950" }, "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. Runtime-only logging is injected after configuration bootstrap; quota reads remain Mapping-compatible and no client/callback enters a stored document.", @@ -25702,8 +25701,7 @@ }, "application/single_app/functions_workflow_results.py::authorize_workflow_run_read": { "boundary": { - "batches": [], - "module_sha256": "e526ab344055c783779b65807af1225294697dce7b626834e41a2f4bebcd5354", + "sha256": "f5424b8206570dfa24e8e03e8e7f2c9b27689d28804d3e8238d6640897195eb0", "points": [], "queries": [ { @@ -25712,7 +25710,8 @@ "response": "consumed" } ], - "sha256": "f5424b8206570dfa24e8e03e8e7f2c9b27689d28804d3e8238d6640897195eb0" + "batches": [], + "module_sha256": "e526ab344055c783779b65807af1225294697dce7b626834e41a2f4bebcd5354" }, "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. Review 0.261.380: Module-only safe result-summary metadata extension; this storage owner AST and response consumer are unchanged.", @@ -25723,8 +25722,7 @@ }, "application/single_app/functions_workflow_runner.py::_copy_workflow_result_attachments": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "db66c50ed4fac00ebb3209f9c440a14ea0fcd264de15a590a4d8c3aac9a0e4aa", "points": [ { "method": "read_item", @@ -25758,7 +25756,8 @@ } ], "queries": [], - "sha256": "db66c50ed4fac00ebb3209f9c440a14ea0fcd264de15a590a4d8c3aac9a0e4aa" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "normalized-strict", "contract": "Audit ownership and existing target checks use Mapping fields. Retained file/image/chunk point documents are normalized before strict source authorization and reference remapping; returned writes are unused. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25769,8 +25768,7 @@ }, "application/single_app/functions_workflow_runner.py::_create_assistant_message": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "d60c3017804eaa175adec756090d75e4e5e56175befe970b9d2d3817279f12ab", "points": [ { "method": "upsert_item", @@ -25784,7 +25782,8 @@ } ], "queries": [], - "sha256": "d60c3017804eaa175adec756090d75e4e5e56175befe970b9d2d3817279f12ab" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "response-unused", "contract": "Assistant, citation and conversation upsert responses are discarded. The authored assistant dictionary is returned without SDK metadata; unread state is persisted on the Mapping-compatible conversation input. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25795,8 +25794,7 @@ }, "application/single_app/functions_workflow_runner.py::_create_user_message": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "11227ebeea95959cbbbaba0dc0c757022ac6ec33859ebeb497114b51d5737036", "points": [ { "method": "read_item", @@ -25810,7 +25808,8 @@ } ], "queries": [], - "sha256": "11227ebeea95959cbbbaba0dc0c757022ac6ec33859ebeb497114b51d5737036" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "sdk-compatible", "contract": "A replayed SDK message is checked through nested metadata/run_id field reads and returned unchanged. Assistant tracking consumes its id and thread metadata through Mapping access; new-message upsert responses are discarded. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25821,8 +25820,7 @@ }, "application/single_app/functions_workflow_runner.py::_deliver_configured_workflow_result": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "00b4c167bb30b2f7718b3443df9c9e62a97d232aeaa9578e932e0e9488ba4525", "points": [ { "method": "read_item", @@ -25831,7 +25829,8 @@ } ], "queries": [], - "sha256": "00b4c167bb30b2f7718b3443df9c9e62a97d232aeaa9578e932e0e9488ba4525" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "normalized-strict", "contract": "A copied-image SDK point response is normalized before collaboration mirroring. Other backing and destination messages go through their existing authorized delivery owners. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25842,8 +25841,7 @@ }, "application/single_app/functions_workflow_runner.py::_ensure_workflow_conversation": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "87e3bef7c0b5aabf4a6bf887ac59e49205faa829406184a4503b8bba93c80a2f", "points": [ { "method": "read_item", @@ -25872,7 +25870,8 @@ } ], "queries": [], - "sha256": "87e3bef7c0b5aabf4a6bf887ac59e49205faa829406184a4503b8bba93c80a2f" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "normalized-strict", "contract": "Existing/collision audit point documents are owner-checked and normalized before returning to the workflow runner. New create/upsert responses are unused; run-bound IDs preserve retries and manual titles. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25884,8 +25883,7 @@ }, "application/single_app/functions_workflow_runner.py::_get_latest_thread_id": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "589f93f025d29d0a48ad56e9e89e23d4db2811a5322dec506d12659be4dc3f26", "points": [], "queries": [ { @@ -25894,7 +25892,8 @@ "response": "consumed" } ], - "sha256": "589f93f025d29d0a48ad56e9e89e23d4db2811a5322dec506d12659be4dc3f26" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25905,8 +25904,7 @@ }, "application/single_app/functions_workflow_runner.py::_hide_run_posts_superseded_by_reply": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "d0bffe29664b0dc9ea83fc1b01f8b54c258f0b7ea42c166a9f150a6966c895f0", "points": [ { "method": "read_item", @@ -25920,7 +25918,8 @@ } ], "queries": [], - "sha256": "d0bffe29664b0dc9ea83fc1b01f8b54c258f0b7ea42c166a9f150a6966c895f0" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "sdk-compatible", "contract": "SDK point messages are read through Mapping access, checked for posted_via=agent_action, and assigned plain nested supersession metadata. Upsert responses are discarded; missing or failed messages retain the existing best-effort path. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25931,8 +25930,7 @@ }, "application/single_app/functions_workflow_runner.py::_hide_workflow_conversation_after_delivery": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "a83260ac1a25c600544ae9ed8a397f0546d51c0615c52f1dd8a043142440b9a1", "points": [ { "method": "read_item", @@ -25946,7 +25944,8 @@ } ], "queries": [], - "sha256": "a83260ac1a25c600544ae9ed8a397f0546d51c0615c52f1dd8a043142440b9a1" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "sdk-compatible", "contract": "The SDK conversation is inspected and mutated through Mapping access for workflow/hidden state. Its upsert response is discarded, and the cache update uses the user_id field; read/write failures retain the existing False result. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25957,8 +25956,7 @@ }, "application/single_app/functions_workflow_runner.py::_mirror_assistant_message_to_personal_conversation": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "458664d44b1a5d05d51e2eb049b0d9630a1c40b8c782eceeda72a6ec4a775690", "points": [ { "method": "read_item", @@ -25977,7 +25975,8 @@ } ], "queries": [], - "sha256": "458664d44b1a5d05d51e2eb049b0d9630a1c40b8c782eceeda72a6ec4a775690" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "sdk-compatible", "contract": "SDK conversations use Mapping ownership/group checks and unread/citation updates. Existing SDK messages feed the same Mapping-compatible summary update and are normalized before returning; new authored message upsert responses are discarded. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -25988,8 +25987,7 @@ }, "application/single_app/functions_workflow_runner.py::_persist_agent_citation_artifacts": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "8802115ebaf241fb68a75c1d942ee19d2fb6f039f45bb25edc78ce97b2e9cb45", "points": [ { "method": "upsert_item", @@ -25998,7 +25996,8 @@ } ], "queries": [], - "sha256": "8802115ebaf241fb68a75c1d942ee19d2fb6f039f45bb25edc78ce97b2e9cb45" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "response-unused", "contract": "Artifact upsert responses are discarded; compact citation dictionaries returned by the artifact builder are retained. Failed writes use the existing citation fallback without consuming an SDK response. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -26009,8 +26008,7 @@ }, "application/single_app/functions_workflow_runner.py::_query_merge_candidate_documents": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "64302912ed78d926766464c74de15ffc49456009c63955dcbfbeb69afc04404e", "points": [], "queries": [ { @@ -26019,7 +26017,8 @@ "response": "consumed" } ], - "sha256": "64302912ed78d926766464c74de15ffc49456009c63955dcbfbeb69afc04404e" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -26030,8 +26029,7 @@ }, "application/single_app/functions_workflow_runner.py::_query_recent_documents": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "7107052712a007be1dcfa040eab13e8728d5150b95fd27330c2327e0a2e0584e", "points": [], "queries": [ { @@ -26040,7 +26038,8 @@ "response": "consumed" } ], - "sha256": "7107052712a007be1dcfa040eab13e8728d5150b95fd27330c2327e0a2e0584e" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "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. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -26051,8 +26050,7 @@ }, "application/single_app/functions_workflow_runner.py::_run_authorized_workflow_impl": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "51d5c26698d143b7a5bca6e96f22577a1e978728ccd2d0baf7e66f2589823054", "points": [ { "method": "read_item", @@ -26061,7 +26059,8 @@ } ], "queries": [], - "sha256": "51d5c26698d143b7a5bca6e96f22577a1e978728ccd2d0baf7e66f2589823054" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "sdk-compatible", "contract": "A resumed SDK user-message point response supplies id and nested thread metadata through Mapping access to assistant tracking. Policy failures add application-owned error/error_code strings to the locally authored run record; no point wrapper enters a new strict sink. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -26073,8 +26072,7 @@ }, "application/single_app/functions_workflow_runner.py::_update_workflow_mirror_conversation": { "boundary": { - "batches": [], - "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8", + "sha256": "5d69a6dd5441b0dd3c9f36a489d2b70f14d98fbf39ae989d8b2a037646e3c086", "points": [ { "method": "upsert_item", @@ -26083,7 +26081,8 @@ } ], "queries": [], - "sha256": "5d69a6dd5441b0dd3c9f36a489d2b70f14d98fbf39ae989d8b2a037646e3c086" + "batches": [], + "module_sha256": "622f529ccb094099769727c2b233a046ec0348ddd9dbaf8e40d7956a1bed43f8" }, "classification": "response-unused", "contract": "The unread/citation summary mutates its Mapping-compatible conversation input; the returned upsert response is discarded. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review 0.261.380: Module-only completeness evaluation and private evidence capture outside effectful invocation; this point-response owner AST and response consumer are unchanged. Review renewed for 0.261.389: The legacy model-client factory now shares chat transport construction. Workflow run/checkpoint/result storage, authorization, idempotency receipts and SDK mapping consumers are unchanged; no gateway effect is replayed.", @@ -26094,8 +26093,7 @@ }, "application/single_app/functions_workflow_runtime.py::_bind_active_run": { "boundary": { - "batches": [], - "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5", + "sha256": "5c9bd78acc45bf2f4d61a4a00aa26824d76b63fbfdc8dbc367147d31bb81c0c8", "points": [ { "method": "read_item", @@ -26109,7 +26107,8 @@ } ], "queries": [], - "sha256": "5c9bd78acc45bf2f4d61a4a00aa26824d76b63fbfdc8dbc367147d31bb81c0c8" + "batches": [], + "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5" }, "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. SDK-default queue/projection/status execution provides representative real-owner runtime evidence; continuation selectors remain field projections, not strict outer-document validation.", @@ -26120,8 +26119,7 @@ }, "application/single_app/functions_workflow_runtime.py::_project_runtime_run": { "boundary": { - "batches": [], - "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5", + "sha256": "d517e62c328922e43abdbac71fa7c1a1958275302ae538dd1aca819ddabe00ee", "points": [ { "method": "read_item", @@ -26145,7 +26143,8 @@ } ], "queries": [], - "sha256": "d517e62c328922e43abdbac71fa7c1a1958275302ae538dd1aca819ddabe00ee" + "batches": [], + "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5" }, "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. SDK-default queue/projection/status execution provides representative real-owner runtime evidence; continuation selectors remain field projections, not strict outer-document validation.", @@ -26156,8 +26155,7 @@ }, "application/single_app/functions_workflow_runtime.py::check_durable_workflows_once": { "boundary": { - "batches": [], - "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5", + "sha256": "3c9e4df80a33d44da65f94711ee44ba8caff8d1f61bfb2401a58d5dd06a2f286", "points": [], "queries": [ { @@ -26166,7 +26164,8 @@ "response": "consumed" } ], - "sha256": "3c9e4df80a33d44da65f94711ee44ba8caff8d1f61bfb2401a58d5dd06a2f286" + "batches": [], + "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5" }, "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. SDK-default queue/projection/status execution provides representative real-owner runtime evidence; continuation selectors remain field projections, not strict outer-document validation.", @@ -26177,8 +26176,7 @@ }, "application/single_app/functions_workflow_runtime.py::continue_durable_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5", + "sha256": "f71de1caf52eac06d68c7cb9827c9da580e8d6ff0a4ab057c94e38e7abde325e", "points": [ { "method": "read_item", @@ -26187,7 +26185,8 @@ } ], "queries": [], - "sha256": "f71de1caf52eac06d68c7cb9827c9da580e8d6ff0a4ab057c94e38e7abde325e" + "batches": [], + "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5" }, "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. SDK-default queue/projection/status execution provides representative real-owner runtime evidence; continuation selectors remain field projections, not strict outer-document validation.", @@ -26198,8 +26197,7 @@ }, "application/single_app/functions_workflow_runtime.py::queue_durable_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5", + "sha256": "eb451ec7107d3ce5242ab5ada6303e3c26e12f9e63aadd949e01b96693dce639", "points": [ { "method": "read_item", @@ -26228,7 +26226,8 @@ } ], "queries": [], - "sha256": "eb451ec7107d3ce5242ab5ada6303e3c26e12f9e63aadd949e01b96693dce639" + "batches": [], + "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5" }, "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. SDK-default queue/projection/status execution provides representative real-owner runtime evidence; continuation selectors remain field projections, not strict outer-document validation.", @@ -26239,8 +26238,7 @@ }, "application/single_app/functions_workflow_runtime.py::resume_m365_durable_workflow_run": { "boundary": { - "batches": [], - "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5", + "sha256": "575bcc46920e0c8cb578a6ac8db9e309b8ca167a739a16781a821043ce8bc97d", "points": [ { "method": "read_item", @@ -26249,7 +26247,8 @@ } ], "queries": [], - "sha256": "575bcc46920e0c8cb578a6ac8db9e309b8ca167a739a16781a821043ce8bc97d" + "batches": [], + "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5" }, "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. SDK-default queue/projection/status execution provides representative real-owner runtime evidence; continuation selectors remain field projections, not strict outer-document validation.", @@ -26260,8 +26259,7 @@ }, "application/single_app/functions_workflow_runtime.py::workflow_runtime_status": { "boundary": { - "batches": [], - "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5", + "sha256": "addedc285d5a49c04bf60e6a218873cb175faaeb5dd994da3f2aae8495dec5b0", "points": [ { "method": "read_item", @@ -26270,7 +26268,8 @@ } ], "queries": [], - "sha256": "addedc285d5a49c04bf60e6a218873cb175faaeb5dd994da3f2aae8495dec5b0" + "batches": [], + "module_sha256": "98fa44d5157506a95ace2d5e323ffe9d7f77a96a7afa7239988029a1d65a4ec5" }, "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. SDK-default queue/projection/status execution provides representative real-owner runtime evidence; continuation selectors remain field projections, not strict outer-document validation.", @@ -26281,8 +26280,7 @@ }, "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore._read_control": { "boundary": { - "batches": [], - "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601", + "sha256": "f524b533206fcb5a9afc3f51b0e0a9e3743f40683224a9988d10cb77d6ba846e", "points": [ { "method": "read_item", @@ -26291,7 +26289,8 @@ } ], "queries": [], - "sha256": "f524b533206fcb5a9afc3f51b0e0a9e3743f40683224a9988d10cb77d6ba846e" + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" }, "classification": "sdk-compatible", "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", @@ -26302,8 +26301,7 @@ }, "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore._replace": { "boundary": { - "batches": [], - "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601", + "sha256": "49b1ecfa58161e4aa57e04ef2f663b68d0f61045062656581ccd545906325dfc", "points": [ { "method": "replace_item", @@ -26312,7 +26310,8 @@ } ], "queries": [], - "sha256": "49b1ecfa58161e4aa57e04ef2f663b68d0f61045062656581ccd545906325dfc" + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" }, "classification": "sdk-compatible", "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", @@ -26323,8 +26322,7 @@ }, "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore._verify_existing_record": { "boundary": { - "batches": [], - "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601", + "sha256": "ab7406e8ef1ed75a2c52a5e928bfde344f07393b80f2642dcd227dca88f72bc7", "points": [ { "method": "read_item", @@ -26333,7 +26331,8 @@ } ], "queries": [], - "sha256": "ab7406e8ef1ed75a2c52a5e928bfde344f07393b80f2642dcd227dca88f72bc7" + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" }, "classification": "sdk-compatible", "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", @@ -26344,8 +26343,7 @@ }, "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore.initialize": { "boundary": { - "batches": [], - "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601", + "sha256": "144df60afd6a838f1f3aaca394c9bd60ea406d66724a5e8cd1664e034b7aa969", "points": [ { "method": "create_item", @@ -26354,7 +26352,8 @@ } ], "queries": [], - "sha256": "144df60afd6a838f1f3aaca394c9bd60ea406d66724a5e8cd1664e034b7aa969" + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" }, "classification": "sdk-compatible", "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", @@ -26365,8 +26364,7 @@ }, "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore.tombstone": { "boundary": { - "batches": [], - "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601", + "sha256": "02550cd8959ceb2512c9f9e7aa1d07a0c14385c07f656a8d89d18d48977da010", "points": [ { "method": "create_item", @@ -26375,7 +26373,8 @@ } ], "queries": [], - "sha256": "02550cd8959ceb2512c9f9e7aa1d07a0c14385c07f656a8d89d18d48977da010" + "batches": [], + "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601" }, "classification": "sdk-compatible", "contract": "_verify_identity accepts dictionary subclasses; _strip_cosmos_metadata projects plain replacements before bounded JSON validation.", @@ -26386,6 +26385,9 @@ }, "application/single_app/functions_workflow_runtime_store.py::WorkflowRuntimeStore.write_record": { "boundary": { + "sha256": "2ff6f956594bbd4e85705c20540b5ca97d6ab7d9be82e1e3cffe9b27e2a82d44", + "points": [], + "queries": [], "batches": [ { "method": "execute_item_batch", @@ -26393,10 +26395,7 @@ "response": "unused" } ], - "module_sha256": "2f60f045069faf116aa262ac82022dac5965d9f13efb28f9ca9e0db9d4f58601", - "points": [], - "queries": [], - "sha256": "2ff6f956594bbd4e85705c20540b5ca97d6ab7d9be82e1e3cffe9b27e2a82d44" + "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.", @@ -26405,8 +26404,7 @@ }, "application/single_app/functions_workspace_authoring.py::_assert_available_name": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "2845badc3c227845c90d381e04e0c86387de63a22345bac0b221ea1f84a61fec", "points": [], "queries": [ { @@ -26420,7 +26418,8 @@ "response": "consumed" } ], - "sha256": "2845badc3c227845c90d381e04e0c86387de63a22345bac0b221ea1f84a61fec" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26431,8 +26430,7 @@ }, "application/single_app/functions_workspace_authoring.py::_assert_global_available_name": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "160414da04c6afe7ca4e98e10bfde2ed7d57dd325f478213c50cc62a4f50d703", "points": [], "queries": [ { @@ -26441,7 +26439,8 @@ "response": "consumed" } ], - "sha256": "160414da04c6afe7ca4e98e10bfde2ed7d57dd325f478213c50cc62a4f50d703" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26452,8 +26451,7 @@ }, "application/single_app/functions_workspace_authoring.py::_assert_group_available_name": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "a97098cc7c98141169eb7308cb83097690d8bca0fe81c79d2c17b0ed68389704", "points": [], "queries": [ { @@ -26467,7 +26465,8 @@ "response": "consumed" } ], - "sha256": "a97098cc7c98141169eb7308cb83097690d8bca0fe81c79d2c17b0ed68389704" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26478,8 +26477,7 @@ }, "application/single_app/functions_workspace_authoring.py::_cleanup_replaced_secrets": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "efd7842f0cf096879938f5923abe43d5b79819e52a11b36831dd7a8c4e54fbd0", "points": [], "queries": [ { @@ -26498,7 +26496,8 @@ "response": "consumed" } ], - "sha256": "efd7842f0cf096879938f5923abe43d5b79819e52a11b36831dd7a8c4e54fbd0" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26509,8 +26508,7 @@ }, "application/single_app/functions_workspace_authoring.py::_sync_editor_reminders": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "571e8a38e2c8ec4d1d9ca4fae9c6f3a4040fc38831513773fef547537faa175f", "points": [ { "method": "patch_item", @@ -26519,7 +26517,8 @@ } ], "queries": [], - "sha256": "571e8a38e2c8ec4d1d9ca4fae9c6f3a4040fc38831513773fef547537faa175f" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26530,8 +26529,7 @@ }, "application/single_app/functions_workspace_authoring.py::delete_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "7854c93a88a5c04eac52df00e4799c1591a7ad6954e30a6d1e1b36e38ae789ba", "points": [ { "method": "delete_item", @@ -26540,7 +26538,8 @@ } ], "queries": [], - "sha256": "7854c93a88a5c04eac52df00e4799c1591a7ad6954e30a6d1e1b36e38ae789ba" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26549,8 +26548,7 @@ }, "application/single_app/functions_workspace_authoring.py::delete_global_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "534275467cebcfbd124bbb145d4982df9fed050dd946fd82c307fa800b42bb9e", "points": [ { "method": "delete_item", @@ -26559,7 +26557,8 @@ } ], "queries": [], - "sha256": "534275467cebcfbd124bbb145d4982df9fed050dd946fd82c307fa800b42bb9e" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26568,8 +26567,7 @@ }, "application/single_app/functions_workspace_authoring.py::delete_group_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "091afdd15aef6701a865fff142a27b20af41b5843e74dc7b191c5662c3aa318e", "points": [ { "method": "delete_item", @@ -26578,7 +26576,8 @@ } ], "queries": [], - "sha256": "091afdd15aef6701a865fff142a27b20af41b5843e74dc7b191c5662c3aa318e" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26587,8 +26586,7 @@ }, "application/single_app/functions_workspace_authoring.py::list_editor_records": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "0644df05d0bc95a6f4cc684c1207541ee087a21452e22fbfeb3fcb8e245967a8", "points": [], "queries": [ { @@ -26602,7 +26600,8 @@ "response": "consumed" } ], - "sha256": "0644df05d0bc95a6f4cc684c1207541ee087a21452e22fbfeb3fcb8e245967a8" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26613,8 +26612,7 @@ }, "application/single_app/functions_workspace_authoring.py::list_global_editor_records": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "5f804d08106d54afe5041bd1fb6e69feb007791e53172024f499a1c191256d10", "points": [], "queries": [ { @@ -26623,7 +26621,8 @@ "response": "consumed" } ], - "sha256": "5f804d08106d54afe5041bd1fb6e69feb007791e53172024f499a1c191256d10" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26634,8 +26633,7 @@ }, "application/single_app/functions_workspace_authoring.py::list_group_editor_records": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "5d1816ce8939e3c138d48ebcfdba677dcc1791f5e07423553e05a3f53b689090", "points": [], "queries": [ { @@ -26649,7 +26647,8 @@ "response": "consumed" } ], - "sha256": "5d1816ce8939e3c138d48ebcfdba677dcc1791f5e07423553e05a3f53b689090" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26660,8 +26659,7 @@ }, "application/single_app/functions_workspace_authoring.py::read_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "868eeca7039453ea5d0a0d3d9e4187a711193dbeb0be1c06bb0bdbd147032825", "points": [ { "method": "read_item", @@ -26670,7 +26668,8 @@ } ], "queries": [], - "sha256": "868eeca7039453ea5d0a0d3d9e4187a711193dbeb0be1c06bb0bdbd147032825" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26681,8 +26680,7 @@ }, "application/single_app/functions_workspace_authoring.py::read_global_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "c2a89be2257ca1359da93dafde2011ab378347e45772e8dbb154ae67cc72d357", "points": [ { "method": "read_item", @@ -26691,7 +26689,8 @@ } ], "queries": [], - "sha256": "c2a89be2257ca1359da93dafde2011ab378347e45772e8dbb154ae67cc72d357" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26702,8 +26701,7 @@ }, "application/single_app/functions_workspace_authoring.py::read_group_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "4220960e84458f2216fb800b9eb2ebbfecb883524c67b2ee8a6cb3253cff8153", "points": [ { "method": "read_item", @@ -26712,7 +26710,8 @@ } ], "queries": [], - "sha256": "4220960e84458f2216fb800b9eb2ebbfecb883524c67b2ee8a6cb3253cff8153" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26723,8 +26722,7 @@ }, "application/single_app/functions_workspace_authoring.py::read_group_merged_global_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "a6ad28bd2f2be9c6cee3a22eb83bc952a416ba13a7bf89cf0bc7fd083f984845", "points": [ { "method": "read_item", @@ -26733,7 +26731,8 @@ } ], "queries": [], - "sha256": "a6ad28bd2f2be9c6cee3a22eb83bc952a416ba13a7bf89cf0bc7fd083f984845" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26744,8 +26743,7 @@ }, "application/single_app/functions_workspace_authoring.py::save_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "202c098f09f1b06c5dc9fda008f6ddcecbbdb1dcff377a5f1631ef524b0d75c0", "points": [ { "method": "replace_item", @@ -26759,7 +26757,8 @@ } ], "queries": [], - "sha256": "202c098f09f1b06c5dc9fda008f6ddcecbbdb1dcff377a5f1631ef524b0d75c0" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26770,8 +26769,7 @@ }, "application/single_app/functions_workspace_authoring.py::save_global_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "554fe0352d6b3b8e2a9834a61ef5db2aa1374876e9237569cefb091125dc5fd6", "points": [ { "method": "replace_item", @@ -26785,7 +26783,8 @@ } ], "queries": [], - "sha256": "554fe0352d6b3b8e2a9834a61ef5db2aa1374876e9237569cefb091125dc5fd6" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26796,8 +26795,7 @@ }, "application/single_app/functions_workspace_authoring.py::save_group_editor_record": { "boundary": { - "batches": [], - "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813", + "sha256": "3f70651e24b0922e6ae10eda75072faeecba3f5e93354f1feb7d4584cd6dbf8d", "points": [ { "method": "replace_item", @@ -26811,7 +26809,8 @@ } ], "queries": [], - "sha256": "3f70651e24b0922e6ae10eda75072faeecba3f5e93354f1feb7d4584cd6dbf8d" + "batches": [], + "module_sha256": "7f081466ee3a2fb89f1be0d1b0176997d5c14b3aff54a4e0606935020f88c813" }, "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.", @@ -26822,8 +26821,7 @@ }, "application/single_app/functions_workspace_identities.py::create_workspace_identity": { "boundary": { - "batches": [], - "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441", + "sha256": "2cb3d7431eace51481a79be9524175792c280fc72f8fde63e967156a23006f2e", "points": [ { "method": "create_item", @@ -26832,7 +26830,8 @@ } ], "queries": [], - "sha256": "2cb3d7431eace51481a79be9524175792c280fc72f8fde63e967156a23006f2e" + "batches": [], + "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441" }, "classification": "normalized-strict", "contract": "create_workspace_identity: normalizes returned create/conditional replace SDK documents before credential submission consumes ETags and copies identity state. Lost-response confirmation reads the owned SDK point record before preserving committed Key Vault references; failed writes retain conflict/error behavior and never delete possibly live secrets.", @@ -26843,8 +26842,7 @@ }, "application/single_app/functions_workspace_identities.py::delete_workspace_identity": { "boundary": { - "batches": [], - "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441", + "sha256": "53af570e44df2c56f42fb0a497bf4bb305a3e39092965c92c947642abbe954a5", "points": [ { "method": "delete_item", @@ -26853,7 +26851,8 @@ } ], "queries": [], - "sha256": "53af570e44df2c56f42fb0a497bf4bb305a3e39092965c92c947642abbe954a5" + "batches": [], + "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441" }, "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.", @@ -26864,8 +26863,7 @@ }, "application/single_app/functions_workspace_identities.py::delete_workspace_identity_conditional": { "boundary": { - "batches": [], - "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441", + "sha256": "c1296eec3a40980524b382b74731f785d997bb255353446d12198dc61565d43b", "points": [ { "method": "delete_item", @@ -26874,7 +26872,8 @@ } ], "queries": [], - "sha256": "c1296eec3a40980524b382b74731f785d997bb255353446d12198dc61565d43b" + "batches": [], + "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441" }, "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.", @@ -26885,8 +26884,7 @@ }, "application/single_app/functions_workspace_identities.py::get_workspace_identity": { "boundary": { - "batches": [], - "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441", + "sha256": "ee9ca96edf1583d5f49675f444b2be2f5df7ee5b89e36223c4b259603e95c8dd", "points": [ { "method": "read_item", @@ -26895,7 +26893,8 @@ } ], "queries": [], - "sha256": "ee9ca96edf1583d5f49675f444b2be2f5df7ee5b89e36223c4b259603e95c8dd" + "batches": [], + "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441" }, "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.", @@ -26908,8 +26907,7 @@ }, "application/single_app/functions_workspace_identities.py::list_workspace_identities": { "boundary": { - "batches": [], - "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441", + "sha256": "173ac629756efbafa1c0cafa0e8006d9896ae95742e8b165cc9e43d4c0d4b76f", "points": [], "queries": [ { @@ -26918,7 +26916,8 @@ "response": "consumed" } ], - "sha256": "173ac629756efbafa1c0cafa0e8006d9896ae95742e8b165cc9e43d4c0d4b76f" + "batches": [], + "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441" }, "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.", @@ -26930,8 +26929,7 @@ }, "application/single_app/functions_workspace_identities.py::update_workspace_identity": { "boundary": { - "batches": [], - "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441", + "sha256": "e36e9170ac3efa2a58ae038617cf0468b908f1552ef18c071fa1649e4517e228", "points": [ { "method": "upsert_item", @@ -26940,7 +26938,8 @@ } ], "queries": [], - "sha256": "e36e9170ac3efa2a58ae038617cf0468b908f1552ef18c071fa1649e4517e228" + "batches": [], + "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441" }, "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.", @@ -26951,8 +26950,7 @@ }, "application/single_app/functions_workspace_identities.py::update_workspace_identity_conditional": { "boundary": { - "batches": [], - "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441", + "sha256": "30c57cb2eb491ef106116beb674dd15cb3f37565b8b8215066967b24fbd6a8c4", "points": [ { "method": "replace_item", @@ -26961,7 +26959,8 @@ } ], "queries": [], - "sha256": "30c57cb2eb491ef106116beb674dd15cb3f37565b8b8215066967b24fbd6a8c4" + "batches": [], + "module_sha256": "e59833a886b751793747703c811f00fb198e1fa3861ccc6146117f57e033a441" }, "classification": "normalized-strict", "contract": "update_workspace_identity_conditional: normalizes returned create/conditional replace SDK documents before credential submission consumes ETags and copies identity state. Lost-response confirmation reads the owned SDK point record before preserving committed Key Vault references; failed writes retain conflict/error behavior and never delete possibly live secrets.", @@ -27015,18 +27014,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Workspace document discovery consumes plain query rows and builds bounded related-document metadata; no Cosmos point wrapper enters its document catalog. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Workspace document discovery consumes plain query rows and builds bounded related-document metadata; no Cosmos point wrapper enters its document catalog. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_create_personal_conversation": { "boundary": { @@ -27045,14 +27044,14 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "response-unused", - "contract": "Both conversation upsert responses are discarded; the constructed plain conversation is logged and cache-invalidated, with existing persistence failures unchanged. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Both conversation upsert responses are discarded; the constructed plain conversation is logged and cache-invalidated, with existing persistence failures unchanged. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_get_user_message_image_context": { "boundary": { @@ -27066,18 +27065,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The user-message point mapping supplies nested plain metadata/thread fields for paired image attribution; only user/thread values escape the boundary. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The user-message point mapping supplies nested plain metadata/thread fields for paired image attribution; only user/thread values escape the boundary. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_load_user_message_response_context": { "boundary": { @@ -27091,18 +27090,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The user-message point mapping is read through get() into a plain response-context dictionary; nested thread/user metadata stays JSON and read failures retain existing fallback fields. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The user-message point mapping is read through get() into a plain response-context dictionary; nested thread/user metadata stays JSON and read failures retain existing fallback fields. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_persist_screened_assistant": { "boundary": { @@ -27116,14 +27115,14 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "response-unused", - "contract": "The local Cosmos delete response is discarded on source-screening rollback; its IfNotModified ETag comes from the persistence owner result. Assistant point normalization remains with persist_chat_reply rather than weakening screening. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The local Cosmos delete response is discarded on source-screening rollback; its IfNotModified ETag comes from the persistence owner result. Assistant point normalization remains with persist_chat_reply rather than weakening screening. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_read_agent_citation_artifact_payloads": { "boundary": { @@ -27137,18 +27136,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Artifact and chunk discovery returns plain query rows to build_message_artifact_payload_map; it is not a point-response normalization boundary. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Artifact and chunk discovery returns plain query rows to build_message_artifact_payload_map; it is not a point-response normalization boundary. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_read_recent_assistant_messages": { "boundary": { @@ -27162,18 +27161,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Partitioned assistant query rows remain plain dictionaries through soft-delete filtering and saved-analysis history sanitization. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Partitioned assistant query rows remain plain dictionaries through soft-delete filtering and saved-analysis history sanitization. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_reject_chat_submission": { "boundary": { @@ -27197,14 +27196,14 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "response-unused", - "contract": "Safety/user-message upsert and conversation replace responses are discarded; the browser payload is constructed from plain screened documents and explicit public fields. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Safety/user-message upsert and conversation replace responses are discarded; the browser payload is constructed from plain screened documents and explicit public fields. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_resolve_authorized_conversation_context": { "boundary": { @@ -27218,18 +27217,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The conversation point mapping feeds shared-backing and participation authorization using Mapping fields; no raw document reaches an exact-dictionary domain validator or bypasses access checks. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The conversation point mapping feeds shared-backing and participation authorization using Mapping fields; no raw document reaches an exact-dictionary domain validator or bypasses access checks. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_resolve_chat_selected_document_metadata": { "boundary": { @@ -27243,18 +27242,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Workspace lookup consumes plain query rows, rechecks document availability and projects only id/name/title/workspace fields into a plain selection DTO. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Workspace lookup consumes plain query rows, rechecks document availability and projects only id/name/title/workspace fields into a plain selection DTO. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_rollback_agent_citation_artifacts": { "boundary": { @@ -27279,14 +27278,14 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "response-unused", - "contract": "Plain query rows provide chunk IDs; all chunk/artifact delete responses are discarded and rollback failure accounting remains explicit. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Plain query rows provide chunk IDs; all chunk/artifact delete responses are discarded and rollback failure accounting remains explicit. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::_save_chat_user_metadata": { "boundary": { @@ -27300,18 +27299,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "A new-message upsert may return the SDK mapping to Mapping-compatible chat persistence callers; retry metadata is delegated to patch_chat_message_metadata, which owns conditional update/normalization. No strict top-level DTO is synthesized from arbitrary iterables. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "A new-message upsert may return the SDK mapping to Mapping-compatible chat persistence callers; retry metadata is delegated to patch_chat_message_metadata, which owns conditional update/normalization. No strict top-level DTO is synthesized from arbitrary iterables. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::persist_agent_citation_artifacts": { "boundary": { @@ -27330,14 +27329,14 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "response-unused", - "contract": "Artifact upsert and cancellation-rollback delete responses are discarded; artifact identities are taken from constructed plain documents and cancellation remains visible. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Artifact upsert and cancellation-rollback delete responses are discarded; artifact identities are taken from constructed plain documents and cancellation remains visible. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats._answer_raced_block_submission": { "boundary": { @@ -27351,18 +27350,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "A reread SDK message is checked for conversation membership and inspected by Mapping-compatible block revision helpers; conflict/replay JSON consists of explicit revision fields, not the SDK wrapper. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "A reread SDK message is checked for conversation membership and inspected by Mapping-compatible block revision helpers; conflict/replay JSON consists of explicit revision fields, not the SDK wrapper. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats._find_originating_user_request": { "boundary": { @@ -27376,18 +27375,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The partitioned prior-user query returns plain rows; only the first row content string is used as the originating request. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The partitioned prior-user query returns plain rows; only the first row content string is used as the originating request. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats._get_latest_chat_thread_id": { "boundary": { @@ -27401,18 +27400,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The TOP 1 thread projection is a plain query row; only thread_id is returned, with the existing read-failure fallback unchanged. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The TOP 1 thread projection is a plain query row; only thread_id is returned, with the existing read-failure fallback unchanged. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats._load_block_revision_message": { "boundary": { @@ -27426,18 +27425,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The point message mapping is checked against the authorized conversation and passed to Mapping-compatible revision readers/persistence; missing messages retain their 404 contract. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The point message mapping is checked against the authorized conversation and passed to Mapping-compatible revision readers/persistence; missing messages retain their 404 contract. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats._load_or_create_analyze_conversation": { "boundary": { @@ -27456,18 +27455,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Existing point mappings are checked for owner/deletion state; newly created SDK conversation mappings feed field-based activity logging and cache invalidation, not exact-dictionary result validation. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Existing point mappings are checked for owner/deletion state; newly created SDK conversation mappings feed field-based activity logging and cache invalidation, not exact-dictionary result validation. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats._resolve_document_action_selected_documents": { "boundary": { @@ -27481,18 +27480,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Chat attachment resolution consumes plain partitioned query rows and emits display-name/context projections; workspace ownership remains with the document resolver. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Chat attachment resolution consumes plain partitioned query rows and emits display-name/context projections; workspace ownership remains with the document resolver. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.add_message_image_revision_api": { "boundary": { @@ -27506,18 +27505,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The reload callback returns a partitioned SDK message mapping to the Mapping-compatible image revision owner, which rechecks concurrent versions; the route emits only explicit revision/error fields. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The reload callback returns a partitioned SDK message mapping to the Mapping-compatible image revision owner, which rechecks concurrent versions; the route emits only explicit revision/error fields. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.chat_api": { "boundary": { @@ -27602,10 +27601,11 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Retry/source point mappings supply role/content and nested model/thread metadata through Mapping access; history queries stay plain. Metadata persistence remains with its existing owner and local write responses are discarded. Action recovery now pauses before user-message persistence and model initialization; the original mapping-compatible Cosmos consumers and conditional persistence stay unchanged. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Added per-answer evidence metadata and stable model-configuration errors; existing point responses still use Mapping-compatible field access and the same save/authorization owners. No exact-dict sink or new storage call is introduced. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review 0.261.395: canonical source intent is nested plain request JSON; the existing SDK Mapping reads and unused message/conversation write responses are unchanged. Review 0.261.400: Excel native-inspection routing delegates to report/search readers; original retry/history Mapping consumers and unused writes are unchanged. Existing SDK route evidence and native routing/citation tests pass. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Retry/source point mappings supply role/content and nested model/thread metadata through Mapping access; history queries stay plain. Metadata persistence remains with its existing owner and local write responses are discarded. Action recovery now pauses before user-message persistence and model initialization; the original mapping-compatible Cosmos consumers and conditional persistence stay unchanged. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Added per-answer evidence metadata and stable model-configuration errors; existing point responses still use Mapping-compatible field access and the same save/authorization owners. No exact-dict sink or new storage call is introduced. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review 0.261.395: canonical source intent is nested plain request JSON; the existing SDK Mapping reads and unused message/conversation write responses are unchanged. Review 0.261.400: Excel native-inspection routing delegates to report/search readers; original retry/history Mapping consumers and unused writes are unchanged. Existing SDK route evidence and native routing/citation tests pass. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_action_runtime_recovery.py::test_actual_chat_routes_pause_before_kernel_initialization_or_user_persistence", @@ -27613,8 +27613,7 @@ "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.chat_stream_api.generate": { "boundary": { @@ -27679,10 +27678,11 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Retry point mappings are checked for role/conversation and nested metadata through Mapping access; history queries remain plain, and local create/replace/delete return values are discarded. SSE telemetry does not alter storage contracts. Action recovery now pauses before user-message persistence and model initialization; the original mapping-compatible Cosmos consumers and conditional persistence stay unchanged. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Added per-answer evidence metadata and stable model-configuration errors; existing point responses still use Mapping-compatible field access and the same save/authorization owners. Streaming publication and cancellation fences remain unchanged. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review 0.261.395: canonical source intent is nested plain request JSON; the existing SDK Mapping reads and unused message/conversation write responses are unchanged. Review 0.261.400: Excel native-inspection routing delegates to report/search readers; original retry/history Mapping consumers and unused writes are unchanged. Existing SDK route evidence and native routing/citation tests pass. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Retry point mappings are checked for role/conversation and nested metadata through Mapping access; history queries remain plain, and local create/replace/delete return values are discarded. SSE telemetry does not alter storage contracts. Action recovery now pauses before user-message persistence and model initialization; the original mapping-compatible Cosmos consumers and conditional persistence stay unchanged. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Added per-answer evidence metadata and stable model-configuration errors; existing point responses still use Mapping-compatible field access and the same save/authorization owners. Streaming publication and cancellation fences remain unchanged. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review 0.261.395: canonical source intent is nested plain request JSON; the existing SDK Mapping reads and unused message/conversation write responses are unchanged. Review 0.261.400: Excel native-inspection routing delegates to report/search readers; original retry/history Mapping consumers and unused writes are unchanged. Existing SDK route evidence and native routing/citation tests pass. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_action_runtime_recovery.py::test_actual_chat_routes_pause_before_kernel_initialization_or_user_persistence", @@ -27690,8 +27690,7 @@ "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.chat_stream_api.generate.finalize_cancelled_stream_response": { "boundary": { @@ -27705,14 +27704,14 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "response-unused", - "contract": "Cancellation refreshes the conversation with a discarded replace response; screened message persistence remains with its existing owner and the stream payload is assembled separately. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: The added evidence metadata is plain request-owned JSON. Direct Cosmos mutation responses remain unused; conditional cancellation/publication behavior is unchanged. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Cancellation refreshes the conversation with a discarded replace response; screened message persistence remains with its existing owner and the stream payload is assembled separately. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: The added evidence metadata is plain request-owned JSON. Direct Cosmos mutation responses remain unused; conditional cancellation/publication behavior is unchanged. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.execute_document_action_chat_request": { "boundary": { @@ -27746,18 +27745,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The original Analyze point mapping is checked for role/conversation/content and nested thread metadata; local message writes and cleanup deletes discard responses, while retained analysis contracts remain strict. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The original Analyze point mapping is checked for role/conversation/content and nested thread metadata; local message writes and cleanup deletes discard responses, while retained analysis contracts remain strict. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.execute_saved_analysis_chat_request": { "boundary": { @@ -27802,18 +27801,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Retry input point mappings supply authorized role/content/thread fields; history queries are plain, and user/system writes and rollback deletes discard responses. Saved-analysis strict result admission remains with its storage owner. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Retry input point mappings supply authorized role/content/thread fields; history queries are plain, and user/system writes and rollback deletes discard responses. Saved-analysis strict result admission remains with its storage owner. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.generate_image_from_proposal": { "boundary": { @@ -27832,18 +27831,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The source assistant SDK mapping is authorized by conversation/role and used by Mapping-compatible planned-image lookup; conversation replacement discards its response and public image data is projected explicitly. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The source assistant SDK mapping is authorized by conversation/role and used by Mapping-compatible planned-image lookup; conversation replacement discards its response and public image data is projected explicitly. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.generate_image_from_proposal.read_conversation_image": { "boundary": { @@ -27857,18 +27856,18 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The partitioned point mapping is returned to find_planned_proposal_image, which inspects message fields; a missing message returns None, without an empty-document or strict-type fallback. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The partitioned point mapping is returned to find_planned_proposal_image, which inspects message fields; a missing message returns None, without an empty-document or strict-type fallback. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.image_proposal_status": { "boundary": { @@ -27882,18 +27881,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Proposal status iterates plain query rows, validates nested proposal dictionaries and emits explicit public image status fields. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Proposal status iterates plain query rows, validates nested proposal dictionaries and emits explicit public image status fields. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.mask_message_api": { "boundary": { @@ -27918,18 +27917,18 @@ } ], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "Point message/conversation mappings and plain fallback query rows use field-based ownership and soft-delete checks; nested mask metadata goes to existing persistence, and public JSON projects mask fields only. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "Point message/conversation mappings and plain fallback query rows use field-based ownership and soft-delete checks; nested mask metadata goes to existing persistence, and public JSON projects mask fields only. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_chats.py::register_route_backend_chats.set_message_visual_style_api": { "boundary": { @@ -27943,23 +27942,22 @@ ], "queries": [], "batches": [], - "module_sha256": "410724ade096fb60ad87f78ca8db8122f327fe815a484587d9ac08c91b9a245e" + "module_sha256": "bf3d83a4cd6fa896f85508f121ab4532353460d6c3f8a68ee6eb8dcd3742c442" }, "classification": "sdk-compatible", - "contract": "The point message mapping is checked for conversation identity and passed to Mapping-compatible visual-style/persistence owners; public JSON projects nested visual_styles rather than the SDK document. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Index-first module review: this storage function and its point/query/batch consumers are unchanged (AST and storage-call shapes checked); new metadata identities remain scalar strings and do not alter SDK mapping/ETag handling. Existing owner evidence and representative updated-module SDK runtime cases are retained. Base-merge review for 0.261.407: both parents and the combined module retain the same storage-function AST and point/query/batch consumers. Web IQ discovery and Assigned Knowledge inventory changes are outside these storage functions; existing owner-runtime SDK evidence and merged source/search regressions are retained.", + "contract": "The point message mapping is checked for conversation identity and passed to Mapping-compatible visual-style/persistence owners; public JSON projects nested visual_styles rather than the SDK document. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function. Combined V2 source-policy and stale-group recovery wiring preserves this storage function; both branches' representative owner-runtime evidence is retained. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.388: Function body and SDK point/query/batch operations are unchanged; module-only model-policy, source-presentation, or export-helper changes do not alter this Mapping consumer or its conditional-write contract. Review renewed for 0.261.389: Legacy and named model calls now use the shared explicit-API client factory. Redundant identity-header construction was removed; the factory retains the same identity context. SDK conversation/message consumers, object authorization, screening, cancellation, ETags and persistence operations are unchanged. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", + "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_action_credentials_bootstrap.py", "functional_tests/test_excel_document_accessibility_extraction.py::test_mixed_source_inspection_uses_report_search_authorization_and_citations", "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain", "functional_tests/test_stale_active_group_recovery.py::test_stale_group_recovers_in_real_pages_and_chat_transports", "functional_tests/test_v2_document_source_runtime.py" - ], - "evidence_scope": "owner-runtime" + ] }, "application/single_app/route_backend_collaboration.py::_find_collaboration_originating_request": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "ed7144214acf3cab30b8e4361586861007bd3127d59d2fd904bf2a07a8386c0f", "points": [], "queries": [ { @@ -27968,7 +27966,8 @@ "response": "consumed" } ], - "sha256": "ed7144214acf3cab30b8e4361586861007bd3127d59d2fd904bf2a07a8386c0f" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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. Representative SDK-default runtime coverage now executes this shared-storage module; this does not claim exhaustive branch coverage for this unchanged owner.", @@ -27979,8 +27978,7 @@ }, "application/single_app/route_backend_collaboration.py::_read_source_message_doc": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "4e197f96774901388a1020c7f7782209922f741d17537f0d6ef327d3efbf838b", "points": [ { "method": "read_item", @@ -27995,7 +27993,8 @@ "response": "consumed" } ], - "sha256": "4e197f96774901388a1020c7f7782209922f741d17537f0d6ef327d3efbf838b" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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. Representative SDK-default runtime coverage now executes this shared-storage module; this does not claim exhaustive branch coverage for this unchanged owner.", @@ -28006,8 +28005,7 @@ }, "application/single_app/route_backend_collaboration.py::_save_collaboration_block_revisions": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "c1ca1faf4fc3d73cfde67dd6f45439322bc550d23302d3c000bf011d2f8c5a8b", "points": [ { "method": "upsert_item", @@ -28016,7 +28014,8 @@ } ], "queries": [], - "sha256": "c1ca1faf4fc3d73cfde67dd6f45439322bc550d23302d3c000bf011d2f8c5a8b" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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.", @@ -28025,8 +28024,7 @@ }, "application/single_app/route_backend_collaboration.py::_save_collaboration_image_revisions": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "c0339b04a55a8a44fec6f496e6d3da8556b04ef196581787b0dd6fd4477f685f", "points": [ { "method": "upsert_item", @@ -28040,7 +28038,8 @@ } ], "queries": [], - "sha256": "c0339b04a55a8a44fec6f496e6d3da8556b04ef196581787b0dd6fd4477f685f" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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.", @@ -28049,8 +28048,7 @@ }, "application/single_app/route_backend_collaboration.py::_sync_collaboration_block_revisions_to_source": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "6379d69b1d3010498caa86ba7cae744002d02d46da7c012dd178e991b99b4f3e", "points": [ { "method": "read_item", @@ -28064,7 +28062,8 @@ } ], "queries": [], - "sha256": "6379d69b1d3010498caa86ba7cae744002d02d46da7c012dd178e991b99b4f3e" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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. Representative SDK-default runtime coverage now executes this shared-storage module; this does not claim exhaustive branch coverage for this unchanged owner.", @@ -28075,8 +28074,7 @@ }, "application/single_app/route_backend_collaboration.py::_sync_collaboration_mask_metadata_to_source": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "62a96e92fdcab0fb96a26e681afadabffcb66e5c23c0b1d9c2113e3bb76d16a0", "points": [ { "method": "read_item", @@ -28090,7 +28088,8 @@ } ], "queries": [], - "sha256": "62a96e92fdcab0fb96a26e681afadabffcb66e5c23c0b1d9c2113e3bb76d16a0" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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. Representative SDK-default runtime coverage now executes this shared-storage module; this does not claim exhaustive branch coverage for this unchanged owner.", @@ -28101,8 +28100,7 @@ }, "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.add_collaboration_image_revision_api": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "4bb38f2c190d9406561a1d98a4e82237ef836afe05249aa5e796aab2e4730818", "points": [ { "method": "read_item", @@ -28111,7 +28109,8 @@ } ], "queries": [], - "sha256": "4bb38f2c190d9406561a1d98a4e82237ef836afe05249aa5e796aab2e4730818" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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. Representative SDK-default runtime coverage now executes this shared-storage module; this does not claim exhaustive branch coverage for this unchanged owner.", @@ -28122,8 +28121,7 @@ }, "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.mask_collaboration_message_api": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "1fc52aaaa55005467cd20bcac1ba986376ac46a4c827ee6bdb2ceb2ef1a74e99", "points": [ { "method": "upsert_item", @@ -28132,7 +28130,8 @@ } ], "queries": [], - "sha256": "1fc52aaaa55005467cd20bcac1ba986376ac46a4c827ee6bdb2ceb2ef1a74e99" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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.", @@ -28141,8 +28140,7 @@ }, "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.set_collaboration_message_visual_style_api": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "f525b0236ed0bb7c4a3022b0e04811502f4c56a88b1e28cee1585c1a08acfc20", "points": [ { "method": "upsert_item", @@ -28151,7 +28149,8 @@ } ], "queries": [], - "sha256": "f525b0236ed0bb7c4a3022b0e04811502f4c56a88b1e28cee1585c1a08acfc20" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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.", @@ -28160,8 +28159,7 @@ }, "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.stream_collaboration_message_api": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "9d221091867db40566421803a650bcae021f9c7a2fa1b147dba0b263566b335d", "points": [ { "method": "upsert_item", @@ -28170,7 +28168,8 @@ } ], "queries": [], - "sha256": "9d221091867db40566421803a650bcae021f9c7a2fa1b147dba0b263566b335d" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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. The new credential branch authorizes the private request against the actor and verified original shared question, returns a safe visible-ID DTO only on its HTTP stream, and never publishes it. Both event formats execute under the real shared route.", @@ -28181,8 +28180,7 @@ }, "application/single_app/route_backend_collaboration.py::register_route_backend_collaboration.stream_collaboration_message_api.generate_stream.transform_event_block": { "boundary": { - "batches": [], - "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b", + "sha256": "e3f90fdcd656acdc6e0c4719a4c6c31ff9fbcd70ad63d9a71e21e489794e21e6", "points": [ { "method": "read_item", @@ -28201,7 +28199,8 @@ } ], "queries": [], - "sha256": "e3f90fdcd656acdc6e0c4719a4c6c31ff9fbcd70ad63d9a71e21e489794e21e6" + "batches": [], + "module_sha256": "291181b2bfd858f889fd87b70f529dbe7a4cb4547af2a73f0af9deeda3bb4f4b" }, "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. The new credential branch authorizes the private request against the actor and verified original shared question, returns a safe visible-ID DTO only on its HTTP stream, and never publishes it. Both event formats execute under the real shared route.", @@ -28212,8 +28211,7 @@ }, "application/single_app/route_backend_content_screening.py::register_route_backend_content_screening.content_screening_update_configuration": { "boundary": { - "batches": [], - "module_sha256": "4fd917927cadbfb141d5268b9116f3350687681e46bf5a2c6d49a6c0b02d2e7d", + "sha256": "96f02b15c06020c1da35a3347ca858516ec06b10b07889b8b630c798cf6890f5", "points": [ { "method": "read_item", @@ -28222,7 +28220,8 @@ } ], "queries": [], - "sha256": "96f02b15c06020c1da35a3347ca858516ec06b10b07889b8b630c798cf6890f5" + "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.", @@ -28233,8 +28232,7 @@ }, "application/single_app/route_backend_control_center.py::_control_center_count_users": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "01a9ad635c819fde99b0b296f472c6440616cc79b7e8aff29bf05a2d92fd7693", "points": [], "queries": [ { @@ -28243,7 +28241,8 @@ "response": "consumed" } ], - "sha256": "01a9ad635c819fde99b0b296f472c6440616cc79b7e8aff29bf05a2d92fd7693" + "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.", @@ -28254,8 +28253,7 @@ }, "application/single_app/route_backend_control_center.py::_control_center_iter_users": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "5ba64d8b61db844264f1273a6bb055cb6315f3bac5568b37350bd7f31c055cc9", "points": [], "queries": [ { @@ -28264,7 +28262,8 @@ "response": "consumed" } ], - "sha256": "5ba64d8b61db844264f1273a6bb055cb6315f3bac5568b37350bd7f31c055cc9" + "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.", @@ -28275,8 +28274,7 @@ }, "application/single_app/route_backend_control_center.py::_control_center_query_user_page": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "aac7db66f198602913f484100799d691e35f77cf431197c599502ae10ad0cfc9", "points": [], "queries": [ { @@ -28290,7 +28288,8 @@ "response": "consumed" } ], - "sha256": "aac7db66f198602913f484100799d691e35f77cf431197c599502ae10ad0cfc9" + "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.", @@ -28301,8 +28300,7 @@ }, "application/single_app/route_backend_control_center.py::enhance_group_with_activity": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "7f60d6f37106da1433c8148fd7153b33a98c75f706dabb51dfbca559e775f5b0", "points": [], "queries": [ { @@ -28336,7 +28334,8 @@ "response": "consumed" } ], - "sha256": "7f60d6f37106da1433c8148fd7153b33a98c75f706dabb51dfbca559e775f5b0" + "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.", @@ -28347,8 +28346,7 @@ }, "application/single_app/route_backend_control_center.py::enhance_public_workspace_with_activity": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "41e4438482b804498e698784b4dc6f27149e9c9c84026572f7512fd122832632", "points": [], "queries": [ { @@ -28377,7 +28375,8 @@ "response": "consumed" } ], - "sha256": "41e4438482b804498e698784b4dc6f27149e9c9c84026572f7512fd122832632" + "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.", @@ -28388,8 +28387,7 @@ }, "application/single_app/route_backend_control_center.py::enhance_user_with_activity": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "15165977cf094e191e4765d9487052825ed9b83053532bf362d0bc6d5f185d8a", "points": [], "queries": [ { @@ -28448,7 +28446,8 @@ "response": "consumed" } ], - "sha256": "15165977cf094e191e4765d9487052825ed9b83053532bf362d0bc6d5f185d8a" + "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.", @@ -28459,8 +28458,7 @@ }, "application/single_app/route_backend_control_center.py::get_activity_log_user_details": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "db6ac09d6cf74929d1f3ba5cfc090fdf53620d66f3b2faa48a02445fd7398487", "points": [ { "method": "read_item", @@ -28469,7 +28467,8 @@ } ], "queries": [], - "sha256": "db6ac09d6cf74929d1f3ba5cfc090fdf53620d66f3b2faa48a02445fd7398487" + "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.", @@ -28480,8 +28479,7 @@ }, "application/single_app/route_backend_control_center.py::get_activity_trends_data": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "6cae217b028b8ca9d05d4d82e9440f922a87665ebbabed773209b6f386bf2e38", "points": [], "queries": [ { @@ -28520,7 +28518,8 @@ "response": "consumed" } ], - "sha256": "6cae217b028b8ca9d05d4d82e9440f922a87665ebbabed773209b6f386bf2e38" + "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.", @@ -28531,8 +28530,7 @@ }, "application/single_app/route_backend_control_center.py::get_distinct_token_filter_values": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "88cb89bb060277c932b41a0c695a107f32d7c55adcedd867fb41dd62a2e3f8c7", "points": [], "queries": [ { @@ -28541,7 +28539,8 @@ "response": "consumed" } ], - "sha256": "88cb89bb060277c932b41a0c695a107f32d7c55adcedd867fb41dd62a2e3f8c7" + "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.", @@ -28552,8 +28551,7 @@ }, "application/single_app/route_backend_control_center.py::get_group_name_map": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "a11221be98915e6d6562cbb7ce21dfe081431bc73a950f085d56ca2425cb8672", "points": [ { "method": "read_item", @@ -28562,7 +28560,8 @@ } ], "queries": [], - "sha256": "a11221be98915e6d6562cbb7ce21dfe081431bc73a950f085d56ca2425cb8672" + "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.", @@ -28573,8 +28572,7 @@ }, "application/single_app/route_backend_control_center.py::get_group_token_totals": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "cd22ac59f1ae93391e86fdaf5e592d1554dca69237b3ee7d5a1069962e35a3c4", "points": [], "queries": [ { @@ -28588,7 +28586,8 @@ "response": "consumed" } ], - "sha256": "cd22ac59f1ae93391e86fdaf5e592d1554dca69237b3ee7d5a1069962e35a3c4" + "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.", @@ -28599,8 +28598,7 @@ }, "application/single_app/route_backend_control_center.py::get_public_workspace_name_map": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "c7acfabe176f420db2da191e9bd616eb6d5496b2675abe861d0ca44bc4edc4a1", "points": [ { "method": "read_item", @@ -28609,7 +28607,8 @@ } ], "queries": [], - "sha256": "c7acfabe176f420db2da191e9bd616eb6d5496b2675abe861d0ca44bc4edc4a1" + "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.", @@ -28620,8 +28619,7 @@ }, "application/single_app/route_backend_control_center.py::get_raw_activity_trends_data": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "bc580439f145a7efc361bbdc0f3d9e923090497976501b4f0b5c14f486585a06", "points": [], "queries": [ { @@ -28665,7 +28663,8 @@ "response": "consumed" } ], - "sha256": "bc580439f145a7efc361bbdc0f3d9e923090497976501b4f0b5c14f486585a06" + "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.", @@ -28676,8 +28675,7 @@ }, "application/single_app/route_backend_control_center.py::get_raw_activity_trends_data.get_user_info": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "1ac34bf41434e9967d08dbc7804dc180c19f04a01678d00ef67a476e28ee1cf9", "points": [ { "method": "read_item", @@ -28686,7 +28684,8 @@ } ], "queries": [], - "sha256": "1ac34bf41434e9967d08dbc7804dc180c19f04a01678d00ef67a476e28ee1cf9" + "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.", @@ -28697,8 +28696,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_documents": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "a1dab49c07ba1a019f7a7c966979e2b8e322e4cc4717eaae3ec9ebccf8728828", "points": [ { "method": "create_item", @@ -28718,7 +28716,8 @@ "response": "consumed" } ], - "sha256": "a1dab49c07ba1a019f7a7c966979e2b8e322e4cc4717eaae3ec9ebccf8728828" + "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.", @@ -28727,8 +28726,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_group": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "d8f46e31573c657e2d4fb8e5d373a5277edb1f6515c6ffd14d398d797d0fcc5f", "points": [ { "method": "delete_item", @@ -28758,7 +28756,8 @@ "response": "consumed" } ], - "sha256": "d8f46e31573c657e2d4fb8e5d373a5277edb1f6515c6ffd14d398d797d0fcc5f" + "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.", @@ -28767,8 +28766,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_public_workspace": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "dc56aa9ebe34d4a74e87b0f1a444ce3288d8face35882d9e959d2629b0535c1b", "points": [ { "method": "delete_item", @@ -28782,7 +28780,8 @@ } ], "queries": [], - "sha256": "dc56aa9ebe34d4a74e87b0f1a444ce3288d8face35882d9e959d2629b0535c1b" + "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.", @@ -28791,8 +28790,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_public_workspace_documents": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "4f95d0624ad9e1e16e0530c684f83045f043ed9cf8d7b91d09702ce13c23c366", "points": [ { "method": "create_item", @@ -28807,7 +28805,8 @@ "response": "consumed" } ], - "sha256": "4f95d0624ad9e1e16e0530c684f83045f043ed9cf8d7b91d09702ce13c23c366" + "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.", @@ -28816,8 +28815,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_delete_user_documents": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "37081d79f77c390b0bc0eeee8769b496d3a45075684316cf78ada29492dfca38", "points": [ { "method": "create_item", @@ -28837,7 +28835,8 @@ "response": "consumed" } ], - "sha256": "37081d79f77c390b0bc0eeee8769b496d3a45075684316cf78ada29492dfca38" + "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.", @@ -28846,8 +28845,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_take_ownership": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "4d96dcd137ce7240af654015cddff03a7d9f3ce6d1310c92ad8fa1a04b0d0e10", "points": [ { "method": "create_item", @@ -28856,7 +28854,8 @@ } ], "queries": [], - "sha256": "4d96dcd137ce7240af654015cddff03a7d9f3ce6d1310c92ad8fa1a04b0d0e10" + "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.", @@ -28865,8 +28864,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_take_workspace_ownership": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "f6cbc529a9062c458ed8b214ca3c84c8047e4e8b5330e76e8cd015ea62ba4ea0", "points": [ { "method": "read_item", @@ -28880,7 +28878,8 @@ } ], "queries": [], - "sha256": "f6cbc529a9062c458ed8b214ca3c84c8047e4e8b5330e76e8cd015ea62ba4ea0" + "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.", @@ -28891,8 +28890,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_take_workspace_ownership._resolve_user": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "ef274097ab22ac87c72a3b048c7e5c29552a0fd3019ea61d09e7bd0d37bced4f", "points": [ { "method": "read_item", @@ -28901,7 +28899,8 @@ } ], "queries": [], - "sha256": "ef274097ab22ac87c72a3b048c7e5c29552a0fd3019ea61d09e7bd0d37bced4f" + "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.", @@ -28912,8 +28911,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_transfer_ownership": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "055e76f4c52ccb11c56a596291122ad68e78b56e995a48fc5cfb53ddd093775c", "points": [ { "method": "create_item", @@ -28922,7 +28920,8 @@ } ], "queries": [], - "sha256": "055e76f4c52ccb11c56a596291122ad68e78b56e995a48fc5cfb53ddd093775c" + "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.", @@ -28931,8 +28930,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_transfer_workspace_ownership": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "4417b1f5555b88b196d8548e4faf4e1b1a60cf02f96bd434a5114beb3b4221ee", "points": [ { "method": "read_item", @@ -28946,7 +28944,8 @@ } ], "queries": [], - "sha256": "4417b1f5555b88b196d8548e4faf4e1b1a60cf02f96bd434a5114beb3b4221ee" + "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.", @@ -28957,8 +28956,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._execute_transfer_workspace_ownership._resolve_user": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "ef274097ab22ac87c72a3b048c7e5c29552a0fd3019ea61d09e7bd0d37bced4f", "points": [ { "method": "read_item", @@ -28967,7 +28965,8 @@ } ], "queries": [], - "sha256": "ef274097ab22ac87c72a3b048c7e5c29552a0fd3019ea61d09e7bd0d37bced4f" + "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.", @@ -28978,8 +28977,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center._update_group_status": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "cb8948e7e20ef4aa9dba1a57e93feff9141802a76bbc247a8b4eb799afa96d56", "points": [ { "method": "read_item", @@ -28988,7 +28986,8 @@ } ], "queries": [], - "sha256": "cb8948e7e20ef4aa9dba1a57e93feff9141802a76bbc247a8b4eb799afa96d56" + "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.", @@ -28999,8 +28998,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_group_member": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "4d41d2c6f7181843fee34e6ab84bbe70f079a743174252ff29aa25a75e81b7b1", "points": [ { "method": "read_item", @@ -29014,7 +29012,8 @@ } ], "queries": [], - "sha256": "4d41d2c6f7181843fee34e6ab84bbe70f079a743174252ff29aa25a75e81b7b1" + "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.", @@ -29025,8 +29024,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_workspace_member": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "190a9e0fd62cdf0fbc5a6cc7ffa214590c3494ab4b55776b3bb31e789be2138f", "points": [ { "method": "read_item", @@ -29040,7 +29038,8 @@ } ], "queries": [], - "sha256": "190a9e0fd62cdf0fbc5a6cc7ffa214590c3494ab4b55776b3bb31e789be2138f" + "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.", @@ -29051,8 +29050,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_add_workspace_member_single": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "102f1a5c5260d2a9d49d32adf40a953d0dc291ce2503a66382858dd173e6bde7", "points": [ { "method": "read_item", @@ -29066,7 +29064,8 @@ } ], "queries": [], - "sha256": "102f1a5c5260d2a9d49d32adf40a953d0dc291ce2503a66382858dd173e6bde7" + "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.", @@ -29077,8 +29076,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_get_group_activity": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "846db4bbce46379580c8c2127ffa9612bdb8a7971f1b6845f1bb20b4b35847bf", "points": [], "queries": [ { @@ -29092,7 +29090,8 @@ "response": "consumed" } ], - "sha256": "846db4bbce46379580c8c2127ffa9612bdb8a7971f1b6845f1bb20b4b35847bf" + "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.", @@ -29103,8 +29102,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_take_group_ownership": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "bdad34ce89e68b0c0f3107071a0bd279251bf89dd37d1ecb635da9d2aa108fbf", "points": [ { "method": "read_item", @@ -29113,7 +29111,8 @@ } ], "queries": [], - "sha256": "bdad34ce89e68b0c0f3107071a0bd279251bf89dd37d1ecb635da9d2aa108fbf" + "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.", @@ -29124,8 +29123,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_take_workspace_ownership": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "5c45a4268ed203cc1191f0b24c8708f609f6845792ddb1fa85e0f9f1ed1c1658", "points": [ { "method": "read_item", @@ -29134,7 +29132,8 @@ } ], "queries": [], - "sha256": "5c45a4268ed203cc1191f0b24c8708f609f6845792ddb1fa85e0f9f1ed1c1658" + "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.", @@ -29145,8 +29144,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_admin_transfer_group_ownership": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "02ed6815ae2edd7ae926837e21ee902c01712553c830f5cd6ae50c91fcc3186e", "points": [ { "method": "read_item", @@ -29155,7 +29153,8 @@ } ], "queries": [], - "sha256": "02ed6815ae2edd7ae926837e21ee902c01712553c830f5cd6ae50c91fcc3186e" + "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.", @@ -29166,8 +29165,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_bulk_public_workspace_action": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "23727e4f33f97332f0aa6c496041bd4f98272f187e5a3241a456bdc7d67e7be6", "points": [ { "method": "read_item", @@ -29182,7 +29180,8 @@ "response": "consumed" } ], - "sha256": "23727e4f33f97332f0aa6c496041bd4f98272f187e5a3241a456bdc7d67e7be6" + "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.", @@ -29193,8 +29192,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_control_center_public_workspaces": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "ec82b7ba7e8bd23ff1fa9c8c472ad61c8643ff06af0c82566f08032a027ffe8e", "points": [], "queries": [ { @@ -29203,7 +29201,8 @@ "response": "consumed" } ], - "sha256": "ec82b7ba7e8bd23ff1fa9c8c472ad61c8643ff06af0c82566f08032a027ffe8e" + "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.", @@ -29214,8 +29213,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_group_admin": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "74129a46aadfd2a3b989c2917b6d997af2c2b60a44eb40fb2e8cdf4009f1fc15", "points": [ { "method": "read_item", @@ -29224,7 +29222,8 @@ } ], "queries": [], - "sha256": "74129a46aadfd2a3b989c2917b6d997af2c2b60a44eb40fb2e8cdf4009f1fc15" + "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.", @@ -29235,8 +29234,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_group_documents_admin": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "9eb798e2b3f1c1b9f03626c3987508b0c431d6e3a4a339209c6673fdfaba6766", "points": [ { "method": "read_item", @@ -29245,7 +29243,8 @@ } ], "queries": [], - "sha256": "9eb798e2b3f1c1b9f03626c3987508b0c431d6e3a4a339209c6673fdfaba6766" + "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.", @@ -29256,8 +29255,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_public_workspace_admin": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "d0e757dd05f82a15acdf847446730b24b8ecc5ffbf0b28f551baf5e6d074699b", "points": [ { "method": "read_item", @@ -29266,7 +29264,8 @@ } ], "queries": [], - "sha256": "d0e757dd05f82a15acdf847446730b24b8ecc5ffbf0b28f551baf5e6d074699b" + "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.", @@ -29277,8 +29276,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_public_workspace_documents_admin": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "0c7c5be24c7ef3f726e0f8cd75667b124bed98ba8570690901f7baae22303d90", "points": [ { "method": "read_item", @@ -29287,7 +29285,8 @@ } ], "queries": [], - "sha256": "0c7c5be24c7ef3f726e0f8cd75667b124bed98ba8570690901f7baae22303d90" + "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.", @@ -29298,8 +29297,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_delete_user_documents_admin": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "f3e138cded81bc0eb56dbeae783cfcea5e6240f9c66acf31bebd427ce965f30f", "points": [ { "method": "read_item", @@ -29308,7 +29306,8 @@ } ], "queries": [], - "sha256": "f3e138cded81bc0eb56dbeae783cfcea5e6240f9c66acf31bebd427ce965f30f" + "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.", @@ -29319,8 +29318,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_export_activity_logs": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "0c01054b08e472d162f861977bab1291dac624c04e99a4a595004531d97c295a", "points": [], "queries": [ { @@ -29329,7 +29327,8 @@ "response": "consumed" } ], - "sha256": "0c01054b08e472d162f861977bab1291dac624c04e99a4a595004531d97c295a" + "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.", @@ -29340,8 +29339,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_activity_logs": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "5d97c8a9db00355916061c4e7a2b02f6d190813878abaaa4e54564d5548ce3f5", "points": [], "queries": [ { @@ -29355,7 +29353,8 @@ "response": "consumed" } ], - "sha256": "5d97c8a9db00355916061c4e7a2b02f6d190813878abaaa4e54564d5548ce3f5" + "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.", @@ -29366,8 +29365,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_all_groups": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "db5a1800b1878ef7ffe96d60466bcae089e733dea0fa6bf71c0ce676e28150c4", "points": [], "queries": [ { @@ -29386,7 +29384,8 @@ "response": "consumed" } ], - "sha256": "db5a1800b1878ef7ffe96d60466bcae089e733dea0fa6bf71c0ce676e28150c4" + "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.", @@ -29397,8 +29396,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_all_users": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "7b089da10b9f50d8ce718a8b8a9246ec9d201182982532c25489ecb2fbf21531", "points": [], "queries": [ { @@ -29417,7 +29415,8 @@ "response": "consumed" } ], - "sha256": "7b089da10b9f50d8ce718a8b8a9246ec9d201182982532c25489ecb2fbf21531" + "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.", @@ -29428,8 +29427,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_group_details_admin": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "ace5a3e3953423f49745711e9848d926969f431f59c420d1beaf5e6cd2f72d9d", "points": [ { "method": "read_item", @@ -29438,7 +29436,8 @@ } ], "queries": [], - "sha256": "ace5a3e3953423f49745711e9848d926969f431f59c420d1beaf5e6cd2f72d9d" + "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.", @@ -29449,8 +29448,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_group_members_admin": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "2178cb5d3ca522efc8b51dd2a1041c848a57352392dbabf7c9afd9c8d2311666", "points": [ { "method": "read_item", @@ -29459,7 +29457,8 @@ } ], "queries": [], - "sha256": "2178cb5d3ca522efc8b51dd2a1041c848a57352392dbabf7c9afd9c8d2311666" + "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.", @@ -29470,8 +29469,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_activity": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "d22f652c8f1aeadc7fb1cd2e4f6e25fb05edfc48d2af83c98ce695d6ec22333b", "points": [], "queries": [ { @@ -29480,7 +29478,8 @@ "response": "consumed" } ], - "sha256": "d22f652c8f1aeadc7fb1cd2e4f6e25fb05edfc48d2af83c98ce695d6ec22333b" + "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.", @@ -29491,8 +29490,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_details": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "3ad7c153a87d1bb31ee0b7ee7ad9ef97d8a8c42e467401435faa473ee6afe5ec", "points": [ { "method": "read_item", @@ -29501,7 +29499,8 @@ } ], "queries": [], - "sha256": "3ad7c153a87d1bb31ee0b7ee7ad9ef97d8a8c42e467401435faa473ee6afe5ec" + "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.", @@ -29512,8 +29511,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_public_workspace_members": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "95321b44b8ac34e47bc18acfe1dc9d6ed03ba7ded4e280d7f43b682a397efe23", "points": [ { "method": "read_item", @@ -29532,7 +29530,8 @@ } ], "queries": [], - "sha256": "95321b44b8ac34e47bc18acfe1dc9d6ed03ba7ded4e280d7f43b682a397efe23" + "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.", @@ -29543,8 +29542,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_get_token_filter_options": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "4931b85731507d256754196b317189aaa18c299f3ccf7714f0b96ccc08a3c606", "points": [ { "method": "read_item", @@ -29563,7 +29561,8 @@ } ], "queries": [], - "sha256": "4931b85731507d256754196b317189aaa18c299f3ccf7714f0b96ccc08a3c606" + "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.", @@ -29574,8 +29573,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_refresh_control_center_data": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "7710a07eb7492e1d26caaeaffda928d3b72b5a9850c63605aac3a0eaf7c1cf73", "points": [], "queries": [ { @@ -29589,7 +29587,8 @@ "response": "consumed" } ], - "sha256": "7710a07eb7492e1d26caaeaffda928d3b72b5a9850c63605aac3a0eaf7c1cf73" + "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.", @@ -29600,8 +29599,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_update_public_workspace_ownership": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "2b714ae8d17eb3f9414f3d6b0e416945015d7e63492077fe4165a17f3aec993a", "points": [ { "method": "read_item", @@ -29615,7 +29613,8 @@ } ], "queries": [], - "sha256": "2b714ae8d17eb3f9414f3d6b0e416945015d7e63492077fe4165a17f3aec993a" + "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.", @@ -29626,8 +29625,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_update_public_workspace_status": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "773660a9082f9caf125d8985ddcca2166410cfcd4ba5032fe4f0a96b2758e0ad", "points": [ { "method": "read_item", @@ -29636,7 +29634,8 @@ } ], "queries": [], - "sha256": "773660a9082f9caf125d8985ddcca2166410cfcd4ba5032fe4f0a96b2758e0ad" + "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.", @@ -29647,8 +29646,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_dashboard_chat_readiness": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "5bb8f8e780644f95c0aa35b6f0bbf777b392fc839477589669bc8e360c266e68", "points": [], "queries": [ { @@ -29657,7 +29655,8 @@ "response": "consumed" } ], - "sha256": "5bb8f8e780644f95c0aa35b6f0bbf777b392fc839477589669bc8e360c266e68" + "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.", @@ -29668,8 +29667,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_group_detail": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "83e235ea1e198629c89936db011966c2a83ab8ecd75c2f64142d3d95a1682bec", "points": [ { "method": "read_item", @@ -29684,7 +29682,8 @@ "response": "consumed" } ], - "sha256": "83e235ea1e198629c89936db011966c2a83ab8ecd75c2f64142d3d95a1682bec" + "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.", @@ -29695,8 +29694,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_public_workspace_detail": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "23bce2a2e6b0b5e978288e25ecb684b7e2a4f019780a955052da381795c84263", "points": [ { "method": "read_item", @@ -29721,7 +29719,8 @@ "response": "consumed" } ], - "sha256": "23bce2a2e6b0b5e978288e25ecb684b7e2a4f019780a955052da381795c84263" + "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.", @@ -29732,8 +29731,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_user_detail": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "11dff4696a7335b87709786771eaa6333d22b0d7ecd498dd3415a9763108e41a", "points": [], "queries": [ { @@ -29762,7 +29760,8 @@ "response": "consumed" } ], - "sha256": "11dff4696a7335b87709786771eaa6333d22b0d7ecd498dd3415a9763108e41a" + "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.", @@ -29773,8 +29772,7 @@ }, "application/single_app/route_backend_control_center.py::register_route_backend_control_center.api_v2_control_center_users_bulk_action": { "boundary": { - "batches": [], - "module_sha256": "da3d3f21dc8c59492992d9f8a2a710ce152dcf7d71fc01b6206b20353c0b34a9", + "sha256": "091325d90b12a464000e5a7586637a9c725e41932513c7d7a966da3d5d502e65", "points": [], "queries": [ { @@ -29783,7 +29781,8 @@ "response": "consumed" } ], - "sha256": "091325d90b12a464000e5a7586637a9c725e41932513c7d7a966da3d5d502e65" + "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.", @@ -29794,8 +29793,7 @@ }, "application/single_app/route_backend_conversation_export.py::_load_export_message_for_user": { "boundary": { - "batches": [], - "module_sha256": "2e30964e61b6a82f3e20c8a97fa9101eea35d5f882a659a6332c4d01f112d27f", + "sha256": "46162520da41c8343e3f6198b672bd3617819e785bdcbe0cb5585780d7a8e780", "points": [ { "method": "read_item", @@ -29820,7 +29818,8 @@ "response": "consumed" } ], - "sha256": "46162520da41c8343e3f6198b672bd3617819e785bdcbe0cb5585780d7a8e780" + "batches": [], + "module_sha256": "2e30964e61b6a82f3e20c8a97fa9101eea35d5f882a659a6332c4d01f112d27f" }, "classification": "sdk-compatible", "contract": "The real message-export owner consumes SDK conversation/message point mappings, preserves message identity and ETag through public-history projection, enforces ownership, and carries the material evidence notice into rendered output.", @@ -29831,8 +29830,7 @@ }, "application/single_app/route_backend_conversation_export.py::_load_exportable_conversation_for_user": { "boundary": { - "batches": [], - "module_sha256": "2e30964e61b6a82f3e20c8a97fa9101eea35d5f882a659a6332c4d01f112d27f", + "sha256": "e08c883a197ed4fc6c2f48cff05b535ae6f0e0532550aefafa881dc087551ea2", "points": [ { "method": "read_item", @@ -29847,7 +29845,8 @@ "response": "consumed" } ], - "sha256": "e08c883a197ed4fc6c2f48cff05b535ae6f0e0532550aefafa881dc087551ea2" + "batches": [], + "module_sha256": "2e30964e61b6a82f3e20c8a97fa9101eea35d5f882a659a6332c4d01f112d27f" }, "classification": "sdk-compatible", "contract": "The real conversation-export owner accepts the SDK point mapping and its ETag, rejects a different owner, and queries ordinary JSON message rows in the conversation partition.", @@ -29858,8 +29857,7 @@ }, "application/single_app/route_backend_conversation_export.py::_load_generated_image_proposal_assets": { "boundary": { - "batches": [], - "module_sha256": "2e30964e61b6a82f3e20c8a97fa9101eea35d5f882a659a6332c4d01f112d27f", + "sha256": "c8f9210188ad8d8d0399324a91ab66c3fdf3aa15b6c3838527ef711a34e3e2f6", "points": [], "queries": [ { @@ -29868,7 +29866,8 @@ "response": "consumed" } ], - "sha256": "c8f9210188ad8d8d0399324a91ab66c3fdf3aa15b6c3838527ef711a34e3e2f6" + "batches": [], + "module_sha256": "2e30964e61b6a82f3e20c8a97fa9101eea35d5f882a659a6332c4d01f112d27f" }, "classification": "sdk-compatible", "contract": "The real image-export owner selects proposal metadata from plain query rows and reopens the SDK point mapping through the real image-content helper. Only the point record contains image bytes, preventing a failed SDK read from passing through the existing query-content fallback.", @@ -29879,8 +29878,7 @@ }, "application/single_app/route_backend_conversations.py::_authorize_personal_conversation_read": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "be12ad59bc41af0561996539729e975d73e0dd420cdf3b601b1b3e6feb30d179", "points": [ { "method": "read_item", @@ -29889,7 +29887,8 @@ } ], "queries": [], - "sha256": "be12ad59bc41af0561996539729e975d73e0dd420cdf3b601b1b3e6feb30d179" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -29901,8 +29900,7 @@ }, "application/single_app/route_backend_conversations.py::_collect_child_message_documents": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "f4046a3cf88c5c3362c3433d079685adb66b1c646d13947558ae38a38331bdba", "points": [], "queries": [ { @@ -29911,7 +29909,8 @@ "response": "consumed" } ], - "sha256": "f4046a3cf88c5c3362c3433d079685adb66b1c646d13947558ae38a38331bdba" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -29923,8 +29922,7 @@ }, "application/single_app/route_backend_conversations.py::_count_hidden_legacy_conversations": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "0b5aa104dbbe0cc2b29d3f8fca3ad15cae7018370a639811ccfc81be5c7e3564", "points": [], "queries": [ { @@ -29933,7 +29931,8 @@ "response": "consumed" } ], - "sha256": "0b5aa104dbbe0cc2b29d3f8fca3ad15cae7018370a639811ccfc81be5c7e3564" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -29945,8 +29944,7 @@ }, "application/single_app/route_backend_conversations.py::_list_personal_conversation_generated_documents": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "53bb11f366c937afb5e7c1e00e49fdc07656a8a04f6c78e35beb3fe61a68f53e", "points": [], "queries": [ { @@ -29955,7 +29953,8 @@ "response": "consumed" } ], - "sha256": "53bb11f366c937afb5e7c1e00e49fdc07656a8a04f6c78e35beb3fe61a68f53e" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -29967,8 +29966,7 @@ }, "application/single_app/route_backend_conversations.py::_load_scope_lock_conversation": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "1d77f8c14df18b5ef095f53d420e3f946390965f5f99b4cf3733b0542dfe3da6", "points": [ { "method": "read_item", @@ -29977,7 +29975,8 @@ } ], "queries": [], - "sha256": "1d77f8c14df18b5ef095f53d420e3f946390965f5f99b4cf3733b0542dfe3da6" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -29989,8 +29988,7 @@ }, "application/single_app/route_backend_conversations.py::_load_unread_collaboration_notification_map": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "e288840b85558b963b02fe8a08dd65cc6f57268680697f7ffbd924490d876761", "points": [], "queries": [ { @@ -29999,7 +29997,8 @@ "response": "consumed" } ], - "sha256": "e288840b85558b963b02fe8a08dd65cc6f57268680697f7ffbd924490d876761" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30011,8 +30010,7 @@ }, "application/single_app/route_backend_conversations.py::_persist_scope_lock_update": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "b6876aa15e2e5423b60e936b4d822543703c04107f5bc7c6346be78eaab8663c", "points": [ { "method": "upsert_item", @@ -30026,7 +30024,8 @@ } ], "queries": [], - "sha256": "b6876aa15e2e5423b60e936b4d822543703c04107f5bc7c6346be78eaab8663c" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30037,8 +30036,7 @@ }, "application/single_app/route_backend_conversations.py::_promote_remaining_thread_attempt": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "70567c02b3fe0d663bbd02e982c95a5f4a8bbf887dbbbad7a1679b603024bcb8", "points": [], "queries": [ { @@ -30047,7 +30045,8 @@ "response": "consumed" } ], - "sha256": "70567c02b3fe0d663bbd02e982c95a5f4a8bbf887dbbbad7a1679b603024bcb8" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30059,8 +30058,7 @@ }, "application/single_app/route_backend_conversations.py::_query_legacy_conversations_for_feed": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "fb26199a7007bb488fcd96a621dbb73d2cc37594401fda2f8524faa8ac1ac59d", "points": [], "queries": [ { @@ -30069,7 +30067,8 @@ "response": "consumed" } ], - "sha256": "fb26199a7007bb488fcd96a621dbb73d2cc37594401fda2f8524faa8ac1ac59d" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30081,8 +30080,7 @@ }, "application/single_app/route_backend_conversations.py::_query_matching_messages": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "d2f13ccdef1ed6b767cbda69558863f036b8619a867b0ed85b10b29d127cce10", "points": [], "queries": [ { @@ -30091,7 +30089,8 @@ "response": "consumed" } ], - "sha256": "d2f13ccdef1ed6b767cbda69558863f036b8619a867b0ed85b10b29d127cce10" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30103,8 +30102,7 @@ }, "application/single_app/route_backend_conversations.py::_rebuild_authorized_personal_conversation_used_documents": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "3f8096462f25be00b36db760102f1f43cf6d84f6ea971f5f5ad4b8950d6ded6e", "points": [ { "method": "upsert_item", @@ -30124,7 +30122,8 @@ "response": "consumed" } ], - "sha256": "3f8096462f25be00b36db760102f1f43cf6d84f6ea971f5f5ad4b8950d6ded6e" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30135,8 +30134,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.api_get_messages": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "1f1b9bc53d9c4dfd2cfab4b059192911c97df1c923c45fe2416c44a68d8384cb", "points": [], "queries": [ { @@ -30145,7 +30143,8 @@ "response": "consumed" } ], - "sha256": "1f1b9bc53d9c4dfd2cfab4b059192911c97df1c923c45fe2416c44a68d8384cb" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30157,8 +30156,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.bulk_hide_conversations": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "81f840e8f67daff73a3edd418243bb3936aeef3867a5ff9a7afdf68b786a66c7", "points": [ { "method": "read_item", @@ -30172,7 +30170,8 @@ } ], "queries": [], - "sha256": "81f840e8f67daff73a3edd418243bb3936aeef3867a5ff9a7afdf68b786a66c7" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30184,8 +30183,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.bulk_pin_conversations": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "f735878ca5ddc678867028375a8c7b03544cd8717c5ce26c8bc14f142a336902", "points": [ { "method": "read_item", @@ -30199,7 +30197,8 @@ } ], "queries": [], - "sha256": "f735878ca5ddc678867028375a8c7b03544cd8717c5ce26c8bc14f142a336902" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30211,8 +30210,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.delete_conversation": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "2813609bc34a1f69a760e0669062af2a3c50f4eb132920826af6ad2dab369fe5", "points": [ { "method": "upsert_item", @@ -30242,7 +30240,8 @@ "response": "consumed" } ], - "sha256": "2813609bc34a1f69a760e0669062af2a3c50f4eb132920826af6ad2dab369fe5" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30253,8 +30252,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.delete_message": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "368109d39acb0f8ed18b0977ffce318ab6c6fdea17ef7ec3775feb7d3d281e2a", "points": [ { "method": "read_item", @@ -30289,7 +30287,8 @@ "response": "consumed" } ], - "sha256": "368109d39acb0f8ed18b0977ffce318ab6c6fdea17ef7ec3775feb7d3d281e2a" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30301,8 +30300,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.delete_multiple_conversations": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "5fec3e5e02315179963be1e9629075ab9f14bcc494402628389eda532d51469e", "points": [ { "method": "upsert_item", @@ -30332,7 +30330,8 @@ "response": "consumed" } ], - "sha256": "5fec3e5e02315179963be1e9629075ab9f14bcc494402628389eda532d51469e" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30343,8 +30342,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.generate_conversation_summary_api": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "b43e1b99cd6bde701a4896e8eae5acbf0c41a22ab061f8386a559a75cbcefea3", "points": [], "queries": [ { @@ -30353,7 +30351,8 @@ "response": "consumed" } ], - "sha256": "b43e1b99cd6bde701a4896e8eae5acbf0c41a22ab061f8386a559a75cbcefea3" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30365,8 +30364,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversation_kind_api": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "247712a562dcc002276aab8ee155f16f30ee65346336de39ca1b1579bc3d776d", "points": [ { "method": "read_item", @@ -30375,7 +30373,8 @@ } ], "queries": [], - "sha256": "247712a562dcc002276aab8ee155f16f30ee65346336de39ca1b1579bc3d776d" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30387,8 +30386,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversation_metadata_api": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "132dd76467c6b53e568b146e4cbbaded407c7ec011ac5bf5c2fc4d8632b2f904", "points": [ { "method": "read_item", @@ -30402,7 +30400,8 @@ } ], "queries": [], - "sha256": "132dd76467c6b53e568b146e4cbbaded407c7ec011ac5bf5c2fc4d8632b2f904" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30414,8 +30413,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_conversations": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "aca58e63857de1251541bf6bcb0ab76f1a8bc805f237dd16e8c007bbda6f66f5", "points": [], "queries": [ { @@ -30424,7 +30422,8 @@ "response": "consumed" } ], - "sha256": "aca58e63857de1251541bf6bcb0ab76f1a8bc805f237dd16e8c007bbda6f66f5" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30436,8 +30435,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.get_user_classifications": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "578cc1a0435445dcd95b0222773a48876a86d435b96486302bcc5166ae332166", "points": [], "queries": [ { @@ -30446,7 +30444,8 @@ "response": "consumed" } ], - "sha256": "578cc1a0435445dcd95b0222773a48876a86d435b96486302bcc5166ae332166" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30458,8 +30457,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.mark_conversation_read_api": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "82808426ee5a477f72469abb7117c64380995ac78625e0ead9c19108a9b550de", "points": [ { "method": "read_item", @@ -30473,7 +30471,8 @@ } ], "queries": [], - "sha256": "82808426ee5a477f72469abb7117c64380995ac78625e0ead9c19108a9b550de" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30485,8 +30484,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.search_conversations": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "28a3a042791e03da653a93a96f2f4fa1da0eeec7c8bd1a53d484fefd7f50ad8f", "points": [], "queries": [ { @@ -30495,7 +30493,8 @@ "response": "consumed" } ], - "sha256": "28a3a042791e03da653a93a96f2f4fa1da0eeec7c8bd1a53d484fefd7f50ad8f" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30507,8 +30506,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.switch_attempt": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "e406e2cb9067349d8fd706e3fa29f192c93bd524c2b7cecf1115b557cffa21fe", "points": [ { "method": "read_item", @@ -30533,7 +30531,8 @@ "response": "consumed" } ], - "sha256": "e406e2cb9067349d8fd706e3fa29f192c93bd524c2b7cecf1115b557cffa21fe" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30545,8 +30544,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.toggle_conversation_hide": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "2fe5e3f4df4ba0f2ffb8eb2341c6dab33a9ea61b9248faaab32424753cc2f726", "points": [ { "method": "read_item", @@ -30560,7 +30558,8 @@ } ], "queries": [], - "sha256": "2fe5e3f4df4ba0f2ffb8eb2341c6dab33a9ea61b9248faaab32424753cc2f726" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30572,8 +30571,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.toggle_conversation_pin": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "9db586c9549d97f2f4ab431fc670f8a4498b883ce0b895bbf9aa287df40d7972", "points": [ { "method": "read_item", @@ -30587,7 +30585,8 @@ } ], "queries": [], - "sha256": "9db586c9549d97f2f4ab431fc670f8a4498b883ce0b895bbf9aa287df40d7972" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30599,8 +30598,7 @@ }, "application/single_app/route_backend_conversations.py::register_route_backend_conversations.update_conversation_title": { "boundary": { - "batches": [], - "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95", + "sha256": "b239c7ec5a4b20f20181461a3f8b1eedd97b38de518e40b93ce9cfa2df1cb77f", "points": [ { "method": "read_item", @@ -30614,7 +30612,8 @@ } ], "queries": [], - "sha256": "b239c7ec5a4b20f20181461a3f8b1eedd97b38de518e40b93ce9cfa2df1cb77f" + "batches": [], + "module_sha256": "51433ed93d3471ecfc203f8f4b18567672c272eeeb93a656996a142b2d258d95" }, "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. Credential interaction adds no new raw point consumer: the private owner normalizes its own SDK responses; existing ownership/Mapping reads and discarded write returns remain unchanged.", @@ -30626,8 +30625,7 @@ }, "application/single_app/route_backend_documents.py::_load_accessible_personal_documents": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "1b8ab218df53ceddbf4cc594a485b2ed0675048a1d9b3914570bf356047c3cf7", "points": [], "queries": [ { @@ -30636,7 +30634,8 @@ "response": "consumed" } ], - "sha256": "1b8ab218df53ceddbf4cc594a485b2ed0675048a1d9b3914570bf356047c3cf7" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "Fallback source discovery materializes plain query rows before current-revision selection; the access-index success path retains its owner-provided document list.", @@ -30647,8 +30646,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.api_approve_shared_document": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "4bb2f1afd8d86892e023fab521ca49c004cbffc09d62649b2f87e5e1e1427bdf", "points": [ { "method": "read_item", @@ -30662,7 +30660,8 @@ } ], "queries": [], - "sha256": "4bb2f1afd8d86892e023fab521ca49c004cbffc09d62649b2f87e5e1e1427bdf" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "The SDK document is field-read and mutated for sharing approval; upsert returns CosmosDict, accepted by isinstance(dict), and that persisted mapping with fresh ETag is passed to index synchronization. Browser JSON is projected separately.", @@ -30673,8 +30672,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.api_bulk_tag_documents": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "16ac2858c8f376d8e939223871f78d852508ae17beaf216a18cb8f589a163b9e", "points": [], "queries": [ { @@ -30683,7 +30681,8 @@ "response": "consumed" } ], - "sha256": "16ac2858c8f376d8e939223871f78d852508ae17beaf216a18cb8f589a163b9e" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "Bulk-tag source lookups consume plain query rows, check document ownership and pass selected ids to the document mutation owner; local discovery introduces no SDK point-to-strict conversion.", @@ -30694,8 +30693,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.api_delete_tag": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "21513f78dbbbe148e1488c3e2f519fabeb6ee99ff9e1b017fa4b4add0185c444", "points": [], "queries": [ { @@ -30704,7 +30702,8 @@ "response": "consumed" } ], - "sha256": "21513f78dbbbe148e1488c3e2f519fabeb6ee99ff9e1b017fa4b4add0185c444" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "Tag deletion iterates plain query rows and their tag lists before delegating mutations; query rows are not SDK point mappings.", @@ -30715,8 +30714,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.api_get_user_documents": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "4b966b59d4193a62acec8dd61dff181e7b2ccea0233b47e321e3e981a23916ca", "points": [], "queries": [ { @@ -30725,7 +30723,8 @@ "response": "consumed" } ], - "sha256": "4b966b59d4193a62acec8dd61dff181e7b2ccea0233b47e321e3e981a23916ca" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "The legacy count fallback consumes a scalar query result, while document/index listing projections remain with their existing owners; no point wrapper is treated as an exact plain document.", @@ -30736,8 +30735,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.api_remove_self_from_document": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "59885803bfcf17f747b6dee4854db92741fb70ac5ee017511f35b255f46a33ac", "points": [ { "method": "read_item", @@ -30746,7 +30744,8 @@ } ], "queries": [], - "sha256": "59885803bfcf17f747b6dee4854db92741fb70ac5ee017511f35b255f46a33ac" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "The SDK document supplies owner and sharing-list fields for removal checks before delegated mutation; no exact-dict domain admission occurs on the point value.", @@ -30757,8 +30756,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.api_share_document": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "7067173ad0f9cfbdf20eeb75b369420142ffaa8efef75ff508b4659ee2bbb8d9", "points": [ { "method": "read_item", @@ -30772,7 +30770,8 @@ } ], "queries": [], - "sha256": "7067173ad0f9cfbdf20eeb75b369420142ffaa8efef75ff508b4659ee2bbb8d9" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "The document CosmosDict supplies user_id and shared-user fields for owner authorization; the refreshed SDK mapping is passed to field-based notification projection, while sharing persistence remains with its document owner.", @@ -30783,8 +30782,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.api_unshare_document": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "2000ce0507df7351d7ec847bbeb9709f700913a71e9b4f31cd0f71f18643c842", "points": [ { "method": "read_item", @@ -30793,7 +30791,8 @@ } ], "queries": [], - "sha256": "2000ce0507df7351d7ec847bbeb9709f700913a71e9b4f31cd0f71f18643c842" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "The point document mapping is checked through user_id and shared-user fields before the document owner removes sharing; JSON responses contain explicit result fields, not the SDK wrapper.", @@ -30804,8 +30803,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.api_update_tag": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "7fde633c80ef35ececc9506b9136df550f535dc8262573740f3fc99eefeb32c1", "points": [], "queries": [ { @@ -30814,7 +30812,8 @@ "response": "consumed" } ], - "sha256": "7fde633c80ef35ececc9506b9136df550f535dc8262573740f3fc99eefeb32c1" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "Tag rename discovery consumes plain query dictionaries and field-based tag/owner values before existing document mutation calls.", @@ -30825,8 +30824,7 @@ }, "application/single_app/route_backend_documents.py::register_route_backend_documents.get_file_content": { "boundary": { - "batches": [], - "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1", + "sha256": "6a6043aca95406472412e9e235804f780b26b17ae5ad56aca3d5ec4b97f5cb8a", "points": [ { "method": "read_item", @@ -30841,7 +30839,8 @@ "response": "consumed" } ], - "sha256": "6a6043aca95406472412e9e235804f780b26b17ae5ad56aca3d5ec4b97f5cb8a" + "batches": [], + "module_sha256": "70ab9dc1019d5791b7f359a10cda466e6a3c76dc3b67d5625af50976a7e86eb1" }, "classification": "sdk-compatible", "contract": "The partitioned SDK conversation is checked through user_id before message discovery. File query rows stay plain, supply chunk/content fields and produce an explicit plain JSON content response.", @@ -30852,8 +30851,7 @@ }, "application/single_app/route_backend_feedback.py::_apply_feedback_review_update": { "boundary": { - "batches": [], - "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19", + "sha256": "e156509d5f230fbe1b15b31b0b6038785da681f5ee053fec28cc88c1d7c8d55c", "points": [ { "method": "read_item", @@ -30862,7 +30860,8 @@ } ], "queries": [], - "sha256": "e156509d5f230fbe1b15b31b0b6038785da681f5ee053fec28cc88c1d7c8d55c" + "batches": [], + "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19" }, "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.", @@ -30873,8 +30872,7 @@ }, "application/single_app/route_backend_feedback.py::_archive_feedback": { "boundary": { - "batches": [], - "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19", + "sha256": "4313ec95732eed92b206391a7ce3832c99d0db2da7df081b25b5fb1f0c853b85", "points": [ { "method": "read_item", @@ -30883,7 +30881,8 @@ } ], "queries": [], - "sha256": "4313ec95732eed92b206391a7ce3832c99d0db2da7df081b25b5fb1f0c853b85" + "batches": [], + "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19" }, "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.", @@ -30894,8 +30893,7 @@ }, "application/single_app/route_backend_feedback.py::_authorize_feedback_conversation": { "boundary": { - "batches": [], - "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19", + "sha256": "9dbd8ed7032992c75b9b4d3842a2f649f458bcb711c37c4a17fc247ed2523086", "points": [ { "method": "read_item", @@ -30904,7 +30902,8 @@ } ], "queries": [], - "sha256": "9dbd8ed7032992c75b9b4d3842a2f649f458bcb711c37c4a17fc247ed2523086" + "batches": [], + "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19" }, "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.", @@ -30915,8 +30914,7 @@ }, "application/single_app/route_backend_feedback.py::_delete_feedback": { "boundary": { - "batches": [], - "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19", + "sha256": "e0986f883c87644d0e16c0c12d81dee19fb0c8533b1f48393ceaf5d2492502cb", "points": [ { "method": "read_item", @@ -30935,7 +30933,8 @@ } ], "queries": [], - "sha256": "e0986f883c87644d0e16c0c12d81dee19fb0c8533b1f48393ceaf5d2492502cb" + "batches": [], + "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19" }, "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.", @@ -30946,8 +30945,7 @@ }, "application/single_app/route_backend_feedback.py::_query_feedback_items": { "boundary": { - "batches": [], - "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19", + "sha256": "64dfcec41f3fae8a5b0a16db1b971b64c702612ec5f39274abbfbce2c3b607bd", "points": [], "queries": [ { @@ -30956,7 +30954,8 @@ "response": "consumed" } ], - "sha256": "64dfcec41f3fae8a5b0a16db1b971b64c702612ec5f39274abbfbce2c3b607bd" + "batches": [], + "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19" }, "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.", @@ -30967,8 +30966,7 @@ }, "application/single_app/route_backend_feedback.py::register_route_backend_feedback.feedback_review_get_single": { "boundary": { - "batches": [], - "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19", + "sha256": "35eee73bbe46eca5d57026ce28e3c92225494846e73fa566a2dac6ba305ffeab", "points": [ { "method": "read_item", @@ -30977,7 +30975,8 @@ } ], "queries": [], - "sha256": "35eee73bbe46eca5d57026ce28e3c92225494846e73fa566a2dac6ba305ffeab" + "batches": [], + "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19" }, "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.", @@ -30988,8 +30987,7 @@ }, "application/single_app/route_backend_feedback.py::register_route_backend_feedback.feedback_submit": { "boundary": { - "batches": [], - "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19", + "sha256": "8fa906645aec09a8d1511a86169cb1fdc0549307a3d5e7a0f57bf6107e02eb81", "points": [ { "method": "upsert_item", @@ -31004,7 +31002,8 @@ "response": "consumed" } ], - "sha256": "8fa906645aec09a8d1511a86169cb1fdc0549307a3d5e7a0f57bf6107e02eb81" + "batches": [], + "module_sha256": "f1a4afb43c821bed42e672e36d9d74405e24d1cc2e4826f8508639e2f3dd6f19" }, "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.", @@ -31013,8 +31012,7 @@ }, "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_bulk_tag_group_documents": { "boundary": { - "batches": [], - "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32", + "sha256": "3e0a08f18cbb2e9b08536a05cbdf9af2a80e650080e9209c52d4ff392d341b06", "points": [], "queries": [ { @@ -31023,7 +31021,8 @@ "response": "consumed" } ], - "sha256": "3e0a08f18cbb2e9b08536a05cbdf9af2a80e650080e9209c52d4ff392d341b06" + "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.", @@ -31034,8 +31033,7 @@ }, "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_delete_group_document": { "boundary": { - "batches": [], - "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32", + "sha256": "0e7e3872316d496e2426c93072252bd077d9e17fc617ab5eef43e6cafc4159d4", "points": [], "queries": [ { @@ -31044,7 +31042,8 @@ "response": "consumed" } ], - "sha256": "0e7e3872316d496e2426c93072252bd077d9e17fc617ab5eef43e6cafc4159d4" + "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.", @@ -31055,8 +31054,7 @@ }, "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_delete_group_tag": { "boundary": { - "batches": [], - "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32", + "sha256": "1248b4c9a4fe15c566d86f9d66e02b71720812baa13e46a21241a33758c09a1d", "points": [], "queries": [ { @@ -31065,7 +31063,8 @@ "response": "consumed" } ], - "sha256": "1248b4c9a4fe15c566d86f9d66e02b71720812baa13e46a21241a33758c09a1d" + "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.", @@ -31076,8 +31075,7 @@ }, "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_get_group_documents": { "boundary": { - "batches": [], - "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32", + "sha256": "e99f47ec943a2e57f5a51981b3e826552fcae5e3a2bed8f1cd031ad0e263e19c", "points": [], "queries": [ { @@ -31091,7 +31089,8 @@ "response": "consumed" } ], - "sha256": "e99f47ec943a2e57f5a51981b3e826552fcae5e3a2bed8f1cd031ad0e263e19c" + "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.", @@ -31102,8 +31101,7 @@ }, "application/single_app/route_backend_group_documents.py::register_route_backend_group_documents.api_update_group_tag": { "boundary": { - "batches": [], - "module_sha256": "d3f94c579dc3ad9964ee0e19e185d6d82fd333a65d5b5cd3421a5964970e1a32", + "sha256": "0533cae1310aa8c2c5d9cea0ebb1de02b46045c69e492a06bad230a3fc670ee1", "points": [], "queries": [ { @@ -31112,7 +31110,8 @@ "response": "consumed" } ], - "sha256": "0533cae1310aa8c2c5d9cea0ebb1de02b46045c69e492a06bad230a3fc670ee1" + "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.", @@ -31123,8 +31122,7 @@ }, "application/single_app/route_backend_groups.py::register_route_backend_groups.api_group_activity": { "boundary": { - "batches": [], - "module_sha256": "61aec306156aa512829ee0809a429a7464ebecc3ba292ec567cd9a00a8b8d7e1", + "sha256": "17a8e6e356351c481d623b5901ec4130206c7382acb3a1b75ab598ae2855a9e7", "points": [], "queries": [ { @@ -31133,7 +31131,8 @@ "response": "consumed" } ], - "sha256": "17a8e6e356351c481d623b5901ec4130206c7382acb3a1b75ab598ae2855a9e7" + "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.", @@ -31144,8 +31143,7 @@ }, "application/single_app/route_backend_groups.py::register_route_backend_groups.api_group_stats": { "boundary": { - "batches": [], - "module_sha256": "61aec306156aa512829ee0809a429a7464ebecc3ba292ec567cd9a00a8b8d7e1", + "sha256": "588d93b9aa39400ff4bf53efc405ce70c31808339678e98f5dd04f1e2e6e2ccf", "points": [], "queries": [ { @@ -31169,7 +31167,8 @@ "response": "consumed" } ], - "sha256": "588d93b9aa39400ff4bf53efc405ce70c31808339678e98f5dd04f1e2e6e2ccf" + "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.", @@ -31180,8 +31179,7 @@ }, "application/single_app/route_backend_m365.py::_workflow_binding_summary": { "boundary": { - "batches": [], - "module_sha256": "ebe71cb7fc78a609d24be25ad5f66850f567d8739728bc8cf5b0df69ce9dd16b", + "sha256": "01654cea9d8defaf48328ad300d37b27aaee5dc9491144930d19009d0a71d2da", "points": [ { "method": "read_item", @@ -31190,7 +31188,8 @@ } ], "queries": [], - "sha256": "01654cea9d8defaf48328ad300d37b27aaee5dc9491144930d19009d0a71d2da" + "batches": [], + "module_sha256": "ebe71cb7fc78a609d24be25ad5f66850f567d8739728bc8cf5b0df69ce9dd16b" }, "classification": "sdk-compatible", "contract": "Access-checked personal/group SDK point responses are consumed only via Mapping.get; a new plain dictionary projects id, name and scope for jsonify. No raw workflow, strict domain validator, metadata or ETag crosses the response boundary.", @@ -31201,8 +31200,7 @@ }, "application/single_app/route_backend_m365.py::register_route_backend_m365.list_m365_waiting_requests": { "boundary": { - "batches": [], - "module_sha256": "ebe71cb7fc78a609d24be25ad5f66850f567d8739728bc8cf5b0df69ce9dd16b", + "sha256": "f6dba896e621b730b8610e92a02ba74103c98dccf549744fd8b7cb96d90c104a", "points": [], "queries": [ { @@ -31211,7 +31209,8 @@ "response": "consumed" } ], - "sha256": "f6dba896e621b730b8610e92a02ba74103c98dccf549744fd8b7cb96d90c104a" + "batches": [], + "module_sha256": "ebe71cb7fc78a609d24be25ad5f66850f567d8739728bc8cf5b0df69ce9dd16b" }, "classification": "sdk-compatible", "contract": "Unchanged partition-bound query consumes plain SDK JSON rows through jsonify, continuation and CSRF fields; dependency-light identifier imports introduce no strict point-response sink.", @@ -31222,8 +31221,7 @@ }, "application/single_app/route_backend_orchestration.py::_authorize_context_conversation": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "22acc754f250e1f43e216ac38a72d4f6f86940db24340fdb1a534d3848cb3ecc", "points": [ { "method": "read_item", @@ -31232,7 +31230,8 @@ } ], "queries": [], - "sha256": "22acc754f250e1f43e216ac38a72d4f6f86940db24340fdb1a534d3848cb3ecc" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "The conversation point mapping proves owner/nondeleted state through field access and now rechecks shared-source membership before dependent reads; missing or unauthorized records retain ConversationContextError.", @@ -31244,8 +31243,7 @@ }, "application/single_app/route_backend_orchestration.py::_checkpoint_artifact_versions": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "1c83df7e9294278003effafc350fa505ef60e47463b758e2ac25477e19f8e44a", "points": [ { "method": "read_item", @@ -31254,7 +31252,8 @@ } ], "queries": [], - "sha256": "1c83df7e9294278003effafc350fa505ef60e47463b758e2ac25477e19f8e44a" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Artifact point mappings are JSON-encoded by the existing checkpoint fingerprint helper; SDK dictionary subclasses are supported and nested artifact validation is unchanged.", @@ -31265,8 +31264,7 @@ }, "application/single_app/route_backend_orchestration.py::_conversation_context_for_run": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "285797ca8e6a453e9284bfdb04486f76457e63ae0e122b77b486487ca857db49", "points": [ { "method": "read_item", @@ -31275,7 +31273,8 @@ } ], "queries": [], - "sha256": "285797ca8e6a453e9284bfdb04486f76457e63ae0e122b77b486487ca857db49" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "The saved turn point mapping is normalized by normalize_history_message before role/conversation/fingerprint validation; history-disabled snapshots fail before reuse and source authorization is rechecked.", @@ -31287,8 +31286,7 @@ }, "application/single_app/route_backend_orchestration.py::_ensure_conversation": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "16e2e62456a9d1d728e0985459f8625413e0d4c5a8a08d19b36f506ce01ef06f", "points": [ { "method": "read_item", @@ -31307,7 +31305,8 @@ } ], "queries": [], - "sha256": "16e2e62456a9d1d728e0985459f8625413e0d4c5a8a08d19b36f506ce01ef06f" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Requested conversation point mappings supply owner/scope/deletion fields; constructed create/upsert bodies are plain and write responses are discarded. Shared ownership is established separately, not inferred from wrapper type.", @@ -31318,8 +31317,7 @@ }, "application/single_app/route_backend_orchestration.py::_link_regeneration_thread": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "d679a3d90d078defe9de7faaae37dde08f24433e8b7311987a0a07be7802deb8", "points": [ { "method": "read_item", @@ -31328,7 +31326,8 @@ } ], "queries": [], - "sha256": "d679a3d90d078defe9de7faaae37dde08f24433e8b7311987a0a07be7802deb8" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Point answer mappings supply conversation/visibility and nested thread fields; metadata patching retains its existing owner and stale or missing answers are not silently restored.", @@ -31339,8 +31338,7 @@ }, "application/single_app/route_backend_orchestration.py::_load_conversation_snapshot": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "1b4d30f5e09b77e861bd836b0be885ac7e122285dfd6aa68d34417b971863a5c", "points": [ { "method": "read_item", @@ -31355,7 +31353,8 @@ "response": "consumed" } ], - "sha256": "1b4d30f5e09b77e861bd836b0be885ac7e122285dfd6aa68d34417b971863a5c" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "A cutoff point mapping supplies authorized conversation/role/timestamp; plain bounded query rows pass through screening and saved-analysis sanitization before plain snapshot construction.", @@ -31366,8 +31365,7 @@ }, "application/single_app/route_backend_orchestration.py::_load_ledger": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "b5dc08f80aa6ad83c0e2d1d7c1f4e3338cb90b939facde5ffa8b9fc40ebb969f", "points": [], "queries": [ { @@ -31376,7 +31374,8 @@ "response": "consumed" } ], - "sha256": "b5dc08f80aa6ad83c0e2d1d7c1f4e3338cb90b939facde5ffa8b9fc40ebb969f" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Ledger source revalidation consumes plain projected query rows to check source visibility; failed reads omit the ledger rather than authorizing point documents or widening scope.", @@ -31387,8 +31386,7 @@ }, "application/single_app/route_backend_orchestration.py::_load_regeneration_snapshot": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "5637554bb021fcd62df90f70c98e9e6e33cc15489898e46f2df2ed1203a80c45", "points": [], "queries": [ { @@ -31397,7 +31395,8 @@ "response": "consumed" } ], - "sha256": "5637554bb021fcd62df90f70c98e9e6e33cc15489898e46f2df2ed1203a80c45" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Historical context discovery consumes plain partitioned query rows, applies retry-prefix/screening rules and builds a bounded plain conversation snapshot.", @@ -31408,8 +31407,7 @@ }, "application/single_app/route_backend_orchestration.py::_mirror_planned_turn": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "8615966a67ce45b07978a6c1bef586a4929ecaada317f7d63b94829c1fc302b4", "points": [ { "method": "read_item", @@ -31423,7 +31421,8 @@ } ], "queries": [], - "sha256": "8615966a67ce45b07978a6c1bef586a4929ecaada317f7d63b94829c1fc302b4" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Conversation/message point mappings feed shared-backing ownership checks and Mapping-compatible collaboration mirroring; no strict task/result descriptor consumes the wrappers.", @@ -31434,8 +31433,7 @@ }, "application/single_app/route_backend_orchestration.py::_persist_planned_turn": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "0ee1e0c7657944a1819faffbbb32aeff018ed19408c9a4e443e6aea195af0138", "points": [ { "method": "read_item", @@ -31444,7 +31442,8 @@ } ], "queries": [], - "sha256": "0ee1e0c7657944a1819faffbbb32aeff018ed19408c9a4e443e6aea195af0138" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "The saved question point mapping updates nested orchestration metadata through the existing metadata-patch owner; durable returned planning identity is a separate plain scoped DTO.", @@ -31455,8 +31454,7 @@ }, "application/single_app/route_backend_orchestration.py::_run_response_removed": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "7abf6197e4f767ff81c376db34ae031cb104e4d275e5ac078621113362fcbaba", "points": [ { "method": "read_item", @@ -31465,7 +31463,8 @@ } ], "queries": [], - "sha256": "7abf6197e4f767ff81c376db34ae031cb104e4d275e5ac078621113362fcbaba" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "The assistant point mapping supplies role/deletion/mask metadata to reply_is_retracted; absence is treated as removed, never as an empty valid response.", @@ -31476,8 +31475,7 @@ }, "application/single_app/route_backend_orchestration.py::_save_message": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "a8e211f24561985c44a87b387ee773a243a5e36e48bd1d58bfcad00a24c861a6", "points": [ { "method": "upsert_item", @@ -31486,7 +31484,8 @@ } ], "queries": [], - "sha256": "a8e211f24561985c44a87b387ee773a243a5e36e48bd1d58bfcad00a24c861a6" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "response-unused", "contract": "The message upsert response is discarded; screening and source-availability checks occur before publication, and persistence errors retain the existing failure path.", @@ -31495,8 +31494,7 @@ }, "application/single_app/route_backend_orchestration.py::_save_turn_message": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "b05e8634d174ceba3cdee9fbdd21ad0ef4b8864a7a572aae0795b6a64578e257", "points": [ { "method": "read_item", @@ -31510,7 +31508,8 @@ } ], "queries": [], - "sha256": "b05e8634d174ceba3cdee9fbdd21ad0ef4b8864a7a572aae0795b6a64578e257" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Saved turn point mappings are converted through normalize_history_message before identity/fingerprint reuse; nested metadata patches retain conditional ownership, and the returned identity/fingerprint are scalar projections.", @@ -31521,8 +31520,7 @@ }, "application/single_app/route_backend_orchestration.py::_touch_conversation": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "99d4c36c67f84cce3003b1743cd74df2a0c457539fd6f0e4d185db2bd3ce140c", "points": [ { "method": "read_item", @@ -31536,7 +31534,8 @@ } ], "queries": [], - "sha256": "99d4c36c67f84cce3003b1743cd74df2a0c457539fd6f0e4d185db2bd3ce140c" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "The conversation point mapping supplies owner/deletion and mutable index fields; replace response is discarded and the Mapping-compatible cache invalidator consumes the authorized input.", @@ -31547,8 +31546,7 @@ }, "application/single_app/route_backend_orchestration.py::_validate_checkpoint_artifacts": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "d93f00edfdb22533b2e2b578313d4cee8da2ace69d7ffca425ed4332425b2366", "points": [ { "method": "read_item", @@ -31557,7 +31555,8 @@ } ], "queries": [], - "sha256": "d93f00edfdb22533b2e2b578313d4cee8da2ace69d7ffca425ed4332425b2366" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Artifact point mappings are checked by field access for conversation/user/visibility and nested content metadata; no top-level exact-dictionary result contract consumes them.", @@ -31568,8 +31567,7 @@ }, "application/single_app/route_backend_orchestration.py::_validate_saved_conversation_context": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "3afd2be38d4155c2b68890b3e5e6ba79339d9aa43b23dbbdb9674de36cdc642e", "points": [], "queries": [ { @@ -31578,7 +31576,8 @@ "response": "consumed" } ], - "sha256": "3afd2be38d4155c2b68890b3e5e6ba79339d9aa43b23dbbdb9674de36cdc642e" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Source revalidation consumes plain bounded query rows through screening and strict saved-snapshot checks; no point wrapper is repaired into a domain context. Selected-history projection uses plain SDK query rows, existing visibility/fingerprint checks and admitted typed result references; new full-text projection and assistant-only result selection are exercised through real planning, execution and editor routes with SDK-default containers.", @@ -31590,8 +31589,7 @@ }, "application/single_app/route_backend_orchestration.py::register_route_backend_orchestration.orchestration_plan": { "boundary": { - "batches": [], - "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6", + "sha256": "29a1e31ee65d239f9ded08e3cf8d8621d32b412f8f41fd579c437c689453a33c", "points": [ { "method": "read_item", @@ -31600,7 +31598,8 @@ } ], "queries": [], - "sha256": "29a1e31ee65d239f9ded08e3cf8d8621d32b412f8f41fd579c437c689453a33c" + "batches": [], + "module_sha256": "b03415829b6ed1a63ee63ee31dc2fee94ff435af2534dbca651cd5e09541b1d6" }, "classification": "sdk-compatible", "contract": "Clarification admission consumes SDK conversation ownership fields. Selected-source preparation uses current authorized manifest DTOs before resolution; only bounded plain identity/schema projections enter model context. Only source revision hashes persist in seeds. Point wrappers never enter strict planner contracts, and approval precedes computation/export. Selected-history projection uses plain SDK query rows, existing visibility/fingerprint checks and admitted typed result references; new full-text projection and assistant-only result selection are exercised through real planning, execution and editor routes with SDK-default containers.", @@ -31608,15 +31607,14 @@ "tests": [ "functional_tests/test_orchestration_conversation_context_routes.py", "functional_tests/test_orchestration_conversation_sources.py", + "functional_tests/test_orchestration_followup_citation_provenance.py", "functional_tests/test_orchestration_request_memory_resolution.py", - "functional_tests/test_orchestration_selected_source_planning.py", - "functional_tests/test_orchestration_followup_citation_provenance.py" + "functional_tests/test_orchestration_selected_source_planning.py" ] }, "application/single_app/route_backend_plugins.py::edit_plugin": { "boundary": { - "batches": [], - "module_sha256": "aab8729bff9939c921a5597b0576c83fe398dc09063f4337a3a3d77f0a946b36", + "sha256": "33d4fff6f75f78a7b47db4aab6feac61be6aa97534c858376aee87a74509195c", "points": [ { "method": "read_item", @@ -31625,21 +31623,21 @@ } ], "queries": [], - "sha256": "33d4fff6f75f78a7b47db4aab6feac61be6aa97534c858376aee87a74509195c" + "batches": [], + "module_sha256": "aab8729bff9939c921a5597b0576c83fe398dc09063f4337a3a3d77f0a946b36" }, "classification": "sdk-compatible", "contract": "The unchanged route passes the exact scoped point read to validate_legacy_action_update, which accepts dictionary subclasses and reads fields without strict JSON copying. Runtime coverage uses installed CosmosDict via the shared SDK-default container, preserves ID and ETag, and rejects a missing exact ID or mismatched route name before the repository writer.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_route_cosmos_response_contract.py::test_action_route_point_reads_reach_real_legacy_validator_as_sdk_documents", "functional_tests/test_action_route_cosmos_response_contract.py::test_action_route_missing_exact_point_read_cannot_fall_back_to_a_name", + "functional_tests/test_action_route_cosmos_response_contract.py::test_action_route_point_reads_reach_real_legacy_validator_as_sdk_documents", "functional_tests/test_plugin_routes_cosmos_contract.py::test_global_legacy_update_consumes_sdk_point_response" ] }, "application/single_app/route_backend_plugins.py::set_user_plugins": { "boundary": { - "batches": [], - "module_sha256": "aab8729bff9939c921a5597b0576c83fe398dc09063f4337a3a3d77f0a946b36", + "sha256": "2a84bcceb1cea62cb4c5e3c20803005f63a499e4def57c408eef93e1e8e04aa9", "points": [ { "method": "read_item", @@ -31648,21 +31646,21 @@ } ], "queries": [], - "sha256": "2a84bcceb1cea62cb4c5e3c20803005f63a499e4def57c408eef93e1e8e04aa9" + "batches": [], + "module_sha256": "aab8729bff9939c921a5597b0576c83fe398dc09063f4337a3a3d77f0a946b36" }, "classification": "sdk-compatible", "contract": "The unchanged classic collection-save branch passes its actor-partitioned point read to the real legacy-update validator. Installed CosmosDict fields and ETag reach that mapping-compatible validator unchanged; a missing or foreign exact point ID cannot fall back to a same-name action or invoke a writer. Editor creation remains a separate repository-owned path.", "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_action_route_cosmos_response_contract.py::test_action_route_point_reads_reach_real_legacy_validator_as_sdk_documents", "functional_tests/test_action_route_cosmos_response_contract.py::test_action_route_missing_exact_point_read_cannot_fall_back_to_a_name", + "functional_tests/test_action_route_cosmos_response_contract.py::test_action_route_point_reads_reach_real_legacy_validator_as_sdk_documents", "functional_tests/test_plugin_routes_cosmos_contract.py::test_personal_legacy_update_consumes_sdk_point_response" ] }, "application/single_app/route_backend_plugins.py::test_cosmos_connection": { "boundary": { - "batches": [], - "module_sha256": "aab8729bff9939c921a5597b0576c83fe398dc09063f4337a3a3d77f0a946b36", + "sha256": "b0a291494272cabf99d1c4e6c442e397453712b28ad1434291b0192fe717120e", "points": [], "queries": [ { @@ -31671,7 +31669,8 @@ "response": "consumed" } ], - "sha256": "b0a291494272cabf99d1c4e6c442e397453712b28ad1434291b0192fe717120e" + "batches": [], + "module_sha256": "aab8729bff9939c921a5597b0576c83fe398dc09063f4337a3a3d77f0a946b36" }, "classification": "response-unused", "contract": "The unchanged Cosmos connection probe drains SELECT TOP 1 VALUE c.id only to establish query permission; empty and scalar query rows are discarded, never copied into a strict document/domain contract. Database/container metadata reads are likewise ignored. Runtime coverage verifies query draining, exact query shape, configured client routing, and lazy request-charge response-hook headers.", @@ -31683,8 +31682,7 @@ }, "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_bulk_tag_public_documents": { "boundary": { - "batches": [], - "module_sha256": "a2bf99eb92b95df4c2354418f8a74ed802a9fd6803626620b39c965880b2e230", + "sha256": "f249322bafabb8d42f9ccbeb547e88706a05abc995d4e1a432ddd605d3f3389e", "points": [], "queries": [ { @@ -31693,7 +31691,8 @@ "response": "consumed" } ], - "sha256": "f249322bafabb8d42f9ccbeb547e88706a05abc995d4e1a432ddd605d3f3389e" + "batches": [], + "module_sha256": "a2bf99eb92b95df4c2354418f8a74ed802a9fd6803626620b39c965880b2e230" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation.", @@ -31704,8 +31703,7 @@ }, "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_delete_public_workspace_tag": { "boundary": { - "batches": [], - "module_sha256": "a2bf99eb92b95df4c2354418f8a74ed802a9fd6803626620b39c965880b2e230", + "sha256": "2bff3efcff5f56ca7b67d487b9a9d18e8056e1dd5b2236972454679813649a2b", "points": [], "queries": [ { @@ -31714,7 +31712,8 @@ "response": "consumed" } ], - "sha256": "2bff3efcff5f56ca7b67d487b9a9d18e8056e1dd5b2236972454679813649a2b" + "batches": [], + "module_sha256": "a2bf99eb92b95df4c2354418f8a74ed802a9fd6803626620b39c965880b2e230" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation.", @@ -31725,8 +31724,7 @@ }, "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_list_public_documents": { "boundary": { - "batches": [], - "module_sha256": "a2bf99eb92b95df4c2354418f8a74ed802a9fd6803626620b39c965880b2e230", + "sha256": "fbf09f53a8f547cd40b065005d298f4353317a2e92fba76a71ee89b3d51d9856", "points": [], "queries": [ { @@ -31735,7 +31733,8 @@ "response": "consumed" } ], - "sha256": "fbf09f53a8f547cd40b065005d298f4353317a2e92fba76a71ee89b3d51d9856" + "batches": [], + "module_sha256": "a2bf99eb92b95df4c2354418f8a74ed802a9fd6803626620b39c965880b2e230" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation.", @@ -31746,8 +31745,7 @@ }, "application/single_app/route_backend_public_documents.py::register_route_backend_public_documents.api_update_public_workspace_tag": { "boundary": { - "batches": [], - "module_sha256": "a2bf99eb92b95df4c2354418f8a74ed802a9fd6803626620b39c965880b2e230", + "sha256": "61b6e308b6c2ab845e073e1586db3111ad1e4f33118f620377df4567aa02bb7a", "points": [], "queries": [ { @@ -31756,7 +31754,8 @@ "response": "consumed" } ], - "sha256": "61b6e308b6c2ab845e073e1586db3111ad1e4f33118f620377df4567aa02bb7a" + "batches": [], + "module_sha256": "a2bf99eb92b95df4c2354418f8a74ed802a9fd6803626620b39c965880b2e230" }, "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. Workspace outcome review: existing mapping/query consumers and conditional write contracts are retained; representative module runtime behavior is covered with installed-SDK point responses, including ETags and scope propagation.", @@ -31767,8 +31766,7 @@ }, "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_file_count": { "boundary": { - "batches": [], - "module_sha256": "404eee415b651fe67730b93f997bd06631f3fb77fb66ef591c03aa90ddb52f93", + "sha256": "4fa3852d575f78037fa5a5225f6bd05e8b0aea2d75b60e19102c1627647bfbda", "points": [], "queries": [ { @@ -31777,7 +31775,8 @@ "response": "consumed" } ], - "sha256": "4fa3852d575f78037fa5a5225f6bd05e8b0aea2d75b60e19102c1627647bfbda" + "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.", @@ -31788,8 +31787,7 @@ }, "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_workspace_activity": { "boundary": { - "batches": [], - "module_sha256": "404eee415b651fe67730b93f997bd06631f3fb77fb66ef591c03aa90ddb52f93", + "sha256": "c3330120ec3b557e8ceee5586164f4782ef4dbdeeeeaba6bcc7c3e2758d3edbb", "points": [], "queries": [ { @@ -31798,7 +31796,8 @@ "response": "consumed" } ], - "sha256": "c3330120ec3b557e8ceee5586164f4782ef4dbdeeeeaba6bcc7c3e2758d3edbb" + "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.", @@ -31809,8 +31808,7 @@ }, "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.api_public_workspace_stats": { "boundary": { - "batches": [], - "module_sha256": "404eee415b651fe67730b93f997bd06631f3fb77fb66ef591c03aa90ddb52f93", + "sha256": "3239a9fd163d67457eb170e75defabad0cf3cc83ee67fce93f345a1f9d8ec047", "points": [], "queries": [ { @@ -31834,7 +31832,8 @@ "response": "consumed" } ], - "sha256": "3239a9fd163d67457eb170e75defabad0cf3cc83ee67fce93f345a1f9d8ec047" + "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.", @@ -31845,8 +31844,7 @@ }, "application/single_app/route_backend_public_workspaces.py::register_route_backend_public_workspaces.discover_public_workspaces": { "boundary": { - "batches": [], - "module_sha256": "404eee415b651fe67730b93f997bd06631f3fb77fb66ef591c03aa90ddb52f93", + "sha256": "2abceccfe7a0f037b270aa76701310dabe02f29eed95df7db7bf37393feb6943", "points": [], "queries": [ { @@ -31855,7 +31853,8 @@ "response": "consumed" } ], - "sha256": "2abceccfe7a0f037b270aa76701310dabe02f29eed95df7db7bf37393feb6943" + "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.", @@ -31866,8 +31865,7 @@ }, "application/single_app/route_backend_retention_policy.py::register_route_backend_retention_policy.force_push_retention_defaults": { "boundary": { - "batches": [], - "module_sha256": "84c1e0e08f5f1444aa7732a6fa7881d4f10ea5d395fe1ff8037934afe3186bb2", + "sha256": "f3544c3dcd4e073acae0b0ff24171b087eed9386cb1eeec1f1b5af5a01033a23", "points": [ { "method": "upsert_item", @@ -31876,7 +31874,8 @@ } ], "queries": [], - "sha256": "f3544c3dcd4e073acae0b0ff24171b087eed9386cb1eeec1f1b5af5a01033a23" + "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.", @@ -31885,8 +31884,7 @@ }, "application/single_app/route_backend_safety.py::_archive_safety_log": { "boundary": { - "batches": [], - "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b", + "sha256": "12fa884b14e45b504a65a05265cc26eaeb126a1e52be7105c5922da70d307214", "points": [ { "method": "read_item", @@ -31895,7 +31893,8 @@ } ], "queries": [], - "sha256": "12fa884b14e45b504a65a05265cc26eaeb126a1e52be7105c5922da70d307214" + "batches": [], + "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b" }, "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.", @@ -31906,8 +31905,7 @@ }, "application/single_app/route_backend_safety.py::_count_other_user_violations": { "boundary": { - "batches": [], - "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b", + "sha256": "4088baedc2b9295f883447368c52deff91311d68fee52ee633005a7bd32e7734", "points": [], "queries": [ { @@ -31916,7 +31914,8 @@ "response": "consumed" } ], - "sha256": "4088baedc2b9295f883447368c52deff91311d68fee52ee633005a7bd32e7734" + "batches": [], + "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b" }, "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.", @@ -31927,8 +31926,7 @@ }, "application/single_app/route_backend_safety.py::_delete_safety_log": { "boundary": { - "batches": [], - "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b", + "sha256": "6358cae95552fa159f8f1fa17cb9db22d2404533e67f12ff62a0440d9899267a", "points": [ { "method": "read_item", @@ -31947,7 +31945,8 @@ } ], "queries": [], - "sha256": "6358cae95552fa159f8f1fa17cb9db22d2404533e67f12ff62a0440d9899267a" + "batches": [], + "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b" }, "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.", @@ -31958,8 +31957,7 @@ }, "application/single_app/route_backend_safety.py::_query_safety_logs": { "boundary": { - "batches": [], - "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b", + "sha256": "1d4b299809c1fa558e3854ba54230cda5f6370b46aa7197372cc6c4ceff21f42", "points": [], "queries": [ { @@ -31968,7 +31966,8 @@ "response": "consumed" } ], - "sha256": "1d4b299809c1fa558e3854ba54230cda5f6370b46aa7197372cc6c4ceff21f42" + "batches": [], + "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b" }, "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.", @@ -31979,8 +31978,7 @@ }, "application/single_app/route_backend_safety.py::register_route_backend_safety.apply_safety_review_update": { "boundary": { - "batches": [], - "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b", + "sha256": "98c3a4551b5f56ee37dc6b9f6ada179e0fff459094b883df4e797b2beece9e6b", "points": [ { "method": "read_item", @@ -31989,7 +31987,8 @@ } ], "queries": [], - "sha256": "98c3a4551b5f56ee37dc6b9f6ada179e0fff459094b883df4e797b2beece9e6b" + "batches": [], + "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b" }, "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.", @@ -32000,8 +31999,7 @@ }, "application/single_app/route_backend_safety.py::register_route_backend_safety.get_safety_log": { "boundary": { - "batches": [], - "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b", + "sha256": "a1a8c7ca1d2853c42692e197c5dc54b9e973460c7248b21481165833e7615f80", "points": [ { "method": "read_item", @@ -32010,7 +32008,8 @@ } ], "queries": [], - "sha256": "a1a8c7ca1d2853c42692e197c5dc54b9e973460c7248b21481165833e7615f80" + "batches": [], + "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b" }, "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.", @@ -32021,8 +32020,7 @@ }, "application/single_app/route_backend_safety.py::register_route_backend_safety.update_my_safety_log": { "boundary": { - "batches": [], - "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b", + "sha256": "9ddee90c4aeca29b679b39363ff339bf57a3c594b0c02491a6b3a6f9b1a3327d", "points": [ { "method": "read_item", @@ -32031,7 +32029,8 @@ } ], "queries": [], - "sha256": "9ddee90c4aeca29b679b39363ff339bf57a3c594b0c02491a6b3a6f9b1a3327d" + "batches": [], + "module_sha256": "b20e28bedcf170fa0a4ba99464fcde7cb6c9b6140b6550a5fcb89b4e77fc842b" }, "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.", @@ -32042,8 +32041,7 @@ }, "application/single_app/route_backend_users.py::_has_collaboration_profile_relationship": { "boundary": { - "batches": [], - "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3", + "sha256": "7eb60bbca933fed959e0f812a220727b924946eaf355b9da9147aa8dac19479e", "points": [ { "method": "read_item", @@ -32058,7 +32056,8 @@ "response": "consumed" } ], - "sha256": "7eb60bbca933fed959e0f812a220727b924946eaf355b9da9147aa8dac19479e" + "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.", @@ -32069,8 +32068,7 @@ }, "application/single_app/route_backend_users.py::_has_shared_document_profile_relationship": { "boundary": { - "batches": [], - "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3", + "sha256": "2ce3fc862935814ebf6d1d0028cdeec20fb1ad7ff90a4f47550e4160de492e26", "points": [], "queries": [ { @@ -32079,7 +32077,8 @@ "response": "consumed" } ], - "sha256": "2ce3fc862935814ebf6d1d0028cdeec20fb1ad7ff90a4f47550e4160de492e26" + "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.", @@ -32090,8 +32089,7 @@ }, "application/single_app/route_backend_users.py::_read_authorized_user_profile_document": { "boundary": { - "batches": [], - "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3", + "sha256": "201caf9181199545783634b7f638fc3efeacdd9e8f07d408c902b8595f86bb38", "points": [ { "method": "read_item", @@ -32100,7 +32098,8 @@ } ], "queries": [], - "sha256": "201caf9181199545783634b7f638fc3efeacdd9e8f07d408c902b8595f86bb38" + "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.", @@ -32111,8 +32110,7 @@ }, "application/single_app/route_backend_users.py::register_route_backend_users.api_collaboration_suggestions": { "boundary": { - "batches": [], - "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3", + "sha256": "73abc50267e15ec0134f0862538bafa5ee4ca7ea8f04769443700f81da89d2d8", "points": [], "queries": [ { @@ -32121,7 +32119,8 @@ "response": "consumed" } ], - "sha256": "73abc50267e15ec0134f0862538bafa5ee4ca7ea8f04769443700f81da89d2d8" + "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.", @@ -32132,8 +32131,7 @@ }, "application/single_app/route_backend_users.py::register_route_backend_users.api_get_user_info": { "boundary": { - "batches": [], - "module_sha256": "4f739bc686071e378fb31b3d51beb0c1950f410eecdd47c1bc5c940e6cb610b3", + "sha256": "b6027682ae3b7b3b8c0ffdda269ea18f19e2ed46c8b0dad51ea5f89d52a1c8e0", "points": [ { "method": "read_item", @@ -32142,7 +32140,8 @@ } ], "queries": [], - "sha256": "b6027682ae3b7b3b8c0ffdda269ea18f19e2ed46c8b0dad51ea5f89d52a1c8e0" + "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.", @@ -32153,8 +32152,7 @@ }, "application/single_app/route_backend_workflows.py::_load_group_workflow_conversation": { "boundary": { - "batches": [], - "module_sha256": "266860da0dcacb22b594d1df6ffdefb91bacc63002d6de86fafc27f7ec473df4", + "sha256": "49dd50eb7edc99ff086cd515db6c7d79d97fcf7a959286a93ee33098e1c4d8dd", "points": [ { "method": "read_item", @@ -32163,7 +32161,8 @@ } ], "queries": [], - "sha256": "49dd50eb7edc99ff086cd515db6c7d79d97fcf7a959286a93ee33098e1c4d8dd" + "batches": [], + "module_sha256": "266860da0dcacb22b594d1df6ffdefb91bacc63002d6de86fafc27f7ec473df4" }, "classification": "sdk-compatible", "contract": "SDK conversation Mapping is checked through get for workflow chat type and normalized owning-group authorization, then items projects a metadata-free ordinary dictionary.", @@ -32174,8 +32173,7 @@ }, "application/single_app/route_backend_workflows.py::_load_workflow_conversation": { "boundary": { - "batches": [], - "module_sha256": "266860da0dcacb22b594d1df6ffdefb91bacc63002d6de86fafc27f7ec473df4", + "sha256": "6fb2ae3c4ba3ab91130c34c22411394e28ce70753efca09f3946334181d4bcfb", "points": [ { "method": "read_item", @@ -32184,7 +32182,8 @@ } ], "queries": [], - "sha256": "6fb2ae3c4ba3ab91130c34c22411394e28ce70753efca09f3946334181d4bcfb" + "batches": [], + "module_sha256": "266860da0dcacb22b594d1df6ffdefb91bacc63002d6de86fafc27f7ec473df4" }, "classification": "sdk-compatible", "contract": "SDK conversation Mapping is checked through get for personal owner and workflow chat type, then items projects a metadata-free ordinary dictionary; foreign owners are rejected.", @@ -32195,8 +32194,7 @@ }, "application/single_app/route_enhanced_citations.py::_get_authorized_chat_artifact_message": { "boundary": { - "batches": [], - "module_sha256": "49f426f48b0bba2b70834692911b667acb32888ba62e853e045cbe956e9af0ea", + "sha256": "a2c6beb6142f515b82306165e8d8001995a4fad0f7a776d9f1d43c70c84c7614", "points": [ { "method": "read_item", @@ -32210,10 +32208,11 @@ } ], "queries": [], - "sha256": "a2c6beb6142f515b82306165e8d8001995a4fad0f7a776d9f1d43c70c84c7614" + "batches": [], + "module_sha256": "bd86121e79c23e9b2456f10562a58f84d6d91b4ec6a3f0f4147fd401d22a5820" }, "classification": "sdk-compatible", - "contract": "Partitioned SDK conversation/message mappings feed participation, generated-artifact, publication and optional workspace screening checks through fields. The authorized message mapping is returned intact with nested plain metadata and ETag. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", + "contract": "Partitioned SDK conversation/message mappings feed participation, generated-artifact, publication and optional workspace screening checks through fields. The authorized message mapping is returned intact with nested plain metadata and ETag. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_public_source_owner_sdk.py::test_enhanced_citation_owner_returns_sdk_artifact_and_uses_plain_upload_rows" @@ -32221,8 +32220,7 @@ }, "application/single_app/route_enhanced_citations.py::register_enhanced_citations_routes.get_enhanced_citation_tabular": { "boundary": { - "batches": [], - "module_sha256": "49f426f48b0bba2b70834692911b667acb32888ba62e853e045cbe956e9af0ea", + "sha256": "5cf97a0cec09c4811369dd7c311d5aaf3f358e0dc96e8c7e82803ebc89bbc365", "points": [ { "method": "read_item", @@ -32237,10 +32235,11 @@ "response": "consumed" } ], - "sha256": "5cf97a0cec09c4811369dd7c311d5aaf3f358e0dc96e8c7e82803ebc89bbc365" + "batches": [], + "module_sha256": "bd86121e79c23e9b2456f10562a58f84d6d91b4ec6a3f0f4147fd401d22a5820" }, "classification": "sdk-compatible", - "contract": "The SDK conversation owner check precedes file discovery. Partitioned file query rows remain plain dictionaries through approval/provenance checks and blob-field projection; the SDK conversation never enters strict JSON admission. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained.", + "contract": "The SDK conversation owner check precedes file discovery. Partitioned file query rows remain plain dictionaries through approval/provenance checks and blob-field projection; the SDK conversation never enters strict JSON admission. Public discovery now uses the bootstrap-free owner-configured boundary; this storage function and SDK response consumption are unchanged, with representative owner-runtime evidence retained. Review renewed for 0.261.405: exact owner AST, referenced import bindings, and SDK point/query/batch operations are unchanged. Module-only Excel helper/caller additions do not change this response consumer; existing specific runtime/source evidence is retained.", "evidence_scope": "owner-runtime", "tests": [ "functional_tests/test_v2_public_source_owner_sdk.py::test_enhanced_citation_owner_returns_sdk_artifact_and_uses_plain_upload_rows" @@ -32248,8 +32247,7 @@ }, "application/single_app/route_external_public_documents.py::register_route_external_public_documents.external_get_public_documents": { "boundary": { - "batches": [], - "module_sha256": "231c4794f1288f2a86c0e7cf6a20ddd35f2ea0f728b59279646bb78dddc99ce0", + "sha256": "fdba7f2d675b7e814bb2d2493aac2c09f7b219a9b12f767a212def8a8f21a7f0", "points": [], "queries": [ { @@ -32258,7 +32256,8 @@ "response": "consumed" } ], - "sha256": "fdba7f2d675b7e814bb2d2493aac2c09f7b219a9b12f767a212def8a8f21a7f0" + "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.", @@ -32269,8 +32268,7 @@ }, "application/single_app/route_frontend_chats.py::_build_new_chat_conversation": { "boundary": { - "batches": [], - "module_sha256": "4609a2914605a56dac8e47d545543ce4d736cf3ebb18480974f605015bde12a8", + "sha256": "3f1dc9d4206c9b17c73ddad4708bf92b1ec94a40d8b646201f05c34179fdd1a4", "points": [ { "method": "upsert_item", @@ -32279,7 +32277,8 @@ } ], "queries": [], - "sha256": "3f1dc9d4206c9b17c73ddad4708bf92b1ec94a40d8b646201f05c34179fdd1a4" + "batches": [], + "module_sha256": "4609a2914605a56dac8e47d545543ce4d736cf3ebb18480974f605015bde12a8" }, "classification": "response-unused", "contract": "Constructs and returns its own plain conversation dictionary; the SDK upsert response is discarded. Real-owner new/missing upload context tests verify persisted SDK responses retain ETags without changing the returned domain document.", @@ -32290,8 +32289,7 @@ }, "application/single_app/route_frontend_chats.py::_resolve_chat_upload_context": { "boundary": { - "batches": [], - "module_sha256": "4609a2914605a56dac8e47d545543ce4d736cf3ebb18480974f605015bde12a8", + "sha256": "2438af0d0c512dd0c24b52828098eb62d04115bac98d9c083c375eeede97a372", "points": [ { "method": "read_item", @@ -32300,7 +32298,8 @@ } ], "queries": [], - "sha256": "2438af0d0c512dd0c24b52828098eb62d04115bac98d9c083c375eeede97a372" + "batches": [], + "module_sha256": "4609a2914605a56dac8e47d545543ce4d736cf3ebb18480974f605015bde12a8" }, "classification": "sdk-compatible", "contract": "Point conversation responses use mapping field access for backing detection, collaboration identity, and personal ownership; the returned upload context retains the mapping and ETag. Upload consumers read/mutate fields and upsert the mapping, without an exact-dictionary sink. Real-owner runtime checks cover SDK personal reads, cross-user denial, and new/missing context creation. Storage function is unchanged; module-level recovery wiring is covered by representative real-owner SDK runtime evidence, not exhaustive coverage of this function.", @@ -32311,8 +32310,7 @@ }, "application/single_app/route_frontend_chats.py::register_route_frontend_chats.upload_file": { "boundary": { - "batches": [], - "module_sha256": "4609a2914605a56dac8e47d545543ce4d736cf3ebb18480974f605015bde12a8", + "sha256": "e500cecd87a5cccc8a7ee72b7a2571ac5bc3608661cef685cf2795f6e399f80d", "points": [ { "method": "upsert_item", @@ -32372,7 +32370,8 @@ "response": "consumed" } ], - "sha256": "e500cecd87a5cccc8a7ee72b7a2571ac5bc3608661cef685cf2795f6e399f80d" + "batches": [], + "module_sha256": "4609a2914605a56dac8e47d545543ce4d736cf3ebb18480974f605015bde12a8" }, "classification": "response-unused", "contract": "All six message/conversation upsert responses are discarded; upload responses project constructed message/workspace fields and conversation title/id, not the SDK write response. Query rows supply thread ids and counts separately. The unchanged body reads/mutates the SDK-compatible upload context mapping.", @@ -32381,8 +32380,7 @@ }, "application/single_app/route_frontend_control_center.py::get_control_center_statistics": { "boundary": { - "batches": [], - "module_sha256": "864a0ff0422bfeb363581dbcc416f66a569fe93b587062d59f58f03fc75ba814", + "sha256": "d0f2fe9b8db61ebf4ea8f4487d3d6fd99e4d9135bf0f6d60f271ab216c059652", "points": [], "queries": [ { @@ -32436,7 +32434,8 @@ "response": "consumed" } ], - "sha256": "d0f2fe9b8db61ebf4ea8f4487d3d6fd99e4d9135bf0f6d60f271ab216c059652" + "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.", @@ -32447,8 +32446,7 @@ }, "application/single_app/route_frontend_conversations.py::_authorize_frontend_personal_conversation_access": { "boundary": { - "batches": [], - "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b", + "sha256": "d9c4ad68ff896cb16581ad73fd5a718ce68cd399a3e9b7013ce76da1aa76deee", "points": [ { "method": "read_item", @@ -32457,7 +32455,8 @@ } ], "queries": [], - "sha256": "d9c4ad68ff896cb16581ad73fd5a718ce68cd399a3e9b7013ce76da1aa76deee" + "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.", @@ -32468,8 +32467,7 @@ }, "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.conversations": { "boundary": { - "batches": [], - "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b", + "sha256": "26806b7d6a411cd80252ba95f8682ddb44b4ffa1f965e50f3263309d25d42612", "points": [], "queries": [ { @@ -32478,7 +32476,8 @@ "response": "consumed" } ], - "sha256": "26806b7d6a411cd80252ba95f8682ddb44b4ffa1f965e50f3263309d25d42612" + "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.", @@ -32489,8 +32488,7 @@ }, "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_agent_citation_artifact": { "boundary": { - "batches": [], - "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b", + "sha256": "fd8501eec03eaa48a3decb39bfe0249ba8012efb668a4a2d40e9bbe13d4d517b", "points": [ { "method": "read_item", @@ -32515,7 +32513,8 @@ "response": "consumed" } ], - "sha256": "fd8501eec03eaa48a3decb39bfe0249ba8012efb668a4a2d40e9bbe13d4d517b" + "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.", @@ -32526,8 +32525,7 @@ }, "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_conversation_messages": { "boundary": { - "batches": [], - "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b", + "sha256": "6b1cfcc1271fdcd83c47a2485dd848ec2514b85510c79189e15440158af4da1e", "points": [], "queries": [ { @@ -32536,7 +32534,8 @@ "response": "consumed" } ], - "sha256": "6b1cfcc1271fdcd83c47a2485dd848ec2514b85510c79189e15440158af4da1e" + "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.", @@ -32547,8 +32546,7 @@ }, "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.get_message_metadata": { "boundary": { - "batches": [], - "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b", + "sha256": "bc31ff8688128bcc8cbd9b17865c94c68471da69bed27ee9f60a6bb685162c21", "points": [ { "method": "read_item", @@ -32563,7 +32561,8 @@ "response": "consumed" } ], - "sha256": "bc31ff8688128bcc8cbd9b17865c94c68471da69bed27ee9f60a6bb685162c21" + "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.", @@ -32574,8 +32573,7 @@ }, "application/single_app/route_frontend_conversations.py::register_route_frontend_conversations.view_conversation": { "boundary": { - "batches": [], - "module_sha256": "d82946e78310508a252888f0294e3bf4e5b0c099503b12080e5d36794ad17b7b", + "sha256": "d86c4dd32514a5ed089b4bb14cc361a6b5272f3732c045c3028304fd78db1da6", "points": [], "queries": [ { @@ -32584,7 +32582,8 @@ "response": "consumed" } ], - "sha256": "d86c4dd32514a5ed089b4bb14cc361a6b5272f3732c045c3028304fd78db1da6" + "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.", @@ -32595,8 +32594,7 @@ }, "application/single_app/route_frontend_group_workspaces.py::register_route_frontend_group_workspaces.group_workspaces": { "boundary": { - "batches": [], - "module_sha256": "f7369403bb7f46bac2309d90cdca5f4b125c4ab5670bdbb22d69781328efe190", + "sha256": "df494ec94b71d6290e3e55d9523b70c1614d3753aa16128c9c345601286dbaeb", "points": [], "queries": [ { @@ -32605,7 +32603,8 @@ "response": "consumed" } ], - "sha256": "df494ec94b71d6290e3e55d9523b70c1614d3753aa16128c9c345601286dbaeb" + "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.", @@ -32616,8 +32615,7 @@ }, "application/single_app/route_frontend_profile.py::register_route_frontend_profile.get_user_activity_trends": { "boundary": { - "batches": [], - "module_sha256": "161a5f6125e8df58457902de3693d4715a4cd75c5848b0bd04703a20c3611fc5", + "sha256": "a17ce8a02c0093e8e4661101d61925940228be61197fb8a68d05adbe01c4bcac", "points": [], "queries": [ { @@ -32651,7 +32649,8 @@ "response": "consumed" } ], - "sha256": "a17ce8a02c0093e8e4661101d61925940228be61197fb8a68d05adbe01c4bcac" + "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.", @@ -32662,8 +32661,7 @@ }, "application/single_app/route_frontend_workspace.py::register_route_frontend_workspace.workspace": { "boundary": { - "batches": [], - "module_sha256": "59c173e6664096002e14ab63cb014657beff1b4ad645a59c2731ed4d005b2a3e", + "sha256": "252b880849f4eca48d35d608cdf8949d4f2912dae6886081d869ffebb59a07e1", "points": [], "queries": [ { @@ -32672,7 +32670,8 @@ "response": "consumed" } ], - "sha256": "252b880849f4eca48d35d608cdf8949d4f2912dae6886081d869ffebb59a07e1" + "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.", @@ -32683,8 +32682,7 @@ }, "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore._persist": { "boundary": { - "batches": [], - "module_sha256": "2f61903cd0a5097c6d55bf00f74d282d4ccb50c4f669e0ff0e91b434044d2e83", + "sha256": "a3524c7630031b3943be9a396b941644bb88b8ec4a6f876ad88da89c24ab04d5", "points": [ { "method": "upsert_item", @@ -32693,7 +32691,8 @@ } ], "queries": [], - "sha256": "a3524c7630031b3943be9a396b941644bb88b8ec4a6f876ad88da89c24ab04d5" + "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.", @@ -32704,8 +32703,7 @@ }, "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore.delete_fact": { "boundary": { - "batches": [], - "module_sha256": "2f61903cd0a5097c6d55bf00f74d282d4ccb50c4f669e0ff0e91b434044d2e83", + "sha256": "9bc27d2a241e5ae26219ccd994401d6d97024b2fe329ca337af5f8d1ec339054", "points": [ { "method": "delete_item", @@ -32714,7 +32712,8 @@ } ], "queries": [], - "sha256": "9bc27d2a241e5ae26219ccd994401d6d97024b2fe329ca337af5f8d1ec339054" + "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.", @@ -32723,8 +32722,7 @@ }, "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore.get_fact_item": { "boundary": { - "batches": [], - "module_sha256": "2f61903cd0a5097c6d55bf00f74d282d4ccb50c4f669e0ff0e91b434044d2e83", + "sha256": "6de40ea727242a1edf76614ae2c486471999e1ffa911625a713fe9892b26c2fd", "points": [ { "method": "read_item", @@ -32733,7 +32731,8 @@ } ], "queries": [], - "sha256": "6de40ea727242a1edf76614ae2c486471999e1ffa911625a713fe9892b26c2fd" + "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.", @@ -32744,8 +32743,7 @@ }, "application/single_app/semantic_kernel_fact_memory_store.py::FactMemoryStore.get_facts": { "boundary": { - "batches": [], - "module_sha256": "2f61903cd0a5097c6d55bf00f74d282d4ccb50c4f669e0ff0e91b434044d2e83", + "sha256": "7d59076553f20ffec29f304389266b9dd78e2598371a924e723921037498d63b", "points": [], "queries": [ { @@ -32754,7 +32752,8 @@ "response": "consumed" } ], - "sha256": "7d59076553f20ffec29f304389266b9dd78e2598371a924e723921037498d63b" + "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.", @@ -32765,8 +32764,7 @@ }, "application/single_app/semantic_kernel_plugins/cosmos_query_plugin.py::CosmosQueryPlugin.execute_query": { "boundary": { - "batches": [], - "module_sha256": "d6687c31fc3a3c06b0e3b702c0019a3e5347a24d58eec7942aa065d1d6fb10fa", + "sha256": "14c58ba4a36ef80c1f8db6ee380dc4090a3166b8e8955e49bca991d045720e29", "points": [], "queries": [ { @@ -32775,7 +32773,8 @@ "response": "consumed" } ], - "sha256": "14c58ba4a36ef80c1f8db6ee380dc4090a3166b8e8955e49bca991d045720e29" + "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.", @@ -33024,8 +33023,7 @@ }, "deployers/bicep/postconfig.py::": { "boundary": { - "batches": [], - "module_sha256": "0bb24e992842febe1d3f6728ae9fb93afaaa94a541df12e40f6b19d8de429d28", + "sha256": "a64112a2d9c349dce8cf1fe077450f6f64fd744aebd44ff10a7f926a159bda85", "points": [ { "method": "read_item", @@ -33034,19 +33032,19 @@ } ], "queries": [], - "sha256": "0bb24e992842febe1d3f6728ae9fb93afaaa94a541df12e40f6b19d8de429d28" + "batches": [], + "module_sha256": "a64112a2d9c349dce8cf1fe077450f6f64fd744aebd44ff10a7f926a159bda85" }, "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", + "contract": "The real postconfig module consumes installed-SDK CosmosDict reads as mutable mappings through deepcopy, field updates and optional-service configuration. persist_settings owns strict cache/storage normalization and conditional writes. Runtime evidence executes the full module for existing and missing documents; all returned point documents retain SDK shape and matching ETag response headers.", + "evidence_scope": "owner-runtime", "tests": [ - "functional_tests/test_m365_cosmos_sdk_contract.py::test_real_sdk_point_documents_are_wrapped_but_nested_json_and_query_rows_are_plain" + "functional_tests/test_deployer_postconfig_sdk_contract.py::test_real_postconfig_module_accepts_sdk_point_documents" ] }, "scripts/resolve_multiendpoint_gpt.py::fetch_settings_from_cosmos": { "boundary": { - "batches": [], - "module_sha256": "37e530aacf76fe8238effe061af6a7af13ea166a671682358f1f087128d68564", + "sha256": "1316e67af6b71fd1e58b331d10db9d2089d7b2074062647cd91b129f9b23e2a3", "points": [ { "method": "read_item", @@ -33066,7 +33064,8 @@ "response": "consumed" } ], - "sha256": "1316e67af6b71fd1e58b331d10db9d2089d7b2074062647cd91b129f9b23e2a3" + "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.", @@ -33447,7 +33446,6 @@ "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/semantic_kernel_plugins/cosmos_query_plugin.py::CosmosQueryPlugin.execute_query": "f152f3d02d6f16db68314a2b3abdf0f5980750a43429dc4ce71080e20cced7fe", - "deployers/bicep/postconfig.py::": "ab2f59030e95975bf89a77fc91e4bd1067570f8287b14795505d1e0d080f1561", "scripts/resolve_multiendpoint_gpt.py::fetch_settings_from_cosmos": "f4455768ece848c45391f567540ecb90c3aa85e10ef1da84b880a326af7b79f8" } } diff --git a/functional_tests/test_deployer_postconfig_sdk_contract.py b/functional_tests/test_deployer_postconfig_sdk_contract.py new file mode 100644 index 000000000..ceb9f2515 --- /dev/null +++ b/functional_tests/test_deployer_postconfig_sdk_contract.py @@ -0,0 +1,53 @@ +# test_deployer_postconfig_sdk_contract.py +""" +Functional test for the merged deployment entrypoint's Cosmos document contract. +Version: 0.261.408 +Implemented in: 0.261.408 + +Execute the real postconfig module with installed-SDK point responses for an +existing settings document and first-time creation. External services use the +existing deployment fixture; no Azure requests are made. +""" + +from azure.cosmos._cosmos_responses import CosmosDict +import pytest + +from test_app_settings_store_consistency import FakeCosmos +from test_deployment_configuration import ( + test_real_postconfig_entrypoint_writes_once_and_initializes_search as run_real_entrypoint, + world, +) + + +class SdkDeploymentCosmos(FakeCosmos): + def __init__(self): + super().__init__() + self.responses = [] + + def _response(self, response_hook=None): + document = super()._response(response_hook) + response = CosmosDict(document, response_headers={"etag": document["_etag"]}) + self.responses.append(response) + return response + + +@pytest.mark.parametrize("existing", [True, False]) +def test_real_postconfig_module_accepts_sdk_point_documents(monkeypatch, world, existing): + world.cosmos = SdkDeploymentCosmos() + previous_etag = world.cosmos.document["_etag"] if existing else None + if not existing: + world.cosmos.document = None + + run_real_entrypoint(monkeypatch, world) + + stored = world.cosmos.read_item(item="app_settings", partition_key="app_settings") + assert type(stored) is CosmosDict + assert stored["id"] == "app_settings" + assert stored["_etag"] and stored["_etag"] != previous_etag + assert world.cosmos.writes == 1 + assert world.cosmos.responses + assert all(type(response) is CosmosDict for response in world.cosmos.responses) + assert all( + response.get_response_headers()["etag"] == response["_etag"] + for response in world.cosmos.responses + ) diff --git a/functional_tests/test_excel_document_accessibility_extraction.py b/functional_tests/test_excel_document_accessibility_extraction.py index 070dadcdf..41ca85b7e 100644 --- a/functional_tests/test_excel_document_accessibility_extraction.py +++ b/functional_tests/test_excel_document_accessibility_extraction.py @@ -1,7 +1,7 @@ # test_excel_document_accessibility_extraction.py """ Functional tests for native Excel inspection and workspace evidence persistence. -Version: 0.261.399 +Version: 0.261.408 Implemented in: 0.261.399 Real workbook packages exercise saved properties, styles, notes, threaded comments, @@ -172,7 +172,8 @@ def test_native_excel_properties_comments_objects_styles_and_printing(workbook_p assert any(item["color"] == "#FF0000" for item in style["colors"]) body = "\n".join(item["content"] for item in evidence) assert "Thread reply" in body and "$0.00" in body and "#FFFF00" in body - assert "Operations" not in body, "Native evidence must not become a copy of worksheet rows" + assert "Theme color" not in body, "Unannotated worksheet values must not become native row indexing" + assert any(item["cell"] == "A2" and item["cell_value"] == "Operations" for item in notes) assert "No worksheet rows" in body, "Blank sheets still have native evidence" assert any("External relationships" in note for note in metadata["coverage_notes"]) summary = format_accessibility_metadata_for_chat(metadata) @@ -399,6 +400,10 @@ def schema(*args): "pandas": pandas, "os": os, "logging": logging, "log_event": lambda *args, **kwargs: None, "extract_office_accessibility_metadata": extract_office_accessibility_metadata, + "_extract_excel_native_inventory": lambda document_id, user_id, path, extension, **scope: ( + *extract_office_accessibility_metadata(path, extension), None, + ), + "EXCEL_INVENTORY_FIELD": "excel_native_inventory", "build_excel_evidence_chunks": excel.build_excel_evidence_chunks, "get_embedding_safe_chunk_characters": lambda settings: 900, "get_settings": lambda: {"enable_extract_meta_data": True}, @@ -436,7 +441,7 @@ def test_ingestion_modes_scopes_native_properties_and_chunk_identity(workbook_pa assert native and all(len(item["page_text_content"]) <= 900 for item in native) if enhanced: assert chunks[0]["page_text_content"] == "schema preview" - assert all("Operations" not in item["page_text_content"] for item in native) + assert all("Theme color" not in item["page_text_content"] for item in native) assert any(item.get("num_chunks") == count for item in updates) assert any(item.get("title") == "AI-generated title" for item in updates) is auto_metadata @@ -562,6 +567,10 @@ def execute(sources, callback, selection_mode, **kwargs): "annotate_document_search_payload": annotate_document_search_payload, "format_accessibility_metadata_for_chat": format_accessibility_metadata_for_chat, "EXCEL_EVIDENCE_MARKER": excel.EXCEL_EVIDENCE_MARKER, + "build_excel_native_chat_evidence": excel.build_excel_native_chat_evidence, + "excel_native_question_sections": excel.excel_native_question_sections, + "has_excel_native_inspection_intent": excel.has_excel_native_inspection_intent, + "merge_excel_native_evidence": excel.merge_excel_native_evidence, "execute_tabular_evidence_sources": execute, } _load_functions("route_backend_chats.py", {"_execute_excel_native_inspection_evidence"}, namespace) diff --git a/functional_tests/test_excel_document_delete_sdk_contract.py b/functional_tests/test_excel_document_delete_sdk_contract.py new file mode 100644 index 000000000..fd1f8b03a --- /dev/null +++ b/functional_tests/test_excel_document_delete_sdk_contract.py @@ -0,0 +1,87 @@ +# test_excel_document_delete_sdk_contract.py +""" +Owner-runtime SDK contract for Excel document and private-inventory cleanup. +Version: 0.261.408 +Implemented in: 0.261.408 + +The actual deletion function consumes installed-SDK CosmosDict point responses. +External logging, Search, and blob side effects are isolated and scope checked. +""" + +import ast +from pathlib import Path +import os +import sys +from types import ModuleType, SimpleNamespace +from unittest.mock import patch + +import pytest +from azure.core import MatchConditions +from azure.cosmos._cosmos_responses import CosmosDict +from azure.cosmos.exceptions import CosmosResourceNotFoundError + +APP = Path(__file__).resolve().parents[1] / "application" / "single_app" +sys.path.insert(0, str(APP)) + +from content_screening.contracts import ScreeningConflictError, subject_from_document # noqa: E402 +from test_support.offline_bootstrap import OfflineContainer # noqa: E402 + + +def load_delete(container, calls): + source = ast.parse((APP / "functions_documents.py").read_text(encoding="utf-8")) + node = next(node for node in source.body if isinstance(node, ast.FunctionDef) and node.name == "delete_document") + namespace = { + "os": os, "cosmos_user_documents_container": container, + "cosmos_group_documents_container": container, "cosmos_public_documents_container": container, + "SCREENING_FIELD": "content_screening", "EXCEL_INVENTORY_FIELD": "excel_native_inventory", + "ScreeningConflictError": ScreeningConflictError, + "CosmosResourceNotFoundError": CosmosResourceNotFoundError, "MatchConditions": MatchConditions, + "subject_from_document": subject_from_document, + "prepare_document_deletion": lambda document, actor: calls.append(("private_cleanup", document, actor)), + "clear_excel_inventory_cache": lambda subject: calls.append(("cache_cleanup", subject)), + "delete_from_blob_storage": lambda document, **kwargs: calls.append(("source_cleanup", document, kwargs)), + "delete_document_access_index_for_document_fail_open": lambda document, **kwargs: {"success": True}, + "assert_group_document_source_writable": lambda document: None, + } + exec(compile(ast.Module(body=[node], type_ignores=[]), "functions_documents.py", "exec"), namespace) + return namespace["delete_document"] + + +@pytest.mark.parametrize("scope", ["personal", "group", "public"]) +def test_real_delete_owner_handles_sdk_points_and_scope_bound_native_cleanup(scope): + container, calls = OfflineContainer(), [] + document = {"id": "document", "user_id": "owner", "file_name": "review.xlsx", "version": 1} + kwargs = {} + if scope == "group": + document["group_id"] = "group" + kwargs["group_id"] = "group" + elif scope == "public": + document["public_workspace_id"] = "public" + kwargs["public_workspace_id"] = "public" + saved = container.upsert_item(document) + assert isinstance(saved, CosmosDict) + delete = load_delete(container, calls) + debug, activity = ModuleType("functions_debug"), ModuleType("functions_activity_logging") + debug.debug_print = lambda *args: None + activity.log_document_deletion_transaction = lambda **kwargs: calls.append(("activity", kwargs)) + with patch.dict(sys.modules, {"functions_debug": debug, "functions_activity_logging": activity}): + delete("owner", "document", strict=True, expected_etag=saved["_etag"], **kwargs) + assert "document" not in container.items + private = next(call for call in calls if call[0] == "private_cleanup") + assert isinstance(private[1], CosmosDict) + assert private[1]["id"] == "document" and private[2] == "owner" + assert next(call for call in calls if call[0] == "cache_cleanup")[1] == subject_from_document(document) + source = next(call for call in calls if call[0] == "source_cleanup") + assert source[2]["strict"] is True + + +def test_stale_sdk_etag_prevents_private_inventory_deletion(): + container, calls = OfflineContainer(), [] + container.upsert_item({"id": "document", "user_id": "owner", "file_name": "review.xlsx", "version": 1}) + delete = load_delete(container, calls) + debug = ModuleType("functions_debug") + debug.debug_print = lambda *args: None + with patch.dict(sys.modules, {"functions_debug": debug}): + with pytest.raises(ScreeningConflictError): + delete("owner", "document", strict=True, expected_etag="stale") + assert not calls and "document" in container.items diff --git a/functional_tests/test_excel_inventory_persistence.py b/functional_tests/test_excel_inventory_persistence.py new file mode 100644 index 000000000..b316d4948 --- /dev/null +++ b/functional_tests/test_excel_inventory_persistence.py @@ -0,0 +1,255 @@ +# test_excel_inventory_persistence.py +""" +Functional tests for private, complete, revision-bound Excel inventories. +Version: 0.261.409 +Implemented in: 0.261.408 +UUID import binding regression implemented in: 0.261.409 + +The real private artifact store runs against the existing Azure-like blob double. +Tests prove paging, full-text continuations, source binding, publication failures, +fresh authorization, screening capture, and revision-confined cleanup. +""" + +import json +import ast +import sys +import uuid +from pathlib import Path +from types import SimpleNamespace + +import pytest +from openpyxl import Workbook +from openpyxl.comments import Comment +from azure.core.exceptions import ResourceNotFoundError + +APP = Path(__file__).resolve().parents[1] / "application" / "single_app" +sys.path.insert(0, str(APP)) + +import functions_excel_accessibility as excel # noqa: E402 +from content_screening.contracts import Subject, hash_payload # noqa: E402 +from content_screening.extraction import ExtractionCapture # noqa: E402 +from content_screening.storage import ScreeningStorage, revision_prefix # noqa: E402 +from functions_excel_inventory import ( # noqa: E402 + EXCEL_INVENTORY_FIELD, + ExcelInventoryPersistenceError, + clear_excel_inventory_cache, + open_excel_inventory, + open_stored_excel_inventory, + persist_excel_inventory, +) +from test_content_screening_persistence import FakeBlobService, FakeSdkError # noqa: E402 +from test_excel_native_inspection_chat_evidence import review_workbook # noqa: E402 +from test_document_accessibility_report_action import _load_payload_namespace # noqa: E402 +from excel_workbook_reader import ExcelWorkbookReader, bounded_range # noqa: E402 +from openpyxl.utils.cell import get_column_letter # noqa: E402 + + +__all__ = ["review_workbook"] + + +@pytest.fixture(autouse=True) +def isolate_inventory_cache(): + clear_excel_inventory_cache() + yield + clear_excel_inventory_cache() + + +@pytest.fixture +def inventory_store(): + service = FakeBlobService() + return ScreeningStorage(service), service + + +def test_inventory_generations_use_current_uuid_factory(review_workbook, inventory_store, monkeypatch): + store, _ = inventory_store + subject = Subject("personal", "owner", "workbook", "1") + original_factory = uuid.uuid4 + references, expected_scan_keys = [], [] + with monkeypatch.context() as scoped: + for generation in (uuid.UUID(int=1), uuid.UUID(int=2)): + scoped.setattr(uuid, "uuid4", lambda current=generation: current) + _, _, reference = persist_excel_inventory(review_workbook, ".xlsx", subject=subject, storage=store) + scan_id = ( + f"excel-native:{excel.EXCEL_WORKBOOK_SCHEMA_VERSION}:" + f"{reference['source_sha256']}:{generation.hex}" + ) + references.append(reference) + expected_scan_keys.append(hash_payload(scan_id)) + actual_scan_keys = [reference["manifest"]["scan_key"] for reference in references] + assert uuid.uuid4 is original_factory + assert actual_scan_keys == expected_scan_keys + assert actual_scan_keys[0] != actual_scan_keys[1] + for reference in references: + clear_excel_inventory_cache() + reader = open_stored_excel_inventory( + {"id": "workbook", "user_id": "owner", "version": 1, EXCEL_INVENTORY_FIELD: reference}, + storage=store, authorize=lambda: None, + ) + records = reader.page("comments")["records"] + assert len(records) == 5 + assert any(record["text"] == "Set cap to 19500." for record in records) + + +def test_complete_inventory_survives_parent_record_limits_and_restart(review_workbook, inventory_store, monkeypatch): + store, service = inventory_store + subject = Subject("personal", "owner", "workbook", "1") + monkeypatch.setattr(excel, "EXCEL_MAX_RECORDS", 2) + metadata, _, reference = persist_excel_inventory(review_workbook, ".xlsx", subject=subject, storage=store) + assert metadata["comments"] == [] + assert len(json.dumps(metadata, ensure_ascii=True).encode()) <= 500000 + clear_excel_inventory_cache() + checks = [] + reader = open_stored_excel_inventory( + {"id": "workbook", "user_id": "owner", "version": 1, EXCEL_INVENTORY_FIELD: reference}, + storage=ScreeningStorage(service), authorize=lambda: checks.append("checked"), + ) + records, cursor = [], None + while True: + page = reader.page("comments", cursor=cursor, page_size=2) + records.extend(page["records"]) + cursor = page["next_cursor"] + if cursor is None: + break + assert len(records) == 5 + assert any(record["text"] == "Set cap to 19500." for record in records) + assert any(record["kind"] == "note" for record in records) + assert len(checks) >= 8 + assert reader.metadata["comment_summary"]["compatibility_copies"] == 3 + + +def test_long_unicode_text_continues_without_loss_or_oversized_responses(tmp_path, inventory_store): + store, _ = inventory_store + path = tmp_path / "long.xlsx" + workbook = Workbook() + workbook.active["A1"] = "Amount" + workbook.active["A2"] = 0 + text = ('review "\\\\ quote ' + chr(0x03B1) + "\n") * 1800 + "TAIL" + workbook.active["A2"].comment = Comment(text, "Reviewer") + workbook.save(path) + subject = Subject("personal", "owner", "long", "1") + _, _, reference = persist_excel_inventory(path, ".xlsx", subject=subject, storage=store) + reader = open_stored_excel_inventory( + {"id": "long", "user_id": "owner", EXCEL_INVENTORY_FIELD: reference}, + storage=store, authorize=lambda: None, + ) + fragments, cursor = [], None + while True: + page = reader.page("comments", cursor=cursor, max_bytes=4096) + assert len(json.dumps(page, ensure_ascii=False, separators=(",", ":")).encode()) <= 4096 + assert page["records"][0]["record_fragment"] is True + fragments.append(page["records"][0]["record_json_fragment"]) + cursor = page["next_cursor"] + if cursor is None: + break + record = json.loads("".join(fragments)) + assert record["text"] == text and record["cell_value"] == 0 + + +def test_source_and_section_bound_cursors_cannot_be_replayed(review_workbook, inventory_store): + store, _ = inventory_store + document = {"id": "workbook", "user_id": "owner", "version": 1} + original = review_workbook.read_bytes() + reader = open_excel_inventory(document, original, ".xlsx", storage=store, authorize=lambda: None) + page = reader.page("comments", page_size=1) + with pytest.raises(ValueError, match="different source or section"): + reader.page("objects", cursor=page["next_cursor"]) + updated = open_excel_inventory(document, original + b"new-revision", ".xlsx", storage=store, authorize=lambda: None) + with pytest.raises(ValueError, match="different source or section"): + updated.page("comments", cursor=page["next_cursor"]) + + +def test_every_page_rechecks_authorization(review_workbook, inventory_store): + store, _ = inventory_store + allowed = [True] + + def authorize(): + if not allowed[0]: + raise PermissionError("Source access revoked.") + + reader = open_excel_inventory( + {"id": "workbook", "user_id": "owner"}, + review_workbook.read_bytes(), ".xlsx", storage=store, authorize=authorize, + ) + first = reader.page("comments", page_size=1) + allowed[0] = False + with pytest.raises(PermissionError, match="revoked"): + reader.page("comments", cursor=first["next_cursor"]) + with pytest.raises(PermissionError, match="revoked"): + _ = reader.metadata + + +def test_native_text_is_included_in_private_screening_capture(review_workbook, inventory_store): + store, _ = inventory_store + subject = Subject("personal", "owner", "workbook", "1") + capture = ExtractionCapture(subject, "scan", "review.xlsx", artifact_storage=store) + capture.mode = "table" + persist_excel_inventory(review_workbook, ".xlsx", subject=subject, storage=store, capture=capture) + capture.completed = True + units = capture.finish({}) + text = "\n".join(unit.text for unit in units) + assert "Set cap to 19500." in text and "Hold approval." in text + assert all(unit.locator["kind"] == "excel_native" for unit in units) + + +def test_storage_failure_is_not_a_ready_inventory(review_workbook, inventory_store): + store, service = inventory_store + service.get_container_client("content-screening").fail_upload_name = "part-0000" + with pytest.raises(ExcelInventoryPersistenceError) as error: + persist_excel_inventory( + review_workbook, ".xlsx", subject=Subject("personal", "owner", "workbook", "1"), storage=store, + ) + assert "private-provider-error-canary" not in str(error.value) + + +def test_revision_cleanup_does_not_remove_another_workbook(review_workbook, inventory_store): + store, service = inventory_store + first, second = Subject("personal", "owner", "one", "1"), Subject("personal", "owner", "two", "1") + persist_excel_inventory(review_workbook, ".xlsx", subject=first, storage=store) + persist_excel_inventory(review_workbook, ".xlsx", subject=second, storage=store) + container = service.get_container_client("content-screening") + store.delete_revision(first) + assert not any(name.startswith(revision_prefix(first)) for name in container.blobs) + assert any(name.startswith(revision_prefix(second)) for name in container.blobs) + + +def test_real_report_backfills_existing_original_without_reupload(review_workbook, inventory_store): + store, service = inventory_store + document = {"id": "workbook", "user_id": "owner", "version": 1, + "file_name": "review.xlsx", "source_file_available": True} + namespace = _load_payload_namespace(document, chunks=[{ + "id": "workbook_2", "document_id": "workbook", "page_number": 2, + "chunk_text": excel.EXCEL_EVIDENCE_MARKER + "\nNative comments", + }]) + source_reads, checks = [], [] + + def available_bytes(doc, **kwargs): + source_reads.append(kwargs) + return document, review_workbook.read_bytes() + + namespace.update({ + "CLIENTS": {"storage_account_office_docs_client": service}, + "ScreeningStorage": lambda **kwargs: store, + "storage_account_content_screening_container_name": "content-screening", + "screening_access": SimpleNamespace(read_available_document_bytes=available_bytes), + "open_excel_inventory": open_excel_inventory, + "open_stored_excel_inventory": open_stored_excel_inventory, + "EXCEL_INVENTORY_SECTIONS": {"comments"}, + "ExcelWorkbookReader": ExcelWorkbookReader, "bounded_range": bounded_range, + "get_column_letter": get_column_letter, + "ResourceNotFoundError": ResourceNotFoundError, + "assert_evidence_available": lambda *args, **kwargs: checks.append("fresh"), + "_serialize_document": lambda doc, scope: {"id": doc["id"], "file_name": doc["file_name"]}, + }) + tree = ast.parse((APP / "functions_search_service.py").read_text(encoding="utf-8")) + node = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "_read_excel_inspection") + exec(compile(ast.Module(body=[node], type_ignores=[]), "functions_search_service.py", "exec"), namespace) + payload = namespace["get_document_accessibility_payload"]( + "workbook", "owner", sheet_name="Budget", cell_range="B4:B4", + ) + assert payload["schema_version"] == "2.0" + assert payload["accessibility_metadata"]["comment_summary"]["thread_roots"] == 3 + assert any(item["text"] == "Set cap to 19500." for item in payload["excel_inspection"]["page"]["records"]) + assert payload["excel_inspection"]["cells"][0]["value"] == 15000 + assert payload["citation_chunk"]["id"] == "workbook_2" + assert len(source_reads) == 1 and len(checks) >= 3 + assert "accessibility_metadata" not in document, "A read must not rewrite the original metadata/clearance." diff --git a/functional_tests/test_excel_native_images_and_release.py b/functional_tests/test_excel_native_images_and_release.py new file mode 100644 index 000000000..ecd7719aa --- /dev/null +++ b/functional_tests/test_excel_native_images_and_release.py @@ -0,0 +1,169 @@ +# test_excel_native_images_and_release.py +""" +Functional tests for Excel image anchors and release-safe metadata. +Version: 0.261.408 +Implemented in: 0.261.408 + +Real OOXML drawings retain worksheet/cell locations through existing image +extraction. Cleared/sanitized source hashes cannot borrow original metadata. +""" + +import ast +import io +from pathlib import Path +import random +import sys + +from openpyxl import Workbook +from openpyxl.drawing.image import Image as WorkbookImage +from PIL import Image + +APP = Path(__file__).resolve().parents[1] / "application" / "single_app" +sys.path.insert(0, str(APP)) + +from content_screening.access import _with_current_excel_metadata, is_public_document_field # noqa: E402 +from content_screening.contracts import ContentUnit, ScreeningValidationError # noqa: E402 +from content_screening.publication import _tabular_publication_chunks # noqa: E402 +from functions_excel_accessibility import extract_excel_accessibility_metadata # noqa: E402 +from functions_office_media import extract_office_embedded_images_with_diagnostics # noqa: E402 +from test_tabular_enhanced_citations_schema_summary_fix import load_tabular_schema_helpers # noqa: E402 + + +def test_real_excel_image_keeps_sheet_anchor_alt_and_analysis_location(tmp_path): + picture = tmp_path / "figure.png" + pixels = random.Random(7).randbytes(200 * 200 * 3) + Image.frombytes("RGB", (200, 200), pixels).save(picture) + path = tmp_path / "images.xlsx" + workbook = Workbook() + workbook.active.title = "Figures" + workbook.active.add_image(WorkbookImage(picture), "D9") + workbook.save(path) + metadata, _ = extract_excel_accessibility_metadata(path, ".xlsx") + locations = metadata["image_locations"] + assert len(locations) == 1 + output = tmp_path / "extracted" + output.mkdir() + images, diagnostics = extract_office_embedded_images_with_diagnostics( + path, str(output), min_pixels=100, max_images=5, native_media_metadata=locations, + ) + assert diagnostics["candidates"] == 1 + assert len(images) == 1 + assert images[0]["sheet_name"] == "Figures" and images[0]["cell"] == "D9" + assert images[0]["is_decorative"] is None + assert images[0]["position_known"] is True + assert images[0]["placements"][0]["cell"] == "D9" + + +def test_original_excel_metadata_is_not_exposed_after_active_source_sanitization(): + metadata = {"format": "xlsx", "comments": [{"text": "original-private-canary"}], + "inventory_storage": {"source_sha256": "a" * 64}} + original = {"content_screening": {"active_blob": {"content_hash": "a" * 64}}} + matching = _with_current_excel_metadata({"accessibility_metadata": metadata}, original) + assert matching["accessibility_metadata"] == metadata + sanitized = {"content_screening": {"active_blob": {"content_hash": "b" * 64}}} + released = _with_current_excel_metadata({"accessibility_metadata": metadata}, sanitized) + assert "accessibility_metadata" not in released + assert released["native_inspection_status"] == "requires_active_source_inspection" + assert not is_public_document_field("excel_native_inventory") + + +def test_duplicate_image_analysis_retains_each_excel_placement(tmp_path): + picture = tmp_path / "duplicate.png" + Image.frombytes("RGB", (200, 200), random.Random(11).randbytes(200 * 200 * 3)).save(picture) + path = tmp_path / "duplicates.xlsx" + workbook = Workbook() + workbook.active.title = "Figures" + workbook.active.add_image(WorkbookImage(picture), "D9") + workbook.active.add_image(WorkbookImage(picture), "F12") + workbook.save(path) + metadata, _ = extract_excel_accessibility_metadata(path, ".xlsx") + output = tmp_path / "extracted" + output.mkdir() + images, diagnostics = extract_office_embedded_images_with_diagnostics( + path, str(output), min_pixels=100, max_images=5, native_media_metadata=metadata["image_locations"], + ) + assert len(images) == 1 and diagnostics["skipped_reasons"]["duplicate_image"] == 1 + assert {item["cell"] for item in images[0]["placements"]} == {"D9", "F12"} + + +def test_image_analysis_uses_existing_gate_and_keeps_generated_content_separate(): + tree = ast.parse((APP / "functions_documents.py").read_text(encoding="utf-8")) + node = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "_enrich_excel_image_inventory") + calls = [] + + def build(*args, **kwargs): + calls.append(kwargs) + return ([{"content": "The figure contains a delivery schedule.", "sheet_name": "Figures", + "cell": "D9", "media_part": "xl/media/image1.png", "placements": [{"sheet_name": "Figures", "cell": "D9"}]}], + 1, "configured-engine", 0) + + namespace = {"_build_office_embedded_image_chunks": build} + exec(compile(ast.Module(body=[node], type_ignores=[]), "excel_image_enrichment", "exec"), namespace) + metadata, evidence, records = {"coverage_notes": [], "image_locations": {"xl/media/image1.png": {"sheet_name": "Figures"}}}, [], [] + enrich = namespace[node.name] + enrich("file.xlsx", {"enable_office_embedded_image_analysis": False}, lambda **kwargs: None, metadata, evidence, + lambda section, record: records.append((section, record))) + assert not calls and metadata["image_analysis_summary"]["status"] == "disabled" + enrich("file.xlsx", {"enable_office_embedded_image_analysis": True}, lambda **kwargs: None, metadata, evidence, + lambda section, record: records.append((section, record))) + assert len(calls) == 1 and calls[0]["native_media_metadata"] == metadata["image_locations"] + assert records[0][0] == "image_analyses" + assert records[0][1]["source_kind"] == "configured_image_analysis_not_saved_alt_text" + assert records[0][1]["cell"] == "D9" + assert "delivery schedule" in evidence[0]["content"] + + +def test_reviewed_native_publication_is_bounded_and_every_fragment_is_findable(): + units = [ + ContentUnit("sheet", "Data", {"kind": "table_sheet", "sheet_index": 1}), + ContentUnit("native-1", "reviewer feedback " * 80000, {"kind": "excel_native"}), + ContentUnit("native-2", "additional feedback " * 80000, {"kind": "excel_native"}), + ] + chunks = _tabular_publication_chunks( + units, "review.xlsx", 1024, include_native=True, + schema_text="Table: Data!A2:D9; header_row=2; Columns: Site, Cap, Delivered, Accepted", + ) + native = [chunk for chunk in chunks if chunk["unit_id"].startswith("native-")] + assert len(native) > 1 + assert sum(len(chunk["chunk_text"]) for chunk in native) <= 1000000 + assert all(chunk["chunk_text"].startswith("### Excel native inspection\n") for chunk in native) + assert all(len(chunk["chunk_text"]) <= 1024 for chunk in chunks) + assert [chunk["chunk_sequence"] for chunk in chunks] == list(range(1, len(chunks) + 1)) + assert chunks[0]["chunk_text"].startswith("Table: Data!A2:D9; header_row=2;") + assert units[1].text == "reviewer feedback " * 80000 + + sanitized = _tabular_publication_chunks(units, "review.xlsx", 1024, include_native=False) + assert all(chunk["unit_id"] == "table-schema" for chunk in sanitized) + + +def test_native_publication_rejects_chunk_sizes_that_cannot_identify_evidence(): + units = [ContentUnit("native", "feedback", {"kind": "excel_native"})] + try: + _tabular_publication_chunks(units, "review.xlsx", 8, include_native=True) + except ScreeningValidationError: + return + raise AssertionError("Native publication must not emit unidentifiable evidence fragments.") + + +def test_reviewed_workbook_schema_uses_active_bytes_and_actual_table_header(): + workbook = Workbook() + workbook.active.title = "Budget" + workbook.active.append(["Delivery review"]) + workbook.active.append(["Site", "Cap"]) + workbook.active.append(["South", 15000]) + source = io.BytesIO() + workbook.save(source) + source.seek(0) + helpers, _ = load_tabular_schema_helpers() + schema = helpers["_build_tabular_schema_summary"](source, "active-source.xlsx", ".xlsx") + units = [ + ContentUnit("sheet", "Budget", {"kind": "table_sheet", "sheet_index": 1}), + ContentUnit("original-native", "original-private-canary", {"kind": "excel_native"}), + ] + chunks = _tabular_publication_chunks( + units, "active-source.xlsx", 1024, include_native=False, schema_text=schema, + ) + text = "\n".join(chunk["chunk_text"] for chunk in chunks) + assert "header_row=2;" in text + assert "Columns (2): Site, Cap" in text + assert "original-private-canary" not in text diff --git a/functional_tests/test_excel_native_inspection_chat_evidence.py b/functional_tests/test_excel_native_inspection_chat_evidence.py new file mode 100644 index 000000000..a92f48fc2 --- /dev/null +++ b/functional_tests/test_excel_native_inspection_chat_evidence.py @@ -0,0 +1,230 @@ +# test_excel_native_inspection_chat_evidence.py +""" +Functional tests for complete, source-backed Excel native evidence. +Version: 0.261.409 +Implemented in: 0.261.408 + +Real packages distinguish threaded compatibility copies from genuine notes, +preserve saved cell values and unavailable caches, and retain comment content. +No model or cloud service is called. +""" + +import hashlib +import json +import sys +import zipfile +from pathlib import Path +from xml.etree import ElementTree as ET + +import pytest +from openpyxl import Workbook +from openpyxl.comments import Comment + +APP = Path(__file__).resolve().parents[1] / "application" / "single_app" +sys.path.insert(0, str(APP)) + +from functions_accessibility import format_accessibility_metadata_for_chat # noqa: E402 +import functions_excel_accessibility as excel # noqa: E402 +from functions_agent_document_citations import annotate_document_search_payload # noqa: E402 +from test_excel_document_accessibility_extraction import _load_functions # noqa: E402 + + +REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships" +SHEET_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main" + + +def add_relationship(parts, path, identifier, kind, target): + root = ET.fromstring(parts.get(path, f'')) + ET.SubElement(root, f"{{{REL_NS}}}Relationship", { + "Id": identifier, + "Type": f"http://schemas.microsoft.com/office/2017/10/relationships/{kind}", + "Target": target, + }) + parts[path] = ET.tostring(root) + + +@pytest.fixture +def review_workbook(tmp_path): + path = tmp_path / "review.xlsx" + workbook = Workbook() + workbook.active.title = "Budget" + workbook.create_sheet("Delivery") + for sheet in workbook: + sheet.append(["Delivery review"]) + sheet.append(["Site", "Cap", "Delivered", "Accepted"]) + sheet.append(["North", 12000, 18, True]) + sheet.append(["South", 15000, 12, False]) + sheet.append(["East", 9000, 9, True]) + workbook["Budget"]["B4"].comment = Comment( + "[Threaded comment]\nSet cap to 19500.\nHold approval.", + "tc={root-budget}", + ) + workbook["Budget"]["D12"].comment = Comment( + "[Threaded comment]\nArrange a review.", "tc={root-blank}", + ) + workbook["Budget"]["A3"].comment = Comment("A genuine legacy note.", "Legacy reviewer") + workbook["Delivery"]["B4"].comment = Comment( + "[Threaded comment]\nKeep cap at 15000.", "tc={root-delivery}", + ) + workbook.save(path) + with zipfile.ZipFile(path) as archive: + parts = {name: archive.read(name) for name in archive.namelist()} + add_relationship(parts, "xl/_rels/workbook.xml.rels", "people", "person", "persons/person.xml") + parts["xl/persons/person.xml"] = b'' + for index, comments in enumerate(( + """Set cap to 19500. + Hold approval. + Arrange a review.""", + """Keep cap at 15000.""", + ), start=1): + add_relationship( + parts, f"xl/worksheets/_rels/sheet{index}.xml.rels", + "thread", "threadedComment", f"../threadedComments/comments{index}.xml", + ) + parts[f"xl/threadedComments/comments{index}.xml"] = f"{comments}".encode() + with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as archive: + for name, data in parts.items(): + archive.writestr(name, data) + return path + + +def test_threaded_compatibility_copies_do_not_become_legacy_notes(review_workbook): + before = hashlib.sha256(review_workbook.read_bytes()).hexdigest() + metadata, evidence = excel.extract_excel_accessibility_metadata(review_workbook, ".xlsx") + summary = metadata["comment_summary"] + assert summary == { + "legacy_notes": 1, "thread_roots": 3, "replies": 1, + "thread_messages": 4, "compatibility_copies": 3, "raw_records": 8, + } + assert len(metadata["comments"]) == 5 + assert metadata["observed_counts"]["comments"] == 5 + assert all(not str(item.get("author")).startswith("tc=") for item in metadata["comments"]) + assert any(item["kind"] == "note" and item["text"] == "A genuine legacy note." for item in metadata["comments"]) + text = "\n".join(item["content"] for item in evidence) + assert "[Threaded comment]" not in text + assert hashlib.sha256(review_workbook.read_bytes()).hexdigest() == before + + +def test_native_records_include_saved_cell_values_and_blank_cells(review_workbook): + metadata, _ = excel.extract_excel_accessibility_metadata(review_workbook, ".xlsx") + comments = {item["id"]: item for item in metadata["comments"] if item.get("id")} + budget = comments["{root-budget}"] + delivery = comments["{root-delivery}"] + blank = comments["{root-blank}"] + assert budget["sheet"] == "Budget" and budget["cell"] == "B4" + assert budget["cell_value"] == 15000 and budget["cell_value_status"] == "saved" + assert delivery["cell_value"] == 15000 and delivery["resolved"] is True + assert blank["cell_value"] is None and blank["cell_value_status"] == "blank" + assert comments["{reply-budget}"]["date"] is None + assert comments["{reply-budget}"]["resolved"] is None + assert comments["{reply-budget}"]["parent_id"] == "{root-budget}" + + +def test_chat_formatter_supplies_comment_text_not_just_counts(review_workbook): + metadata, _ = excel.extract_excel_accessibility_metadata(review_workbook, ".xlsx") + rendered = format_accessibility_metadata_for_chat(metadata) + assert "Set cap to 19500." in rendered + assert "Hold approval." in rendered + assert "Keep cap at 15000." in rendered + assert "Budget!B4" in rendered and "Delivery!B4" in rendered + assert "15000" in rendered + assert "reviewer feedback" in rendered.lower() + + +def test_comment_inventory_sink_preserves_text_beyond_parent_preview(tmp_path): + path = tmp_path / "long-note.xlsx" + workbook = Workbook() + workbook.active["A1"] = "Value" + workbook.active["A2"] = 0 + text = "Start " + "long review text " * 1000 + "END-OF-COMMENT" + workbook.active["A2"].comment = Comment(text, "Reviewer") + workbook.save(path) + records = [] + metadata, _ = excel.extract_excel_accessibility_metadata( + path, ".xlsx", record_sink=lambda kind, record: records.append((kind, record)), + ) + note = next(record for kind, record in records if kind == "comments") + assert note["text"] == text + assert note["cell_value"] == 0 + assert len(json.dumps(metadata, ensure_ascii=True).encode()) <= 500000 + assert metadata["comments"][0]["text_truncated"] is True + + +def test_formula_without_cache_is_not_blank_or_zero(tmp_path): + path = tmp_path / "formula.xlsx" + workbook = Workbook() + workbook.active["A1"] = "Amount" + workbook.active["A2"] = "=1+2" + workbook.active["A2"].comment = Comment("Confirm calculated amount.", "Reviewer") + workbook.save(path) + metadata, _ = excel.extract_excel_accessibility_metadata(path, ".xlsx") + note = metadata["comments"][0] + assert note["formula"] == "=1+2" + assert note["cell_value"] is None + assert note["cell_value_status"] == "cache_missing" + assert note["cached_value_available"] is False + + +def test_actual_chat_handoff_uses_known_records_when_relevance_has_no_matches(review_workbook): + metadata, _ = excel.extract_excel_accessibility_metadata(review_workbook, ".xlsx") + metadata["properties"]["long_context"] = "irrelevant prefix " * 1200 + metadata["style_inventory"]["long_context"] = "layout prefix " * 1500 + report = { + "document": {"id": "doc", "file_name": "review.xlsx"}, + "accessibility_metadata": metadata, + "style_inventory": metadata["style_inventory"], + "citation_chunk": {"id": "doc_2", "document_id": "doc", "file_name": "review.xlsx", + "page_number": 2, "chunk_text": excel.EXCEL_EVIDENCE_MARKER + "\nNative comments"}, + } + calls = [] + + def get_report(document_id, user_id, **kwargs): + calls.append((document_id, user_id, kwargs)) + return report + + def unexpected_search(**kwargs): + raise AssertionError("A known complete comment inventory must not depend on relevance search.") + + namespace = { + "get_document_accessibility_payload": get_report, "search_documents": unexpected_search, + "annotate_document_search_payload": annotate_document_search_payload, + "build_excel_native_chat_evidence": excel.build_excel_native_chat_evidence, + "excel_native_question_sections": excel.excel_native_question_sections, + "EXCEL_EVIDENCE_MARKER": excel.EXCEL_EVIDENCE_MARKER, + "execute_tabular_evidence_sources": lambda sources, callback, mode, **kwargs: [callback(source) for source in sources], + } + _load_functions("route_backend_chats.py", {"_execute_excel_native_inspection_evidence"}, namespace) + result = namespace["_execute_excel_native_inspection_evidence"]( + [{"document_id": "doc", "scope": "group", "group_id": "group"}], + "List every cell note and threaded comment and the saved cell values", + "owner", "conversation", "selected", + ) + text = result["evidence_envelopes"][0]["summary"] + assert "Set cap to 19500." in text and "Hold approval." in text + assert "Keep cap at 15000." in text and "Arrange a review." in text + assert "Budget!B4" in text and "Delivery!B4" in text + assert "Native evidence segment 2" in text and "[#doc_2]" in text + assert len(text.encode("utf-8")) <= 16384 + assert calls[0][2]["active_group_ids"] == ["group"] + assert result["evidence_envelopes"][0]["coverage"]["worksheet_data_computed"] is False + + +def test_mixed_calculation_handoff_preserves_native_and_computed_evidence(review_workbook): + metadata, _ = excel.extract_excel_accessibility_metadata(review_workbook, ".xlsx") + report = {"document": {"id": "doc", "file_name": "review.xlsx"}, "accessibility_metadata": metadata} + native = { + "evidence_envelopes": [{"document_id": "doc", "status": "completed", "summary": "native", "citations": []}], + "agent_citations": [{"function_name": "get_document_accessibility_report", + "function_arguments": {"document_id": "doc"}, "function_result": report}], + } + computed = { + "evidence_envelopes": [{"document_id": "doc", "status": "completed", + "summary": "Computed total cap = 36000.", "coverage": {}, "citations": []}], + "agent_citations": [], + } + merged = excel.merge_excel_native_evidence(computed, native, "Calculate total cap and list comments") + text = merged["evidence_envelopes"][0]["summary"] + assert "Set cap to 19500." in text + assert "Computed total cap = 36000." in text + assert len(text.encode("utf-8")) <= 16384 + assert computed["evidence_envelopes"][0]["summary"] == "Computed total cap = 36000." diff --git a/functional_tests/test_excel_preview_route.py b/functional_tests/test_excel_preview_route.py new file mode 100644 index 000000000..ef33721a8 --- /dev/null +++ b/functional_tests/test_excel_preview_route.py @@ -0,0 +1,127 @@ +# test_excel_preview_route.py +""" +Functional tests for the real bounded Excel/CSV preview handler. +Version: 0.261.408 +Implemented in: 0.261.408 + +The route body and shared reader execute against real workbook packages. +Only authenticated-document lookup and external blob I/O are isolated. +""" + +import ast +import io +from pathlib import Path +import sys +from types import SimpleNamespace +import zipfile + +from flask import Flask, jsonify, request +import pandas +import pytest + +APP = Path(__file__).resolve().parents[1] / "application" / "single_app" +sys.path.insert(0, str(APP)) + +from content_screening.contracts import ScreeningError # noqa: E402 +from excel_workbook_reader import ExcelWorkbookReader, build_excel_table_preview # noqa: E402 +from test_excel_table_discovery_and_scale import five_tables # noqa: E402 + + +__all__ = ["five_tables"] + + +def preview_app(content, filename="tables.xlsx", allowed=True, failure=None): + source = (APP / "route_enhanced_citations.py").read_text(encoding="utf-8") + tree = ast.parse(source) + calls = {"reads": 0, "lookups": 0, "errors": []} + app = Flask(__name__) + document = {"id": "workbook", "file_name": filename, "user_id": "owner"} + + def get_document(user_id, document_id): + calls["lookups"] += 1 + assert user_id == "owner" and document_id == "workbook" + return (jsonify(document), 200) if allowed else (jsonify({"error": "Access denied."}), 403) + + def read_bytes(doc, **kwargs): + calls["reads"] += 1 + if failure is not None: + raise failure + return document, content + + namespace = { + "pandas": pandas, "io": io, "zipfile": zipfile, "jsonify": jsonify, "request": request, + "get_document": get_document, "get_current_user_id": lambda: "owner", + "get_settings": lambda: {}, "ScreeningError": ScreeningError, + "build_excel_table_preview": build_excel_table_preview, + "read_available_document_bytes": read_bytes, + "_resolve_document_blob_reference": lambda doc: ("container", "source"), + "_log_enhanced_citations_error": lambda *args, **kwargs: calls["errors"].append(args), + "CLIENTS": {"storage_account_office_docs_client": SimpleNamespace( + get_blob_client=lambda **kwargs: SimpleNamespace( + get_blob_properties=lambda: SimpleNamespace(size=len(content)), + ), + )}, + } + names = {"_sanitize_tabular_preview_value", "_serialize_tabular_preview_table", "_preview_integer"} + for node in tree.body: + if isinstance(node, ast.FunctionDef) and node.name in names: + exec(compile(ast.Module(body=[node], type_ignores=[]), "preview_helpers", "exec"), namespace) + registrar = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "register_enhanced_citations_routes") + handler = next(node for node in registrar.body if isinstance(node, ast.FunctionDef) and node.name == "get_enhanced_citation_tabular_preview") + handler.decorator_list = [] + exec(compile(ast.Module(body=[handler], type_ignores=[]), "preview_route", "exec"), namespace) + app.add_url_rule("/preview", view_func=namespace[handler.name]) + return app.test_client(), calls + + +def test_real_route_selects_each_table_and_retains_physical_rows(five_tables): + path, _, origins = five_tables + with ExcelWorkbookReader(path) as reader: + tables = reader.build_manifest()["sheets"][0]["tables"] + client, calls = preview_app(path.read_bytes()) + for index, (table, (header_row, _)) in enumerate(zip(tables, origins), start=1): + response = client.get("/preview", query_string={ + "doc_id": "workbook", "sheet_name": "Five tables", "table_id": table["id"], + "start_row": "2", "max_rows": "1", + }) + assert response.status_code == 200 + payload = response.get_json() + assert payload["columns"] == ["Case", "Amount"] + assert payload["rows"] == [[f"T{index}-3", str(index * 100 + 3)]] + assert payload["row_numbers"] == [header_row + 3] + assert payload["table_count"] == 5 and payload["has_more"] is False + assert calls["reads"] == 5 + + +def test_csv_paging_keeps_headers_and_reaches_late_records(): + content = ("Case,Amount\n" + "".join(f"C{index},{index}\n" for index in range(1, 15001))).encode() + client, _ = preview_app(content, "data.csv") + response = client.get("/preview", query_string={"doc_id": "workbook", "start_row": "14999", "max_rows": "2"}) + assert response.status_code == 200 + payload = response.get_json() + assert payload["columns"] == ["Case", "Amount"] + assert payload["rows"] == [["C15000", "15000"]] + assert payload["total_rows"] == 15000 and payload["row_numbers"] == [15001] + + +@pytest.mark.parametrize("query", [{"max_rows": "0"}, {"max_rows": "501"}, {"start_row": "-1"}, {"header_row": "bad"}]) +def test_invalid_windows_are_explicit_errors(query): + client, calls = preview_app(b"Case,Amount\nA,1\n", "data.csv") + response = client.get("/preview", query_string={"doc_id": "workbook", **query}) + assert response.status_code == 400 + assert calls["reads"] == 0 and calls["errors"] + + +def test_permission_denial_precedes_blob_access(): + client, calls = preview_app(b"private", allowed=False) + response = client.get("/preview", query_string={"doc_id": "workbook"}) + assert response.status_code == 403 + assert calls["reads"] == 0 + + +def test_provider_failure_never_reaches_browser(): + client, calls = preview_app(b"private", failure=RuntimeError("private-provider-secret-canary")) + response = client.get("/preview", query_string={"doc_id": "workbook"}) + assert response.status_code == 500 + assert "private-provider-secret-canary" not in response.get_data(as_text=True) + assert calls["errors"] diff --git a/functional_tests/test_excel_table_discovery_and_scale.py b/functional_tests/test_excel_table_discovery_and_scale.py new file mode 100644 index 000000000..2d0f6a252 --- /dev/null +++ b/functional_tests/test_excel_table_discovery_and_scale.py @@ -0,0 +1,144 @@ +# test_excel_table_discovery_and_scale.py +""" +Functional tests for streaming, table-aware saved Excel inspection. +Version: 0.261.408 +Implemented in: 0.261.408 + +Named and ordinary regions retain their own headers and cell coordinates. +Large fixtures are generated incrementally and neither metadata nor previews +materialize the complete dataset. +""" + +import hashlib +import json +import sys +from pathlib import Path + +import pytest +from openpyxl import Workbook +from openpyxl.worksheet.table import Table + +APP = Path(__file__).resolve().parents[1] / "application" / "single_app" +sys.path.insert(0, str(APP)) + + +def workbook_reader(path): + from excel_workbook_reader import ExcelWorkbookReader + return ExcelWorkbookReader(path) + + +@pytest.fixture(params=[False, True], ids=["ordinary-blocks", "named-tables"]) +def five_tables(request, tmp_path): + path = tmp_path / "five-tables.xlsx" + workbook = Workbook() + sheet = workbook.active + sheet.title = "Five tables" + origins = [(3, 1), (3, 5), (10, 1), (10, 5), (17, 1)] + for index, (row, column) in enumerate(origins, start=1): + sheet.cell(row - 1, column, f"Review table {index}") + sheet.cell(row, column, "Case") + sheet.cell(row, column + 1, "Amount") + for offset in range(1, 4): + sheet.cell(row + offset, column, f"T{index}-{offset}") + sheet.cell(row + offset, column + 1, index * 100 + offset) + if request.param: + from openpyxl.utils.cell import get_column_letter + ref = f"{get_column_letter(column)}{row}:{get_column_letter(column + 1)}{row + 3}" + sheet.add_table(Table(displayName=f"Review{index}", ref=ref)) + workbook.save(path) + return path, request.param, origins + + +def test_five_tables_have_independent_headers_ranges_and_values(five_tables): + path, named, origins = five_tables + before = hashlib.sha256(path.read_bytes()).digest() + with workbook_reader(path) as reader: + manifest = reader.build_manifest() + tables = manifest["sheets"][0]["tables"] + assert len(tables) == 5 + assert len({table["id"] for table in tables}) == 5 + for index, (table, (row, column)) in enumerate(zip(tables, origins), start=1): + assert table["header_row"] == row + assert table["min_column"] == column + assert table["row_count"] == 3 + assert table["origin"] == ("named" if named else "inferred") + assert [item["name"] for item in table["columns"]] == ["Case", "Amount"] + page = reader.read_table_page(table["id"], max_rows=2) + assert page["rows"] == [[f"T{index}-1", index * 100 + 1], [f"T{index}-2", index * 100 + 2]] + assert page["row_numbers"] == [row + 1, row + 2] + assert page["has_more"] is True and page["next_start_row"] == 2 + last = reader.read_table_page(table["id"], start_row=2, max_rows=2) + assert last["rows"] == [[f"T{index}-3", index * 100 + 3]] + assert last["has_more"] is False + assert hashlib.sha256(path.read_bytes()).digest() == before + + +@pytest.mark.parametrize("row_count", [50000, 100000]) +def test_large_workbook_last_row_and_compact_manifest(tmp_path, row_count): + path = tmp_path / f"large-{row_count}.xlsx" + workbook = Workbook(write_only=True) + sheet = workbook.create_sheet("Large data") + sheet.append(["Dataset review"]) + sheet.append(["Case", "Amount"]) + for index in range(1, row_count + 1): + sheet.append([f"CASE-{index:06d}", index]) + workbook.save(path) + with workbook_reader(path) as reader: + manifest = reader.build_manifest() + table = manifest["sheets"][0]["tables"][0] + assert table["header_row"] == 2 and table["row_count"] == row_count + assert len(json.dumps(manifest, ensure_ascii=True).encode()) < 20000 + page = reader.read_table_page(table["id"], start_row=row_count - 2, max_rows=2) + assert page["rows"] == [[f"CASE-{row_count - 1:06d}", row_count - 1], [f"CASE-{row_count:06d}", row_count]] + assert page["row_numbers"] == [row_count + 1, row_count + 2] + assert page["has_more"] is False + cells = reader.read_cells("Large data", [f"B{row_count + 2}"]) + assert cells[f"B{row_count + 2}"]["value"] == row_count + + +def test_repeated_headers_do_not_become_business_rows(tmp_path): + path = tmp_path / "repeated.xlsx" + workbook = Workbook() + sheet = workbook.active + for row in [ + ["Case", "Amount"], ["A", 10], ["B", 20], + ["Case", "Amount"], ["C", 30], + ]: + sheet.append(row) + workbook.save(path) + with workbook_reader(path) as reader: + table = reader.build_manifest()["sheets"][0]["tables"][0] + assert table["row_count"] == 3 + page = reader.read_table_page(table["id"]) + assert page["rows"] == [["A", 10], ["B", 20], ["C", 30]] + assert page["row_numbers"] == [2, 3, 5] + + +def test_empty_and_unlabelled_regions_do_not_invent_headers(tmp_path): + path = tmp_path / "unlabelled.xlsx" + workbook = Workbook() + workbook.active.title = "Values" + workbook.active.append([10, False]) + workbook.active.append([20, True]) + workbook.create_sheet("Empty") + workbook.save(path) + with workbook_reader(path) as reader: + manifest = reader.build_manifest() + table = manifest["sheets"][0]["tables"][0] + assert table["header_row"] is None + assert table["header_status"] == "absent" + assert table["row_count"] == 2 + assert manifest["sheets"][1]["tables"] == [] + page = reader.read_table_page(table["id"]) + assert page["columns"] == ["A", "B"] + assert page["rows"] == [[10, False], [20, True]] + + +def test_invalid_table_and_oversized_preview_are_rejected(five_tables): + path, _, _ = five_tables + with workbook_reader(path) as reader: + table = reader.build_manifest()["sheets"][0]["tables"][0] + with pytest.raises(ValueError, match="table"): + reader.read_table_page("../../another-document") + with pytest.raises(ValueError, match="max_rows"): + reader.read_table_page(table["id"], max_rows=501) diff --git a/functional_tests/test_mixed_source_chat_search_consistency.py b/functional_tests/test_mixed_source_chat_search_consistency.py index dd6af150f..1cac5a249 100644 --- a/functional_tests/test_mixed_source_chat_search_consistency.py +++ b/functional_tests/test_mixed_source_chat_search_consistency.py @@ -2,7 +2,7 @@ # test_mixed_source_chat_search_consistency.py """ Functional test for mixed-source Chat and Search consistency. -Version: 0.261.399 +Version: 0.261.408 Implemented in: 0.250.064; additive tabular evidence gating updated in 0.260.025; derived from Enhanced Citations in 0.261.266 @@ -35,7 +35,11 @@ sys.path.insert(0, str(APP_ROOT)) import functions_mixed_source_orchestration as orchestration # pyright: ignore[reportMissingImports] -from functions_excel_accessibility import is_excel_native_inspection_question +from functions_excel_accessibility import ( + has_excel_native_inspection_intent, + is_excel_native_inspection_question, + merge_excel_native_evidence, +) def _read(path): @@ -121,6 +125,8 @@ async def no_generated_output(**kwargs): namespace = { "asyncio": asyncio, "is_excel_native_inspection_question": is_excel_native_inspection_question, + "has_excel_native_inspection_intent": has_excel_native_inspection_intent, + "merge_excel_native_evidence": merge_excel_native_evidence, "has_request_context": lambda: False, "build_tabular_file_contexts_from_manifest": orchestration.build_tabular_file_contexts_from_manifest, "is_tabular_processing_enabled": lambda settings: settings.get("tabular", True), diff --git a/functional_tests/test_support/document_analysis.py b/functional_tests/test_support/document_analysis.py index 9e3583b00..4a3e3c98e 100644 --- a/functional_tests/test_support/document_analysis.py +++ b/functional_tests/test_support/document_analysis.py @@ -1,7 +1,7 @@ # document_analysis.py """Original-source fixtures and isolated SDK seams for the real Analyze producer. -Version: 0.261.407 +Version: 0.261.408 Implemented in: 0.261.109 """ @@ -134,6 +134,7 @@ def assert_group_role(user_id, group_id, **kwargs): cosmos_group_documents_container=screening_container('group'), cosmos_public_documents_container=screening_container('public'), cosmos_content_screening_container=None, + storage_account_content_screening_container_name='fixture-screening', ): targets = ('functions_search', 'functions_search_service', 'functions_document_analysis', 'functions_debug') originals = {name: sys.modules.get(name) for name in (*stubs, *targets)} diff --git a/functional_tests/test_tabular_enhanced_citations_schema_summary_fix.py b/functional_tests/test_tabular_enhanced_citations_schema_summary_fix.py index 06cd9a83a..855a7a8e2 100644 --- a/functional_tests/test_tabular_enhanced_citations_schema_summary_fix.py +++ b/functional_tests/test_tabular_enhanced_citations_schema_summary_fix.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 """ Functional test for enhanced-citation tabular schema summary fallback fix. -Version: 0.240.023 +Version: 0.261.408 Implemented in: 0.240.023 This test ensures enhanced-citation tabular uploads stay in schema-summary mode, @@ -20,6 +20,9 @@ sys.path.append(ROOT_DIR) sys.path.append(os.path.join(ROOT_DIR, 'application', 'single_app')) +from excel_workbook_reader import ExcelWorkbookReader # noqa: E402 +from functions_tabular_csv_query import read_tabular_csv # noqa: E402 +from test_support.versioning import assert_app_version_at_least # noqa: E402 FUNCTIONS_FILE = os.path.join(ROOT_DIR, 'application', 'single_app', 'functions_documents.py') CONFIG_FILE = os.path.join(ROOT_DIR, 'application', 'single_app', 'config.py') TARGET_FUNCTIONS = { @@ -58,6 +61,8 @@ def load_tabular_schema_helpers(): namespace = { 'os': os, 'pandas': pandas, + 'ExcelWorkbookReader': ExcelWorkbookReader, + 'read_tabular_csv': read_tabular_csv, } exec(compile(module, FUNCTIONS_FILE, 'exec'), namespace) return namespace, source @@ -137,7 +142,7 @@ def test_version_bump_applied(): try: version = read_config_version() - assert version == '0.240.023', version + assert_app_version_at_least("0.240.023") print('✅ Config version bump passed') return True diff --git a/functional_tests/test_tabular_group_blob_context_and_sheet_whitespace.py b/functional_tests/test_tabular_group_blob_context_and_sheet_whitespace.py index 321ce9caf..da8b8fe85 100644 --- a/functional_tests/test_tabular_group_blob_context_and_sheet_whitespace.py +++ b/functional_tests/test_tabular_group_blob_context_and_sheet_whitespace.py @@ -2,8 +2,9 @@ # test_tabular_group_blob_context_and_sheet_whitespace.py """ Functional test for tabular group blob context and sheet whitespace handling. -Version: 0.240.031 +Version: 0.261.408 Implemented in: 0.240.031 +Request-scoped authorization fixture updated in: 0.261.408 This test ensures workbook tabs with trailing whitespace still resolve correctly and that tabular analysis can reuse pre-resolved group blob @@ -14,7 +15,9 @@ import importlib.util import os import sys +from unittest.mock import patch +from flask import Flask, g import pandas as pd @@ -148,12 +151,35 @@ def test_resolved_group_blob_override_survives_missing_group_id(): 'group-123/CCO-Legal File Plan 2025_Final Approved.xlsx', ) - resolved_container, resolved_blob = plugin._resolve_blob_location_with_fallback( - 'test-user', - 'test-conversation', - 'CCO-Legal File Plan 2025_Final Approved.xlsx', - 'group', - ) + location = ('group-documents', 'group-123/CCO-Legal File Plan 2025_Final Approved.xlsx') + + def authorize_group(user_id, group_id, **kwargs): + assert (user_id, group_id) == ('test-user', 'group-123') + + def authorize_blob(container, blob, *, purpose='native'): + assert (container, blob) == location + return None, 'test-user' + + app = Flask(__name__) + with app.test_request_context('/'), patch.object( + PLUGIN_MODULE, 'get_current_user_id', return_value='test-user', + ), patch.object( + PLUGIN_MODULE, 'assert_group_role', side_effect=authorize_group, + ) as membership_check, patch.object( + PLUGIN_MODULE, 'resolve_available_blob_location', + side_effect=lambda container, blob, **kwargs: (container, blob), + ), patch.object(plugin, '_assert_blob_screening_access', side_effect=authorize_blob): + g.authorized_chat_context = { + 'user_id': 'test-user', 'conversation_id': 'test-conversation', + 'active_group_ids': ['group-123'], 'active_group_id': 'group-123', + } + resolved_container, resolved_blob = plugin._resolve_blob_location_with_fallback( + 'test-user', + 'test-conversation', + 'CCO-Legal File Plan 2025_Final Approved.xlsx', + 'group', + ) + assert membership_check.call_count == 1 assert resolved_container == 'group-documents', (resolved_container, resolved_blob) assert resolved_blob == 'group-123/CCO-Legal File Plan 2025_Final Approved.xlsx', (resolved_container, resolved_blob) diff --git a/functional_tests/test_tabular_large_result_pagination.py b/functional_tests/test_tabular_large_result_pagination.py index c142b54fd..1cb79ce3d 100644 --- a/functional_tests/test_tabular_large_result_pagination.py +++ b/functional_tests/test_tabular_large_result_pagination.py @@ -2,8 +2,9 @@ # test_tabular_large_result_pagination.py """ Functional test for tabular SK large-result pagination and output trimming. -Version: 0.250.155 +Version: 0.261.408 Implemented in: 0.242.067; bounded CSV query path in 0.250.060; source descriptor generalization in 0.250.127; serialized row-size estimation in 0.250.152; contains replay semantics in 0.250.155 +Explicit offline source authorization fixtures updated in: 0.261.408 This test ensures row-returning tabular processing tools support start_row/max_rows pagination, avoid skipped rows after auto-trimming oversized output, honor @@ -41,6 +42,15 @@ TabularProcessingPlugin = PLUGIN_MODULE.TabularProcessingPlugin +def authorize_fixture_source(plugin, container_name, blob_path): + """Keep row-shaping unit fixtures restricted to their one mocked source.""" + def authorize(container, blob, *, purpose="native"): + assert (container, blob) == (container_name, blob_path) + return None, 'test-user' + + plugin._assert_blob_screening_access = authorize + + class MockCsvBlobClient: """Minimal blob client for bounded CSV query tests.""" @@ -103,6 +113,11 @@ def read_dataframe(container, blob, sheet_name=None, sheet_index=None, require_e return workbook_frames[selected_sheet].copy() plugin._read_tabular_blob_to_dataframe = read_dataframe + # These row-shaping fixtures have frames, not an original workbook package. + # Real workbook replay and authorization are covered by the table-aware suite. + plugin._build_tabular_generated_export_internal_metadata = lambda **kwargs: { + 'tabular_generated_export_source_error': 'This in-memory fixture has no version-pinned original.', + } return plugin @@ -363,6 +378,7 @@ def test_query_tabular_csv_uses_bounded_shared_engine_and_exact_descriptor(): 'nested/version-7/large-results.csv', ) plugin._get_blob_service_client = lambda: MockCsvBlobServiceClient(csv_content) + authorize_fixture_source(plugin, 'mock-container', 'nested/version-7/large-results.csv') plugin._read_tabular_blob_to_dataframe = lambda *args, **kwargs: (_ for _ in ()).throw( AssertionError('CSV query must not use the whole-DataFrame reader') ) @@ -419,6 +435,7 @@ def test_filter_rows_csv_attaches_replayable_descriptor_for_full_cohort(): 'nested/version-7/large-results.csv', ) plugin._get_blob_service_client = lambda: MockCsvBlobServiceClient(csv_content) + authorize_fixture_source(plugin, 'mock-container', 'nested/version-7/large-results.csv') plugin._read_tabular_blob_to_dataframe = lambda *args, **kwargs: source_frame.copy() result = asyncio.run(plugin.filter_rows( @@ -477,6 +494,7 @@ def test_filter_rows_csv_contains_replay_uses_literal_semantics(): 'nested/version-7/large-results.csv', ) plugin._get_blob_service_client = lambda: MockCsvBlobServiceClient(csv_content) + authorize_fixture_source(plugin, 'mock-container', 'nested/version-7/large-results.csv') plugin._read_tabular_blob_to_dataframe = lambda *args, **kwargs: source_frame.copy() result = asyncio.run(plugin.filter_rows( @@ -530,6 +548,7 @@ def test_filter_rows_csv_rejects_non_replayable_normalized_matching(): 'nested/version-7/large-results.csv', ) plugin._get_blob_service_client = lambda: MockCsvBlobServiceClient(csv_content) + authorize_fixture_source(plugin, 'mock-container', 'nested/version-7/large-results.csv') plugin._read_tabular_blob_to_dataframe = lambda *args, **kwargs: source_frame.copy() result = asyncio.run(plugin.filter_rows( @@ -547,7 +566,7 @@ def test_filter_rows_csv_rejects_non_replayable_normalized_matching(): assert payload['total_matches'] == 2, payload assert 'tabular_generated_export_source' not in metadata, metadata - assert 'normalize_match=true' in metadata['tabular_generated_export_source_error'], metadata + assert 'bounded row-local query' in metadata['tabular_generated_export_source_error'], metadata print('✅ Normalized filter_rows replay rejection passed') return True @@ -579,6 +598,7 @@ def test_search_rows_csv_attaches_replayable_multi_column_descriptor(): 'nested/version-7/large-results.csv', ) plugin._get_blob_service_client = lambda: MockCsvBlobServiceClient(csv_content) + authorize_fixture_source(plugin, 'mock-container', 'nested/version-7/large-results.csv') plugin._read_tabular_blob_to_dataframe = lambda *args, **kwargs: source_frame.copy() result = asyncio.run(plugin.search_rows( diff --git a/functional_tests/test_tabular_model_token_budgets.py b/functional_tests/test_tabular_model_token_budgets.py index cc72a788a..76143da5c 100644 --- a/functional_tests/test_tabular_model_token_budgets.py +++ b/functional_tests/test_tabular_model_token_budgets.py @@ -1,8 +1,9 @@ # test_tabular_model_token_budgets.py """ Functional tests for scoped tabular model budgets and generation ceilings. -Version: 0.261.035 +Version: 0.261.408 Implemented in: 0.261.035 +Source checkpoint identity fixture updated in: 0.261.408 The principal regressions use the shipped catalog and real shared resolver. Only endpoint retrieval and model I/O are replaced with in-memory boundaries; @@ -35,7 +36,7 @@ ) from semantic_kernel.contents.chat_history import ChatHistory as SKChatHistory -from test_tabular_row_orchestration_scale import _load_performance_helpers +from test_tabular_row_orchestration_scale import _load_contract_helpers, _load_performance_helpers # The shared standalone harness establishes the application import path first. from functions_model_budget_runtime import prepare_model_execution_settings @@ -743,11 +744,15 @@ def test_large_context_threshold_and_small_input_boundary_are_preserved(): def test_small_character_budget_survives_source_staging(): helpers, _ = _load_budget_helpers() + contracts = _load_contract_helpers() + helpers['_prepare_tabular_source_rows'] = contracts['_prepare_tabular_source_rows'] source_rows = [{'value': 'x' * 1700} for _ in range(3)] checkpoints = [] def checkpoint(run, rows, source_scan_row_count): - checkpoints.append(list(rows)) + checkpoints.append(contracts['_prepare_tabular_source_rows']( + rows, start_row=run.get('source_staged_rows', 0), token_namespace=run['id'], + )) run['source_staged_rows'] = run.get('source_staged_rows', 0) + len(rows) run['source_staged_batches'] = len(checkpoints) run['source_scan_row_count'] = source_scan_row_count @@ -755,7 +760,7 @@ def checkpoint(run, rows, source_scan_row_count): helpers.update({ 'TABULAR_EXTENSIONS': {'csv'}, - '_iter_versioned_tabular_source_rows': lambda *args: enumerate(source_rows, start=1), + '_iter_versioned_tabular_source_rows': lambda *args, **kwargs: enumerate(source_rows, start=1), '_dump_generated_output_json': json.dumps, '_checkpoint_source_input_batch': checkpoint, '_input_blob_path': lambda *args: args[-1], diff --git a/functional_tests/test_tabular_preview_json_sanitization_fix.py b/functional_tests/test_tabular_preview_json_sanitization_fix.py index 2af713e32..d543b1092 100644 --- a/functional_tests/test_tabular_preview_json_sanitization_fix.py +++ b/functional_tests/test_tabular_preview_json_sanitization_fix.py @@ -2,7 +2,7 @@ # test_tabular_preview_json_sanitization_fix.py """ Functional test for tabular preview JSON sanitization. -Version: 0.240.030 +Version: 0.261.408 Implemented in: 0.240.030 This test ensures the enhanced citation tabular preview converts pandas null-like @@ -131,8 +131,8 @@ def test_route_uses_serialized_preview_output_and_version_bump(): _, source = load_preview_helpers() required_snippets = [ - 'columns, rows = _serialize_tabular_preview_table(preview)', - '"columns": columns,', + 'names, rows = _serialize_tabular_preview_table(frame)', + 'result["columns"], result["rows"] = _serialize_tabular_preview_table(frame)', '"rows": rows,', ] missing = [snippet for snippet in required_snippets if snippet not in source] diff --git a/functional_tests/test_tabular_row_orchestration_scale.py b/functional_tests/test_tabular_row_orchestration_scale.py index a8fdc94b4..780c8173b 100644 --- a/functional_tests/test_tabular_row_orchestration_scale.py +++ b/functional_tests/test_tabular_row_orchestration_scale.py @@ -1,8 +1,10 @@ # test_tabular_row_orchestration_scale.py """ Functional test for scalable per-row tabular orchestration. -Version: 0.261.396 +Version: 0.261.408 Updated in: 0.261.035 for shared model-budget resolution and scoped batching. +Table-aware descriptors and real-package replay fixtures updated in: 0.261.408 +SDK-default conversation/message fixture contracts updated in: 0.261.408 Implemented in: 0.250.060; generated CSV formula safety in 0.250.065; generated file export routing in 0.250.072; source descriptor generalization in 0.250.127; unified durable run contract in 0.250.128; hierarchical analysis in 0.250.129; combined analysis and export in 0.250.130; scale validation in 0.250.132; direct source-backed exhaustive queueing in 0.250.133; direct queue call-site hardening in 0.250.134; model-validation auto retry in 0.250.135; model-aware parallel throughput in 0.250.136; Phase 1 acceleration contracts and observability in 0.250.137; Phase 2 truthful background handoff in 0.250.138; Phase 3 durable LLM generation planning in 0.250.139; Phase 4 compact row response protocol in 0.250.140; Phase 5 completion-driven checkpointing in 0.250.141; Phase 6 rolling worker pool in 0.250.142; Phase 7 independent batch retries in 0.250.143; Phase 8 scale, chaos, and rollout in 0.250.144; background metadata streaming fix in 0.250.145; source-token echo recovery in 0.250.146; fixed-window stale heartbeat fix in 0.250.147; nested CSV output recovery in 0.250.148; generic tabular artifact routing and fast startup in 0.250.149; balanced concurrency waves and default completion checkpoints in 0.250.152; Search shared preflight adapter in 0.250.159; aggregate route-helper harness coverage in 0.250.166; Analyze artifact Phase 7A harness compatibility updated in 0.250.178; reviewed correctness planning and semantic validation updated in 0.250.179; artifact publication lifecycle updated in 0.250.180; safe failure helper compatibility updated in 0.250.199; exhaustive Markdown scale compatibility updated in 0.250.200 This test ensures generated exports preserve source identity and row order while @@ -12,6 +14,7 @@ import ast import asyncio import csv +from copy import deepcopy import heapq import hashlib import io @@ -21,6 +24,7 @@ import math import os import pandas +import pytest import re import sys import time @@ -31,7 +35,9 @@ from collections import Counter from typing import Any, Dict, Optional +from azure.core import MatchConditions from azure.cosmos._cosmos_responses import CosmosDict +from azure.cosmos.exceptions import CosmosHttpResponseError, CosmosResourceNotFoundError REPO_ROOT = Path(__file__).resolve().parents[1] @@ -127,7 +133,10 @@ 'iter_tabular_csv_query_rows', 'validate_tabular_csv_query_expression', } -AUTHORIZATION_FUNCTIONS = {'_authorize_tabular_export_run_execution'} +AUTHORIZATION_FUNCTIONS = { + '_authorize_tabular_export_run_conversation', + '_authorize_tabular_export_run_execution', +} CANCELLATION_FUNCTIONS = { '_is_artifact_publication_recoverable', '_can_cancel_run', @@ -640,55 +649,6 @@ def _load_tabular_request_intent_helpers(): return namespace -def _load_tabular_descriptor_builder(): - """Load the plugin's version-pinned tabular descriptor builder in isolation.""" - module_tree = ast.parse( - TABULAR_PLUGIN_MODULE.read_text(encoding='utf-8'), - filename=str(TABULAR_PLUGIN_MODULE), - ) - plugin_class = next( - node - for node in module_tree.body - if isinstance(node, ast.ClassDef) and node.name == 'TabularProcessingPlugin' - ) - function_node = next( - node - for node in plugin_class.body - if isinstance(node, ast.FunctionDef) - and node.name == '_build_generated_export_query_descriptor_from_location' - ) - namespace = { - 'List': list, - 'Optional': Optional, - 'validate_tabular_csv_query_expression': _load_source_reader_helpers()[ - 'validate_tabular_csv_query_expression' - ], - } - exec( - compile(ast.Module(body=[function_node], type_ignores=[]), str(TABULAR_PLUGIN_MODULE), 'exec'), - namespace, - ) - return namespace['_build_generated_export_query_descriptor_from_location'] - - -def _load_tabular_source_replay_helper(fake_plugin, version_checks): - """Load durable tabular replay with a fake workbook parser and version check.""" - function_node = _get_function_node('_iter_versioned_tabular_source_rows') - namespace = { - 'MatchConditions': SimpleNamespace(IfNotModified='if-not-modified'), - 'TABULAR_EXPORT_FINAL_SPOOL_MAX_MEMORY_BYTES': 1024 * 1024, - 'TabularProcessingPlugin': lambda: fake_plugin, - '_get_versioned_source_blob_client': lambda descriptor: version_checks.append(descriptor) or object(), - 'iter_tabular_csv_query_rows': lambda **kwargs: (), - 'tempfile': __import__('tempfile'), - } - exec( - compile(ast.Module(body=[function_node], type_ignores=[]), str(EXPORT_MODULE), 'exec'), - namespace, - ) - return namespace['_iter_versioned_tabular_source_rows'] - - def _build_query_invocation(start_row, row_count, total_matches=300, source_etag='etag-source-7'): class InvocationPayload(dict): pass @@ -953,13 +913,15 @@ def upload_json_blob(path, payload, metadata=None): def _load_authorization_helper(conversation_owner, visible_public_ids=None, group_authorizer=None): - class CosmosResourceNotFoundError(Exception): - pass - class ConversationContainer: def read_item(self, item, partition_key): - assert item == partition_key - return CosmosDict({'id': item, 'user_id': conversation_owner}, response_headers={}) + if item != partition_key: + raise CosmosResourceNotFoundError(status_code=404, message='Conversation partition not found.') + etag = f'"conversation-{item}-1"' + return CosmosDict( + {'id': item, 'user_id': conversation_owner, '_etag': etag}, + response_headers={'etag': etag}, + ) module_tree = ast.parse(EXPORT_MODULE.read_text(encoding='utf-8'), filename=str(EXPORT_MODULE)) selected_nodes = [ @@ -1376,12 +1338,15 @@ def _assert_concise_background_handoff_contract(text, expected_row_count, expect def _load_idempotent_artifact_helper(): - class CosmosResourceNotFoundError(Exception): - pass - class ConversationContainer: def read_item(self, item, partition_key): - return CosmosDict({'id': item, 'user_id': 'user-1'}, response_headers={}) + if item != partition_key: + raise CosmosResourceNotFoundError(status_code=404, message='Conversation partition not found.') + etag = f'"conversation-{item}-1"' + return CosmosDict( + {'id': item, 'user_id': 'user-1', '_etag': etag}, + response_headers={'etag': etag}, + ) class MessageContainer: def __init__(self): @@ -1389,14 +1354,26 @@ def __init__(self): self.upsert_count = 0 def read_item(self, item, partition_key): - if item not in self.items: - raise CosmosResourceNotFoundError() - return CosmosDict(dict(self.items[item]), response_headers={}) - - def upsert_item(self, item): - self.items[item['id']] = dict(item) + key = (partition_key, item) + if key not in self.items: + raise CosmosResourceNotFoundError(status_code=404, message='Message partition not found.') + saved = deepcopy(self.items[key]) + return CosmosDict(saved, response_headers={'etag': saved['_etag']}) + + def upsert_item(self, body, *, etag=None, match_condition=None): + if not isinstance(body, dict) or not body.get('id') or not body.get('conversation_id'): + raise ValueError('A message id and conversation partition are required.') + key = (body['conversation_id'], body['id']) + current = self.items.get(key) + if match_condition == MatchConditions.IfNotModified and ( + current is None or current['_etag'] != etag + ): + raise CosmosHttpResponseError(status_code=412, message='Message ETag changed.') + saved = deepcopy(dict(body)) + saved['_etag'] = f'"message-{self.upsert_count + 1}"' + self.items[key] = saved self.upsert_count += 1 - return CosmosDict(dict(item), response_headers={}) + return CosmosDict(deepcopy(saved), response_headers={'etag': saved['_etag']}) class BlobClient: def __init__(self): @@ -4849,102 +4826,79 @@ def test_downloadable_complete_csv_request_uses_shared_artifact_intent(): assert helpers['question_requests_tabular_generated_output'](user_question) is True -def test_durable_tabular_descriptor_supports_all_configured_formats(): - """Version-pinned replay descriptors cover CSV and every supported workbook type.""" - descriptor_builder = _load_tabular_descriptor_builder() - - class FakeDescriptorPlugin: - SUPPORTED_EXTENSIONS = ('.csv', '.xls', '.xlsm', '.xlsx') - - @staticmethod - def _infer_source_from_container(container_name): - assert container_name == 'user-documents' - return 'workspace' +def test_durable_tabular_descriptor_supports_all_configured_formats(monkeypatch): + """Build real version-pinned descriptors without replacing authorization or readers.""" + # Import the runtime harness at execution time so its I/O seams cannot leak + # into the other AST-only tests in this module. + from test_native_tabular_compute_service import USER, native_runtime + from test_tabular_table_aware_analytics_replay import _legacy_workbook_bytes, _one_table, _set_source - @staticmethod - def _get_tabular_blob_version(*args, **kwargs): - raise AssertionError('The supplied version pin must be used') - - plugin = FakeDescriptorPlugin() for source_format in ('csv', 'xlsx', 'xls', 'xlsm'): is_workbook = source_format != 'csv' - descriptor = descriptor_builder( - plugin, - container_name='user-documents', - blob_path=f'user-1/source.{source_format}', - filename=f'source.{source_format}', - query_expression='index == index', - expected_row_count=12, - blob_version={'blob_etag': 'etag-12', 'blob_size': 2048}, - sheet_names=['First', 'Second'] if is_workbook else None, - ) - - assert descriptor['source_format'] == source_format - assert descriptor['expected_row_count'] == 12 - assert descriptor['blob_etag'] == 'etag-12' - if is_workbook: - assert descriptor['sheet_names'] == ['First', 'Second'] - else: - assert 'sheet_names' not in descriptor - - -def test_durable_workbook_replay_preserves_sheet_order_and_resume_position(): - """Workbook rows replay in sheet order and resume after the last staged physical row.""" - class FakeWorkbookPlugin: - def __init__(self): - self.frames = { - 'First': pandas.DataFrame([ - {'Item_ID': 'A-1', 'Value': 'one'}, - {'Item_ID': 'A-2', 'Value': 'two'}, - ]), - 'Second': pandas.DataFrame([ - {'Item_ID': 'B-1', 'Value': 'three'}, - ]), - } - - @staticmethod - def _parse_optional_column_list_argument(value): - assert value is None - return None - - def _read_tabular_blob_to_dataframe(self, container, blob_path, sheet_name, require_explicit_sheet): - assert container == 'user-documents' - assert blob_path == 'user-1/source.xlsx' - assert require_explicit_sheet is True - return self.frames[sheet_name].copy() - - @staticmethod - def _try_numeric_conversion(dataframe): - return dataframe + count = 1 if source_format == 'xls' else 12 + with native_runtime(monkeypatch, row_count=12, filename=f'source.{source_format}') as runtime: + if is_workbook: + _set_source(runtime, _legacy_workbook_bytes() if source_format == 'xls' else _one_table(12)) + plugin = runtime.engine.TabularProcessingPlugin(authorized_user_id=USER) + metadata = plugin._get_workbook_metadata('user-documents', f'{USER}/source.{source_format}') + version = plugin._get_tabular_blob_version('user-documents', f'{USER}/source.{source_format}', refresh=True) + descriptor = plugin._build_generated_export_query_descriptor_from_location( + container_name='user-documents', blob_path=f'{USER}/source.{source_format}', + filename=f'source.{source_format}', query_expression='index == index', + expected_row_count=count, blob_version=version, + sheet_names=metadata['sheet_names'] if is_workbook else None, + ) + replayed = list(runtime.engine._iter_versioned_tabular_source_rows( + descriptor, source_format, 3, 0, user_id=USER, + )) + assert descriptor['source_format'] == source_format + assert descriptor['expected_row_count'] == len(replayed) == count + assert descriptor['blob_etag'] == 'source-blob-1' + if is_workbook: + assert descriptor['version'] == 2 and descriptor['source_row_count'] == count + assert len(descriptor['table_selections']) == 1 + assert replayed[-1][1]['_excel_source']['row'] == (1 if source_format == 'xls' else 14) + else: + assert descriptor['version'] == 1 and 'sheet_names' not in descriptor - @staticmethod - def _apply_query_expression_with_fallback(dataframe, query_expression, normalize_match): - assert query_expression == 'index == index' - assert normalize_match is False - return dataframe.query(query_expression), False - @staticmethod - def _build_row_output_records(dataframe, selected_columns): - return dataframe[selected_columns].to_dict(orient='records') +def test_durable_workbook_replay_preserves_sheet_order_and_resume_position(monkeypatch): + """Replay real selected tables; keep physical rows separate from resume cursors.""" + # Keep application imports and external-I/O seams scoped to this runtime. + from test_native_tabular_compute_service import USER, native_runtime + from test_tabular_table_aware_analytics_replay import _set_source, _workbook_bytes - version_checks = [] - replay_rows = _load_tabular_source_replay_helper(FakeWorkbookPlugin(), version_checks) - descriptor = { - 'container': 'user-documents', - 'blob_path': 'user-1/source.xlsx', - 'blob_etag': 'etag-source', - 'query_expression': 'index == index', - 'return_columns': None, - 'sheet_names': ['First', 'Second'], - } - - all_rows = list(replay_rows(descriptor, 'xlsx', 1000, 0)) - resumed_rows = list(replay_rows(descriptor, 'xlsx', 1000, 2)) - - assert [source_row_number for source_row_number, _ in all_rows] == [1, 2, 3] - assert [row['Item_ID'] for _, row in all_rows] == ['A-1', 'A-2', 'B-1'] - assert resumed_rows == [(3, {'Item_ID': 'B-1', 'Value': 'three'})] - assert len(version_checks) == 4 + with native_runtime(monkeypatch, filename='source.xlsx') as runtime: + _set_source(runtime, _workbook_bytes([ + { + 'name': 'First', 'rows': { + 2: {1: 'Item_ID', 2: 'Value'}, 3: {1: 'A-1', 2: 'one'}, 4: {1: 'A-2', 2: 'two'}, + }, + }, + { + 'name': 'Second', 'rows': {7: {1: 'Item_ID', 2: 'Value'}, 8: {1: 'B-1', 2: 'three'}}, + }, + ])) + plugin = runtime.engine.TabularProcessingPlugin(authorized_user_id=USER) + descriptor = plugin._build_generated_export_query_descriptor_from_location( + container_name='user-documents', blob_path=f'{USER}/source.xlsx', filename='source.xlsx', + query_expression='index == index', sheet_names=['First', 'Second'], expected_row_count=3, + ) + all_rows = list(runtime.engine._iter_versioned_tabular_source_rows( + descriptor, 'xlsx', 1, 0, user_id=USER, + )) + resumed_rows = list(runtime.engine._iter_versioned_tabular_source_rows( + descriptor, 'xlsx', 1, 2, user_id=USER, + )) + assert [cursor for cursor, _ in all_rows] == [1, 2, 3] + assert [row['Item_ID'] for _, row in all_rows] == ['A-1', 'A-2', 'B-1'] + assert [row['_excel_source']['row'] for _, row in all_rows] == [3, 4, 8] + assert resumed_rows == all_rows[-1:] + descriptor['version'] = 1 + with pytest.raises(ValueError, match='legacy worksheet-header'): + list(runtime.engine._iter_versioned_tabular_source_rows( + descriptor, 'xlsx', 1, 0, user_id=USER, + )) def test_direct_source_backed_queue_supports_all_workbook_formats(): @@ -5875,6 +5829,32 @@ def authorize_group(user_id, group_id, allowed_roles): authorize_public(public_run) +def test_sdk_default_authorization_conversation_points_preserve_owner_etag_and_partition(): + """Execute the actual fixture and its conversation-ownership consumer with SDK points.""" + authorize = _load_authorization_helper('user-1') + container = authorize.__globals__['cosmos_conversations_container'] + first = container.read_item(item='conversation-1', partition_key='conversation-1') + assert type(first) is CosmosDict + assert first['id'] == 'conversation-1' and first['user_id'] == 'user-1' + assert first['_etag'] + first['user_id'] = 'client-mutation' + again = container.read_item(item='conversation-1', partition_key='conversation-1') + authorized = authorize({ + 'id': 'sdk-conversation-contract', 'user_id': 'user-1', 'conversation_id': 'conversation-1', + }) + assert type(again) is type(authorized) is CosmosDict + assert again['user_id'] == authorized['user_id'] == 'user-1' + assert again['_etag'] == authorized['_etag'] == first['_etag'] + with pytest.raises(CosmosResourceNotFoundError) as missing: + container.read_item(item='conversation-1', partition_key='another-conversation') + assert missing.value.status_code == 404 + wrong_owner = _load_authorization_helper('another-owner') + with pytest.raises(PermissionError, match='ownership'): + wrong_owner({ + 'id': 'sdk-conversation-contract', 'user_id': 'user-1', 'conversation_id': 'conversation-1', + }) + + def test_durable_cancellation_is_idempotent_and_terminal(): """Cancel persists a terminal state that cannot be resumed or canceled again.""" helpers, stored_run = _load_cancellation_helpers({ @@ -6252,6 +6232,72 @@ def test_final_artifact_publication_is_retry_idempotent(): assert message_container.upsert_count == 1 +def test_sdk_default_artifact_conversation_points_preserve_owner_etag_and_partition(): + """The publication fixture's point reads are real SDK mappings, not plain substitutes.""" + upload, _ = _load_idempotent_artifact_helper() + container = upload.__globals__['cosmos_conversations_container'] + first = container.read_item(item='conversation-1', partition_key='conversation-1') + assert type(first) is CosmosDict + assert first == { + 'id': 'conversation-1', 'user_id': 'user-1', '_etag': first['_etag'], + } + first['user_id'] = 'client-mutation' + again = container.read_item(item='conversation-1', partition_key='conversation-1') + assert type(again) is CosmosDict + assert again['user_id'] == 'user-1' and again['_etag'] == first['_etag'] + with pytest.raises(CosmosResourceNotFoundError) as missing: + container.read_item(item='conversation-1', partition_key='another-conversation') + assert missing.value.status_code == 404 + + +def test_sdk_default_artifact_message_points_preserve_versions_partitions_and_atomic_failures(): + """Exercise SDK writes/reads, nested isolation, partitions, and conditional failure atomicity.""" + _, container = _load_idempotent_artifact_helper() + body = { + 'id': 'same-message', 'conversation_id': 'conversation-1', 'metadata': {'value': 'original'}, + } + created = container.upsert_item(body=body) + other = container.upsert_item(body={ + **body, 'conversation_id': 'conversation-2', 'metadata': {'value': 'other-partition'}, + }) + body['metadata']['value'] = 'mutated-input' + created['metadata']['value'] = 'mutated-response' + first_read = container.read_item(item='same-message', partition_key='conversation-1') + other_read = container.read_item(item='same-message', partition_key='conversation-2') + assert all(type(document) is CosmosDict for document in (created, other, first_read, other_read)) + assert type(first_read['metadata']) is dict + assert first_read['metadata'] == {'value': 'original'} + assert other_read['metadata'] == {'value': 'other-partition'} + assert first_read['_etag'] == created['_etag'] != other_read['_etag'] == other['_etag'] + with pytest.raises(CosmosResourceNotFoundError) as missing: + container.read_item(item='same-message', partition_key='unrelated-conversation') + assert missing.value.status_code == 404 + updated = container.upsert_item( + body={**first_read, 'metadata': {'value': 'updated'}}, + etag=first_read['_etag'], match_condition=MatchConditions.IfNotModified, + ) + saved = container.read_item(item='same-message', partition_key='conversation-1') + assert type(updated) is type(saved) is CosmosDict + assert saved['metadata'] == {'value': 'updated'} and saved['_etag'] != first_read['_etag'] + before = deepcopy(container.items) + writes_before = container.upsert_count + with pytest.raises(CosmosHttpResponseError) as stale: + container.upsert_item( + body={**first_read, 'metadata': {'value': 'stale-write'}}, + etag=first_read['_etag'], match_condition=MatchConditions.IfNotModified, + ) + assert stale.value.status_code == 412 + with pytest.raises(CosmosHttpResponseError) as absent: + container.upsert_item( + body={'id': 'missing', 'conversation_id': 'conversation-1'}, + etag='missing-etag', match_condition=MatchConditions.IfNotModified, + ) + assert absent.value.status_code == 412 + with pytest.raises(ValueError, match='partition'): + container.upsert_item(body={'id': 'without-partition'}) + assert container.items == before and container.upsert_count == writes_before + + def test_scheduler_filters_before_limiting_candidates(): """Ineligible rows before the scan limit cannot hide an older recoverable run.""" runs = [ diff --git a/functional_tests/test_tabular_table_aware_analytics_replay.py b/functional_tests/test_tabular_table_aware_analytics_replay.py new file mode 100644 index 000000000..a8550a181 --- /dev/null +++ b/functional_tests/test_tabular_table_aware_analytics_replay.py @@ -0,0 +1,952 @@ +# test_tabular_table_aware_analytics_replay.py +""" +Real-package tests for table-aware analytics and version-pinned durable replay. +Version: 0.261.408 +Implemented in: 0.261.408 + +The existing offline native runtime replaces external I/O, not the workbook +reader, public analytical tools, source staging, checkpoints, or result reader. +OOXML packages are built in memory without Excel execution or temporary files. +""" + +import asyncio +from copy import deepcopy +import importlib +import io +import json +import struct +from xml.sax.saxutils import escape, quoteattr +import zipfile + +from flask import Flask, g +import pytest + +from test_native_tabular_compute_service import ( + CONVERSATION, + USER, + compute_plan, + native_runtime, + open_result, + submit, +) + + +MAIN_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main" +REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships" +PACKAGE_NS = "http://schemas.openxmlformats.org/package/2006/relationships" +CONTENT_NS = "http://schemas.openxmlformats.org/package/2006/content-types" + + +def _column_name(column): + result = "" + while column: + column, remainder = divmod(column - 1, 26) + result = chr(65 + remainder) + result + return result + + +def _workbook_bytes(sheets): + """Build a real spreadsheet package, including independently named tables.""" + contents = io.BytesIO() + overrides = [ + '', + ] + workbook_sheets, workbook_relationships = [], [] + table_number = 0 + with zipfile.ZipFile(contents, "w", compression=zipfile.ZIP_DEFLATED) as package: + package.writestr( + "_rels/.rels", + f'', + ) + for sheet_number, sheet in enumerate(sheets, start=1): + name, rows, tables = sheet["name"], sheet["rows"], sheet.get("tables") or [] + workbook_sheets.append( + f'' + ) + workbook_relationships.append( + f'' + ) + overrides.append( + f'' + ) + table_parts, table_relationships = [], [] + for name, reference, columns in tables: + table_number += 1 + table_parts.append(f'') + table_relationships.append( + f'' + ) + table_columns = "".join( + f'' + for index, column in enumerate(columns, start=1) + ) + package.writestr( + f"xl/tables/table{table_number}.xml", + f'' + f'' + f'{table_columns}
', + ) + overrides.append( + f'' + ) + worksheet_rows = [] + for row_number, cells in sorted(rows.items()): + serialized_cells = [] + for column, value in sorted(cells.items()): + reference = f"{_column_name(column)}{row_number}" + if isinstance(value, tuple) and value[0] == "formula": + cached = f"{escape(str(value[2]))}" if value[2] is not None else "" + body = f"{escape(value[1])}{cached}" + serialized_cells.append(f'{body}') + elif isinstance(value, bool): + serialized_cells.append(f'{int(value)}') + elif isinstance(value, (int, float)): + serialized_cells.append(f'{value}') + elif value is not None: + serialized_cells.append( + f'' + f'{escape(str(value))}' + ) + worksheet_rows.append(f'{"".join(serialized_cells)}') + table_xml = ( + f'{"".join(table_parts)}' + if table_parts else "" + ) + package.writestr( + f"xl/worksheets/sheet{sheet_number}.xml", + f'' + f'{"".join(worksheet_rows)}{table_xml}', + ) + if table_relationships: + package.writestr( + f"xl/worksheets/_rels/sheet{sheet_number}.xml.rels", + f'{"".join(table_relationships)}', + ) + package.writestr( + "xl/workbook.xml", + f'' + f'{"".join(workbook_sheets)}', + ) + package.writestr( + "xl/_rels/workbook.xml.rels", + f'{"".join(workbook_relationships)}', + ) + package.writestr( + "[Content_Types].xml", + f'' + f'{"".join(overrides)}', + ) + return contents.getvalue() + + +def _five_tables(named): + rows, tables = {}, [] + origins = [(3, 1), (3, 5), (10, 1), (10, 5), (17, 1)] + for index, (header, column) in enumerate(origins, start=1): + rows.setdefault(header - 1, {})[column] = f"Review table {index}" + rows.setdefault(header, {}).update({column: "Case", column + 1: "Amount"}) + for offset in range(1, 4): + rows.setdefault(header + offset, {}).update({ + column: f"T{index}-{offset}", column + 1: index * 100 + offset, + }) + if named: + reference = f"{_column_name(column)}{header}:{_column_name(column + 1)}{header + 3}" + tables.append((f"Review{index}", reference, ["Case", "Amount"])) + return _workbook_bytes([{"name": "Five tables", "rows": rows, "tables": tables}]), origins + + +def _one_table(count=3, *, header=2, table_name=None, column="amount"): + rows = {header - 1: {1: "Saved dataset"}, header: {1: "Item_ID", 2: column}} + rows.update({ + header + index: {1: f"item-{index:06d}", 2: index} + for index in range(1, count + 1) + }) + tables = [(table_name, f"A{header}:B{header + count}", ["Item_ID", column])] if table_name else [] + return _workbook_bytes([{"name": "Data", "rows": rows, "tables": tables}]) + + +def _legacy_workbook_bytes(): + """A real BIFF8/OLE workbook with one saved numeric cell and no header.""" + def record(code, payload=b""): + return struct.pack("=", "filter_value": "0"}), + ("query_tabular_data", {"query_expression": "amount >= 0"}), + ("lookup_value", {"lookup_column": "Item_ID", "lookup_value": "missing", "target_column": "amount"}), + ]: + payload, _ = _call(runtime, plugin, operation, table_id="Facts", **arguments) + assert payload["error_code"] == "formula_cache_missing", payload + assert "result" not in payload and "value" not in payload and "row_count" not in payload + saved, _ = _call( + runtime, plugin, "lookup_value", table_id="Facts", lookup_column="Item_ID", + lookup_value="saved", target_column="amount", + ) + assert saved["value"] == 30 + irrelevant, invocation = _call( + runtime, plugin, "query_tabular_data", table_id="Facts", + query_expression='Item_ID == "missing"', return_columns="Item_ID", + ) + assert irrelevant["total_matches"] == 1 + descriptor = invocation.internal_metadata["tabular_generated_export_source"] + assert len(list(_replay(runtime, descriptor))) == 1 + descriptor["return_columns"] = None + with pytest.raises(ValueError, match="cached"): + list(_replay(runtime, descriptor)) + counted, _ = _call( + runtime, plugin, "count_rows", query_expression='Item_ID == "amount"', + table_id="Facts", + ) + assert counted["row_count"] == 0 + + +def test_explicit_all_native_tables_keep_heterogeneous_identities(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _workbook_bytes([{ + "name": "Data", + "rows": { + 3: {1: "Item_ID", 2: "amount"}, 4: {1: "A", 2: 10}, 5: {1: "B", 2: 20}, + 10: {1: "Region", 2: "Units", 3: "Flag"}, + 11: {1: "East", 2: 4, 3: True}, 12: {1: "West", 2: 8, 3: False}, + }, + "tables": [ + ("Facts", "A3:B5", ["Item_ID", "amount"]), + ("Regions", "A10:C12", ["Region", "Units", "Flag"]), + ], + }])) + descriptor = _descriptor(runtime, table_id="all", expected_row_count=4) + assert len(descriptor["table_selections"]) == 2 + rows = list(_replay(runtime, descriptor)) + assert [cursor for cursor, _ in rows] == [1, 2, 3, 4] + assert set(rows[0][1]) == {"Item_ID", "amount", "_excel_source"} + assert set(rows[2][1]) == {"Region", "Units", "Flag", "_excel_source"} + assert [row["_excel_source"]["row"] for _, row in rows] == [4, 5, 11, 12] + assert len({row["_excel_source"]["table_id"] for _, row in rows}) == 2 + plan = compute_plan(runtime, durable=True) + plan["requested_output_hints"]["selected_table"] = "all" + request = runtime.service._compute_request(plan, "Compute doubled amounts.") + candidate, pinned = runtime.service._prepare_native_source( + runtime.engine, runtime.source_manifest[0], request, USER, + ) + assert pinned["expected_row_count"] == candidate["total_matches"] == 4 + assert len(candidate["table_selections"]) == 2 + assert candidate["full_result_available"] is False + foreground, _ = _call( + runtime, _plugin(runtime), "aggregate_column", table_id="all", column="amount", operation="sum", + ) + assert foreground["error_code"] == "table_schema_mismatch" + + +def test_related_tables_use_independent_ranges_and_physical_rows(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _workbook_bytes([{ + "name": "Data", + "rows": { + 3: {1: "Owner", 2: "Team"}, 4: {1: "Ada", 2: "Blue"}, + 5: {1: "Bea", 2: "Green"}, 10: {1: "Assignee", 2: "amount"}, + 11: {1: "Ada", 2: ("formula", "1+2", None)}, 12: {1: "Bea", 2: 20}, + }, + "tables": [ + ("People", "A3:B5", ["Owner", "Team"]), + ("Work", "A10:B12", ["Assignee", "amount"]), + ], + }])) + arguments = { + "source_sheet_name": "Data", "source_value_column": "Owner", + "target_sheet_name": "Data", "target_match_column": "Assignee", + "source_table_id": "People", "target_cell_range": "A10:B12", "target_header_row": "10", + "source_filter_column": "Team", "source_filter_value": "Blue", + } + count, _ = _call(runtime, _plugin(runtime), "count_rows_by_related_values", **arguments) + assert count["row_count"] == 1 + rows, _ = _call( + runtime, _plugin(runtime), "filter_rows_by_related_values", + return_columns="Assignee", **arguments, + ) + assert rows["matched_target_row_count"] == 1 + assert rows["data"][0]["Assignee"] == "Ada" + assert rows["data"][0]["_excel_source"]["row"] == 11 + assert rows["source_selection"]["header_row"] == 3 + assert rows["target_selection"]["header_row"] == 10 + + +def test_csv_and_single_table_compatibility(monkeypatch): + with native_runtime(monkeypatch, row_count=3) as runtime: + plugin = _plugin(runtime) + aggregate, _ = _call(runtime, plugin, "aggregate_column", column="amount", operation="sum") + assert int(aggregate["result"]) == 6 and aggregate["selected_sheet"] is None + queried, invocation = _call(runtime, plugin, "query_tabular_data", query_expression="amount >= 2") + assert queried["total_matches"] == 2 + descriptor = invocation.internal_metadata["tabular_generated_export_source"] + assert descriptor["version"] == 1 and "table_selections" not in descriptor + invalid, _ = _call( + runtime, plugin, "query_tabular_data", query_expression="index == index", header_row="0", + ) + assert invalid["error_code"] == "table_selection_invalid" + + +def test_cross_sheet_tools_and_replay_preserve_table_scope_and_global_cursor(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _workbook_bytes([ + { + "name": "First ", + "rows": {2: {1: "Item_ID", 2: "amount"}, 3: {1: "A", 2: 10}, 4: {1: "B", 2: 20}}, + "tables": [("FirstFacts", "A2:B4", ["Item_ID", "amount"])], + }, + { + "name": "Second", + "rows": {7: {1: "Item_ID", 2: "amount"}, 8: {1: "C", 2: 30}, 9: {1: "D", 2: 40}}, + "tables": [("SecondFacts", "A7:B9", ["Item_ID", "amount"])], + }, + ])) + plugin = _plugin(runtime) + query, invocation = _call( + runtime, plugin, "query_tabular_data", query_expression="index >= 1", return_columns="Item_ID", + ) + assert query["total_matches"] == 3 + assert [row["Item_ID"] for row in query["data"]] == ["B", "C", "D"] + assert [row["_excel_source"]["row"] for row in query["data"]] == [4, 8, 9] + descriptor = invocation.internal_metadata["tabular_generated_export_source"] + assert descriptor["sheet_names"] == ["First ", "Second"] + replayed = list(_replay(runtime, descriptor, chunk_rows=1)) + assert [cursor for cursor, _ in replayed] == [2, 3, 4] + assert [row for _, row in replayed] == query["data"] + count, _ = _call(runtime, plugin, "count_rows", filter_column="amount", filter_operator=">", filter_value="15") + assert count["row_count"] == 3 + lookup, _ = _call( + runtime, plugin, "lookup_value", lookup_column="Item_ID", lookup_value="C", target_column="amount", + ) + assert lookup["total_matches"] == 1 + assert lookup["data"][0]["_excel_source"]["row"] == 8 + mismatch, _ = _call( + runtime, plugin, "aggregate_column", column="amount", operation="sum", + sheet_name="Second", table_id="FirstFacts", + ) + assert mismatch["error_code"] == "table_selection_invalid" + explicit, _ = _call( + runtime, plugin, "count_rows", table_id="FirstFacts", + ) + assert explicit["selected_sheet"] == "First " and explicit["header_row"] == 2 + + +def test_grouped_and_datetime_operations_respect_nonfirst_table_headers(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _workbook_bytes([{ + "name": "Data", + "rows": { + 2: {1: "Category", 2: "amount"}, 3: {1: "unrelated", 2: 9999}, + 7: {1: "Category", 2: "amount", 3: "When"}, + 8: {1: "Blue", 2: 10, 3: "2026-01-05"}, + 9: {1: "Blue", 2: 20, 3: "2026-01-06"}, + 10: {1: "Green", 2: 40, 3: "2026-01-12"}, + }, + "tables": [ + ("Unrelated", "A2:B3", ["Category", "amount"]), + ("Events", "A7:C10", ["Category", "amount", "When"]), + ], + }])) + plugin = _plugin(runtime) + grouped, _ = _call( + runtime, plugin, "group_by_aggregate", group_by_column="Category", + aggregate_column="amount", operation="sum", table_id="Events", + ) + assert grouped["result"] == {"Blue": 30, "Green": 40} + assert grouped["header_row"] == 7 + dated, _ = _call( + runtime, plugin, "group_by_datetime_component", datetime_column="When", + datetime_component="day_name", aggregate_column="amount", operation="sum", + cell_range="A7:C10", header_row="7", + ) + expected = dict.fromkeys(plugin.DAY_NAME_ORDER, 0) + expected.update({"Monday": 50, "Tuesday": 20}) + assert dated["result"] == expected + assert dated["parsed_rows"] == 3 and dated["table_range"] == "A7:C10" + + +def test_separate_file_relationships_authorize_each_explicit_table(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + source_bytes = _workbook_bytes([{ + "name": "Data", "rows": {3: {1: "Owner", 2: "Team"}, 4: {1: "Ada", 2: "Blue"}}, + "tables": [("People", "A3:B4", ["Owner", "Team"])], + }]) + target_bytes = _workbook_bytes([{ + "name": "Data", + "rows": {7: {1: "Assignee", 2: "amount"}, 8: {1: "Ada", 2: 15}, 9: {1: "Bea", 2: 20}}, + "tables": [("Work", "A7:B9", ["Assignee", "amount"])], + }]) + _set_source(runtime, source_bytes) + second = { + **deepcopy(runtime.document), "id": "target-1", "file_name": "target.xlsx", + "blob_path": f"{USER}/target.xlsx", + } + runtime.blobs.values[("user-documents", second["blob_path"])] = { + "bytes": target_bytes, "etag": "target-blob-1", "metadata": {}, + } + reads = [] + + def resolve_document(container, blob_path, user_id): + reads.append(blob_path) + if user_id != USER or container != "user-documents" or not runtime.state["allowed"]: + raise PermissionError("Fixture relationship source denied.") + if blob_path == second["blob_path"]: + return deepcopy(second) + if blob_path == runtime.document["blob_path"]: + return deepcopy(runtime.document) + raise PermissionError("Fixture relationship source denied.") + + runtime.patcher.setattr(runtime.screening, "_resolve_blob_document", resolve_document) + + def read_document(document_id, user_id, **kwargs): + if document_id == second["id"]: + return resolve_document("user-documents", second["blob_path"], user_id) + if document_id == runtime.document["id"]: + return resolve_document("user-documents", runtime.document["blob_path"], user_id) + raise PermissionError("Fixture relationship source denied.") + + runtime.patcher.setattr(runtime.screening, "_read_authorized_document", read_document) + plugin = _plugin(runtime) + arguments = { + "source_sheet_name": "Data", "source_value_column": "Owner", "source_table_id": "People", + "target_sheet_name": "Data", "target_match_column": "Assignee", "target_table_id": "Work", + "target_filename": "target.xlsx", + } + payload, _ = _call(runtime, plugin, "filter_rows_by_related_values", **arguments) + assert payload["matched_target_row_count"] == 1 + assert payload["source_filename"] == "source.xlsx" + assert payload["target_filename"] == "target.xlsx" + assert payload["data"][0]["_excel_source"]["row"] == 8 + assert set(reads) == {runtime.document["blob_path"], second["blob_path"]} + runtime.state["allowed"] = False + denied, _ = _call(runtime, plugin, "count_rows_by_related_values", **arguments) + assert denied["error_code"] == "tabular_source_unavailable" + assert "row_count" not in denied + + +def test_streamed_numeric_conversion_checks_late_rows_before_querying(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + rows = {2: {1: "Item_ID", 2: "amount"}} + rows.update({index + 2: {1: f"row-{index}", 2: index} for index in range(1, 1201)}) + rows[1202][2] = "unknown" + _set_source(runtime, _workbook_bytes([{"name": "Data", "rows": rows}])) + query, invocation = _call( + runtime, _plugin(runtime), "query_tabular_data", query_expression='amount == "2"', + ) + assert query["total_matches"] == 1 + descriptor = invocation.internal_metadata["tabular_generated_export_source"] + replayed = list(_replay(runtime, descriptor, chunk_rows=100)) + assert [row for _, row in replayed] == query["data"] + assert replayed[0][0] == 2 and replayed[0][1]["amount"] == "2" + + +def test_native_range_hints_pin_actual_headers_and_selected_ranges(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _one_table(3)) + plan = compute_plan(runtime, durable=True) + plan["requested_output_hints"].update({ + "selected_sheet": "", "selected_range": "A2:B5", "selected_header_row": "2", + }) + request = runtime.service._compute_request(plan, "Compute doubled amounts.") + candidate, descriptor = runtime.service._prepare_native_source( + runtime.engine, runtime.source_manifest[0], request, USER, + ) + assert candidate["cell_range"] == descriptor["cell_range"] == "A2:B5" + assert candidate["header_row"] == descriptor["header_row"] == 2 + assert candidate["total_matches"] == descriptor["expected_row_count"] == 3 + assert descriptor["table_selections"][0]["origin"] == "range" + assert [row["_excel_source"]["row"] for row in candidate["rows"]] == [3, 4, 5] + + +def test_same_schema_all_tables_keep_full_data_numeric_semantics_on_replay(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _workbook_bytes([{ + "name": "Data", + "rows": { + 2: {1: "Item_ID", 2: "amount"}, 3: {1: "A", 2: 1}, 4: {1: "B", 2: 2}, + 8: {1: "Item_ID", 2: "amount"}, 9: {1: "C", 2: 3}, 10: {1: "D", 2: "unknown"}, + }, + "tables": [ + ("FirstFacts", "A2:B4", ["Item_ID", "amount"]), + ("SecondFacts", "A8:B10", ["Item_ID", "amount"]), + ], + }])) + payload, invocation = _call( + runtime, _plugin(runtime), "query_tabular_data", + table_id="all", query_expression='amount == "2"', + ) + descriptor = invocation.internal_metadata["tabular_generated_export_source"] + replayed = list(_replay(runtime, descriptor, chunk_rows=1)) + assert payload["total_matches"] == len(replayed) == 1 + assert descriptor["numeric_conversion_scope"] == "sheet" + assert [row for _, row in replayed] == payload["data"] + plan = compute_plan(runtime, durable=True, query='amount == "2"') + plan["requested_output_hints"]["selected_table"] = "all" + request = runtime.service._compute_request(plan, "Compute doubled amounts.") + candidate, pinned = runtime.service._prepare_native_source( + runtime.engine, runtime.source_manifest[0], request, USER, + ) + assert pinned["numeric_conversion_scope"] == "sheet" + assert candidate["total_matches"] == 1 and candidate["rows"] == payload["data"] + + +def test_repeated_headers_keep_physical_rows_separate_from_replay_cursors(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _workbook_bytes([{ + "name": "Data", + "rows": { + 2: {1: "Item_ID", 2: "amount"}, 3: {1: "A", 2: 10}, + 4: {1: "Item_ID", 2: "amount"}, 5: {1: "B", 2: 20}, + }, + }])) + descriptor = _descriptor(runtime, expected_row_count=2) + assert descriptor["source_row_count"] == 2 + rows = list(_replay(runtime, descriptor, chunk_rows=1)) + assert [cursor for cursor, _ in rows] == [1, 2] + assert [row["_excel_source"]["row"] for _, row in rows] == [3, 5] + assert list(_replay(runtime, descriptor, resume=1, chunk_rows=1)) == rows[-1:] + + +def test_source_columns_cannot_replace_protected_excel_provenance(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _workbook_bytes([{ + "name": "Data", "rows": {2: {1: "Item_ID", 2: "_excel_source"}, 3: {1: "A", 2: "spoofed"}}, + "tables": [("Facts", "A2:B3", ["Item_ID", "_excel_source"])], + }])) + payload, _ = _call( + runtime, _plugin(runtime), "query_tabular_data", + query_expression="index == index", return_columns="Item_ID", + ) + assert payload["error_code"] == "reserved_excel_column" + assert "data" not in payload + descriptor = _descriptor(runtime, expected_row_count=1) + with pytest.raises(ValueError, match="reserved"): + list(_replay(runtime, descriptor)) + + +def test_existing_csv_request_fingerprints_and_durable_jobs_remain_replayable(monkeypatch): + with native_runtime(monkeypatch, row_count=3) as runtime: + plan = compute_plan(runtime, durable=True) + pending = submit(runtime, plan) + job_id = pending["handle"]["job_id"] + stored = runtime.engine._read_run(USER, job_id) + legacy_request = runtime.service._compute_request(plan, "Compute doubled amounts.") + for field in ("selected_table", "cell_range", "header_row"): + legacy_request.pop(field, None) + legacy_fingerprint = runtime.service.native_compute_digest({ + "request": legacy_request, "sources": stored["compute_context"]["sources"], + }) + stored["compute_context"]["request_fingerprint"] = legacy_fingerprint + runtime.jobs.replace_item(job_id, stored) + reopened = submit(runtime, plan) + assert reopened["status"] == "pending" and reopened["handle"]["job_id"] == job_id + assert reopened["handle"]["request_fingerprint"] == legacy_fingerprint + finished = runtime.engine.process_tabular_generated_output_run(job_id, USER) + assert finished["status"] == "completed", finished.get("last_error") + ready = open_result(runtime, reopened["handle"]) + rows = list(ready["reader"].iter_records()) + assert rows == [ + {"Item_ID": "item-000001", "doubled": 2}, + {"Item_ID": "item-000002", "doubled": 4}, + {"Item_ID": "item-000003", "doubled": 6}, + ] + assert runtime.jobs.created == 1 + + +def test_provider_exceptions_never_reach_public_tool_payloads(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + plugin = _plugin(runtime) + runtime.patcher.setattr( + plugin, "_get_workbook_metadata", + lambda *args, **kwargs: (_ for _ in ()).throw( + RuntimeError("Provider failure with private endpoint and credential details."), + ), + ) + payload, _ = _call(runtime, plugin, "describe_tabular_file") + assert payload["error_code"] == "tabular_analysis_failed" + assert "Provider" not in payload["error"] and "credential" not in payload["error"] + + +@pytest.mark.parametrize("corruption", ["duplicate_cursor", "expected_count", "checkpoint_identity"]) +def test_staging_rejects_repeated_cursors_and_inconsistent_checkpoint_counts(monkeypatch, corruption): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _one_table(3, table_name="Facts")) + plan = compute_plan(runtime, durable=True) + plan["requested_output_hints"]["selected_table"] = "Facts" + pending = submit(runtime, plan) + job_id = pending["handle"]["job_id"] + run = runtime.engine._read_run(USER, job_id) + if corruption == "expected_count": + run["source_descriptor"]["expected_row_count"] = 4 + runtime.jobs.replace_item(job_id, run) + claimed = runtime.engine._try_claim_run(USER, job_id, runtime.settings) + if corruption == "duplicate_cursor": + runtime.patcher.setattr( + runtime.engine, "_iter_versioned_tabular_source_rows", + lambda *args, **kwargs: iter([(1, {"Item_ID": "A"}), (1, {"Item_ID": "A"})]), + ) + elif corruption == "checkpoint_identity": + original = runtime.engine._download_json_blob + + def corrupt_checkpoint(path): + result = original(path) + if isinstance(result, list) and result: + result[0][runtime.engine.TABULAR_EXPORT_INPUT_ROW_NUMBER_FIELD] = 9 + return result + + runtime.patcher.setattr(runtime.engine, "_download_json_blob", corrupt_checkpoint) + with pytest.raises(ValueError): + runtime.engine._stage_tabular_generated_output_source(claimed, runtime.settings) + saved = runtime.engine._read_run(USER, job_id) + assert saved["source_staging_complete"] is False + assert saved["status"] != "completed" + assert runtime.publications == [] + + +def test_durable_checkpoint_resume_preserves_exact_selected_table_count(monkeypatch): + with native_runtime(monkeypatch, filename="source.xlsx") as runtime: + _set_source(runtime, _one_table(37, header=7, table_name="Facts")) + plan = compute_plan(runtime, durable=True) + plan["requested_output_hints"].update({"selected_table": "Facts", "header_row": "7"}) + pending = submit(runtime, plan) + assert pending["status"] == "pending" and pending["reader"] is None + job_id = pending["handle"]["job_id"] + run = runtime.engine._read_run(USER, job_id) + assert run["source_descriptor"]["expected_row_count"] == 37 + assert run["source_descriptor"]["header_row"] == 7 + run["source_descriptor"].update({"batch_max_rows": 5, "schema_probe_rows": 5}) + runtime.jobs.replace_item(job_id, run) + claimed = runtime.engine._try_claim_run(USER, job_id, runtime.settings) + original = runtime.engine._checkpoint_source_input_batch + calls = [] + + def interrupt_after_checkpoint(*args, **kwargs): + saved = original(*args, **kwargs) + calls.append(saved["source_staged_rows"]) + if len(calls) == 2: + raise RuntimeError("Injected worker interruption after a durable checkpoint.") + return saved + + with monkeypatch.context() as patcher: + patcher.setattr(runtime.engine, "_checkpoint_source_input_batch", interrupt_after_checkpoint) + with pytest.raises(RuntimeError, match="Injected worker"): + runtime.engine._stage_tabular_generated_output_source(claimed, runtime.settings) + interrupted = runtime.engine._read_run(USER, job_id) + assert interrupted["source_staged_rows"] == 10 + assert interrupted["source_scan_row_count"] == 10 + assert interrupted["source_staging_complete"] is False + interrupted["last_heartbeat_at"] = "2000-01-01T00:00:00+00:00" + runtime.jobs.replace_item(job_id, interrupted) + finished = runtime.engine.process_tabular_generated_output_run(job_id, USER) + assert finished["status"] == "completed", finished.get("last_error") + ready = open_result(runtime, pending["handle"]) + rows = list(ready["reader"].iter_records()) + assert len(rows) == 37 + assert sum(row["doubled"] for row in rows) == 37 * 38 + assert rows[-1] == {"Item_ID": "item-000037", "doubled": 74} + stored = runtime.engine._read_run(USER, job_id) + checkpoint_rows = [] + for number in range(1, stored["source_staged_batches"] + 1): + checkpoint_rows.extend(runtime.engine._download_json_blob( + runtime.engine._input_blob_path(USER, CONVERSATION, job_id, number), + )) + assert len(checkpoint_rows) == stored["source_staged_rows"] == 37 + assert [row["_excel_source"]["row"] for row in checkpoint_rows] == list(range(8, 45)) + token_field = runtime.engine.TABULAR_EXPORT_INPUT_ROW_TOKEN_FIELD + assert len({row[token_field] for row in checkpoint_rows}) == 37 + assert runtime.publications == [] diff --git a/ui_tests/fixtures/orchestration/harness_entry.tsx b/ui_tests/fixtures/orchestration/harness_entry.tsx index 1264aad02..0aa74d379 100644 --- a/ui_tests/fixtures/orchestration/harness_entry.tsx +++ b/ui_tests/fixtures/orchestration/harness_entry.tsx @@ -44,6 +44,7 @@ import { OrchestrationRunView } from '../../../application/v2_ui/src/components/ import { OrchestrationMapView } from '../../../application/v2_ui/src/components/chat/OrchestrationMapView'; import { OrchestrationPlanEditorHost } from '../../../application/v2_ui/src/components/chat/OrchestrationPlanEditor'; import { MessageList } from '../../../application/v2_ui/src/components/chat/MessageList'; +import { EnhancedCitationViewer } from '../../../application/v2_ui/src/components/chat/EnhancedCitationViewer'; import { ConversationDrawer } from '../../../application/v2_ui/src/components/chat/ConversationDrawer'; import { Composer } from '../../../application/v2_ui/src/components/chat/Composer'; import { ComposerEditor } from '../../../application/v2_ui/src/components/chat/ComposerEditor'; @@ -246,6 +247,7 @@ type ComponentName = | 'WorkflowEditorDialog' | 'WorkflowRunHistory' | 'M365Cards' + | 'EnhancedCitationViewer' | 'Toaster'; // eslint-disable-next-line @typescript-eslint/no-explicit-any @@ -260,6 +262,7 @@ const components: Record ReactElement | null> = { OrchestrationRunView, OrchestrationMapView, MessageList, + EnhancedCitationViewer, ConversationDrawer, Composer, PromptExperience, diff --git a/ui_tests/test_v2_excel_citation_inspection.py b/ui_tests/test_v2_excel_citation_inspection.py new file mode 100644 index 000000000..100f44b16 --- /dev/null +++ b/ui_tests/test_v2_excel_citation_inspection.py @@ -0,0 +1,191 @@ +# test_v2_excel_citation_inspection.py +""" +UI tests for table-aware Excel citation previews and stable source evidence. +Version: 0.261.408 +Implemented in: 0.261.408 + +The real V2 viewer runs through real HTTP fetches against synthetic API transport. +The shared Azure Playwright connection fixture uses Entra authentication when +configured and the existing local browser otherwise. +""" + +import json +from pathlib import Path +from urllib.parse import parse_qs, urlparse + +import pytest +from playwright.sync_api import expect + +from ui_tests.fixtures.orchestration import harness_build +from ui_tests.fixtures.playwright_connection import connect_options + + +__all__ = ["connect_options"] +PASSAGE = "Saved reviewer evidence: Budget!B4 contains 15000; the reviewer requests 19500." +ROOT = Path(__file__).resolve().parents[1] + + +def load_harness(page, origin): + styles = list((ROOT / "application" / "single_app" / "static" / "v2" / "assets").glob("*.css")) + assert len(styles) == 1, "Build the V2 UI before running styled citation tests." + response = page.goto(f"{origin}/{harness_build.HARNESS_HTML_REL}") + assert response is not None and response.ok + page.add_style_tag(url=f"{origin}/application/single_app/static/v2/assets/{styles[0].name}") + + +def install_transport(page, *, identical=False): + requests, failures, errors = [], {"Delivery": False}, [] + page.on("pageerror", lambda error: errors.append(str(error))) + + def transport(route): + parsed = urlparse(route.request.url) + if parsed.path == "/api/get_citation": + route.fulfill(status=200, content_type="application/json", body=json.dumps({"cited_text": PASSAGE})) + return + if parsed.path != "/api/enhanced_citations/tabular_preview": + route.fulfill(status=200, content_type="application/json", body="{}") + return + query = parse_qs(parsed.query) + requests.append(query) + sheet = query.get("sheet_name", ["Budget"])[0] + if failures.get(sheet): + route.fulfill(status=500, content_type="application/json", body=json.dumps({"error": "Preview temporarily unavailable."})) + return + table_id = query.get("table_id", [f"{sheet.lower()}-1"])[0] + table_number = int(table_id.rsplit("-", 1)[-1]) + start = int(query.get("start_row", ["0"])[0]) + count = min(200, 50000 - start) + tables = [ + {"id": f"{sheet.lower()}-{index}", "name": f"Review {index}", "range": f"A{index * 10}:B{50000 + index * 10}", + "origin": "inferred", "header_row": 2, "header_status": "inferred", "row_count": 50000} + for index in range(1, 6 if sheet == "Budget" else 2) + ] + rows = [ + ["North", "15000"] if identical else [f"{sheet}-{table_number}-{index + 1}", str(index + 1)] + for index in range(start, start + count) + ] + payload = { + "filename": "review.xlsx", "selected_sheet": sheet, "sheet_names": ["Budget", "Delivery"], + "sheet_count": 2, "tables": tables, "table_count": len(tables), + "table_id": table_id, "table_name": f"Review {table_number}", "table_range": tables[table_number - 1]["range"], + "header_row": 2, "header_status": "inferred", "total_rows": 50000, + "columns": ["Site", "Amount"], "rows": rows, + "row_numbers": list(range(start + 3, start + 3 + count)), "start_row": start, + "has_more": start + count < 50000, "truncated": start + count < 50000, + "next_start_row": start + count if start + count < 50000 else None, + } + route.fulfill(status=200, content_type="application/json", body=json.dumps(payload)) + + page.route("**/api/**", transport) + return requests, failures, errors + + +def mount_viewer(page): + page.wait_for_function("() => Boolean(window.OrchHarness)") + page.evaluate("""() => { + const H = window.OrchHarness; + H.reset(); + window.viewerFallbacks = []; + H.mount('mount-a', 'EnhancedCitationViewer', { + type: 'tabular', docId: 'workbook', location: '1', locationLabel: 'Page', + metadata: {file_name: 'review.xlsx', enhanced_citations: true}, + citationId: 'workbook_2', onClose: () => H.unmount('mount-a'), + onFallback: (message) => window.viewerFallbacks.push(message), + }); + }""") + dialog = page.get_by_role("dialog", name="Cited source", exact=True) + expect(dialog.get_by_role("tab", name="Budget", exact=True)).to_have_attribute("aria-selected", "true") + expect(dialog.get_by_role("tabpanel")).to_have_attribute("aria-busy", "false") + return dialog + + +@pytest.mark.ui +@pytest.mark.parametrize("viewport", [{"width": 1440, "height": 900}, {"width": 390, "height": 844}], ids=["desktop", "mobile"]) +def test_real_sheets_five_tables_and_original_evidence(page, viewport): + harness_build.ensure_bundle() + page.set_viewport_size(viewport) + requests, _, errors = install_transport(page) + with harness_build.start_static_server() as origin: + load_harness(page, origin) + dialog = mount_viewer(page) + expect(dialog.get_by_role("columnheader", name="Site", exact=True)).to_be_visible() + expect(dialog.get_by_role("cell", name="Budget-1-1", exact=True)).to_be_visible() + expect(dialog.get_by_text("Cited workbook evidence", exact=True)).to_be_visible() + expect(dialog.get_by_text("What was extracted from this image", exact=True)).to_have_count(0) + expect(dialog.get_by_text(PASSAGE, exact=True)).to_be_visible() + dialog.get_by_label("Table", exact=True).select_option("budget-5") + expect(dialog.get_by_role("cell", name="Budget-5-1", exact=True)).to_be_visible() + expect(dialog.get_by_role("cell", name="Budget-1-1", exact=True)).to_have_count(0) + dialog.get_by_role("tab", name="Delivery", exact=True).click() + expect(dialog.get_by_role("tab", name="Delivery", exact=True)).to_have_attribute("aria-selected", "true") + expect(dialog.get_by_role("cell", name="Delivery-1-1", exact=True)).to_be_visible() + expect(dialog.get_by_text(PASSAGE, exact=True)).to_be_visible() + assert any(request.get("table_id") == ["budget-5"] for request in requests) + assert any(request.get("sheet_name") == ["Delivery"] for request in requests) + assert dialog.evaluate("(element) => element.scrollWidth <= element.clientWidth") + assert errors == [] + + +@pytest.mark.ui +def test_identical_source_sheets_still_have_correct_selected_identity_and_keyboard_navigation(page): + harness_build.ensure_bundle() + requests, _, errors = install_transport(page, identical=True) + with harness_build.start_static_server() as origin: + load_harness(page, origin) + dialog = mount_viewer(page) + budget = dialog.get_by_role("tab", name="Budget", exact=True) + budget.focus() + budget.press("ArrowRight") + delivery = dialog.get_by_role("tab", name="Delivery", exact=True) + expect(delivery).to_have_attribute("aria-selected", "true") + expect(delivery).to_be_focused() + expect(dialog.get_by_role("tabpanel")).to_have_attribute("aria-label", "Delivery data preview") + expect(dialog.get_by_role("cell", name="North", exact=True).first).to_be_visible() + delivery.press("Home") + expect(budget).to_have_attribute("aria-selected", "true") + budget.click() + expect(dialog.get_by_role("tabpanel")).to_have_attribute("aria-busy", "false") + assert any(request.get("sheet_name") == ["Delivery"] for request in requests) + assert errors == [] + + +@pytest.mark.ui +def test_fifty_thousandth_record_is_loaded_without_rendering_fifty_thousand_rows(page): + harness_build.ensure_bundle() + requests, _, errors = install_transport(page) + with harness_build.start_static_server() as origin: + load_harness(page, origin) + dialog = mount_viewer(page) + dialog.get_by_label("Go to record", exact=True).fill("50000") + dialog.get_by_role("button", name="Go", exact=True).click() + expect(dialog.get_by_role("cell", name="Budget-1-50000", exact=True)).to_be_visible() + expect(dialog.get_by_role("rowheader", name="50002", exact=True)).to_be_visible() + expect(dialog.get_by_text("Records 50000–50000 of 50000", exact=True)).to_be_visible() + assert len(dialog.get_by_role("row").all()) <= 201 + assert any(request.get("start_row") == ["49999"] for request in requests) + dialog.get_by_role("button", name="Previous records", exact=True).click() + expect(dialog.get_by_role("cell", name="Budget-1-1", exact=True)).to_be_visible() + dialog.get_by_label("Go to record", exact=True).fill("1") + dialog.get_by_role("button", name="Go", exact=True).click() + expect(dialog.get_by_role("tabpanel")).to_have_attribute("aria-busy", "false") + assert errors == [] + + +@pytest.mark.ui +def test_failed_switch_does_not_mislabel_previous_data_and_can_retry(page): + harness_build.ensure_bundle() + _, failures, errors = install_transport(page) + with harness_build.start_static_server() as origin: + load_harness(page, origin) + dialog = mount_viewer(page) + failures["Delivery"] = True + dialog.get_by_role("tab", name="Delivery", exact=True).click() + expect(dialog.get_by_role("alert")).to_contain_text("Preview temporarily unavailable.") + expect(dialog.get_by_role("tab", name="Budget", exact=True)).to_have_attribute("aria-selected", "true") + expect(dialog.get_by_role("cell", name="Budget-1-1", exact=True)).to_be_visible() + failures["Delivery"] = False + dialog.get_by_role("button", name="Retry preview", exact=True).click() + expect(dialog.get_by_role("tab", name="Delivery", exact=True)).to_have_attribute("aria-selected", "true") + expect(dialog.get_by_role("cell", name="Delivery-1-1", exact=True)).to_be_visible() + assert page.evaluate("window.viewerFallbacks") == [] + assert errors == []