agenticdome-python-sdk 1.2.37__tar.gz → 1.2.39__tar.gz

{agenticdome_python_sdk-1.2.37 → agenticdome_python_sdk-1.2.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.37
+Version: 1.2.39
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License-Expression: Apache-2.0
@@ -186,8 +186,12 @@ attach other boundaries manually, then run
 If a coding assistant has already made and tested the application edits,
 import its canonical `AgenticDome_Integration.md` in the customer portal and
 run `agenticdome validate-report --report AgenticDome_Integration.md` from
-that same deployable workload. Import the two generated, hash-bound JSON files
-in Onboarding. This avoids repeating the guided edit plan; the Markdown counts
+that same deployable workload. If it reports `ready=false`, follow the local
+`.agenticdome/RECONCILIATION.md` worklist and rerun after reviewing the real
+source and tests. You may import the two generated, hash-bound JSON files in
+Onboarding even when the gate is incomplete, to retain partial evidence and run
+a fixed tenant-policy diagnostic. They do not count as passing workload proof or
+unlock activation; rerun and reimport after closing the gaps. This avoids repeating the guided edit plan; the Markdown counts
 remain AI-reported and a real action-path test is still required before
 claiming protection. See the [customer onboarding guide](docs/customer-onboarding.md).
 

{agenticdome_python_sdk-1.2.37 → agenticdome_python_sdk-1.2.39}/README.md

@@ -73,8 +73,12 @@ attach other boundaries manually, then run
 If a coding assistant has already made and tested the application edits,
 import its canonical `AgenticDome_Integration.md` in the customer portal and
 run `agenticdome validate-report --report AgenticDome_Integration.md` from
-that same deployable workload. Import the two generated, hash-bound JSON files
-in Onboarding. This avoids repeating the guided edit plan; the Markdown counts
+that same deployable workload. If it reports `ready=false`, follow the local
+`.agenticdome/RECONCILIATION.md` worklist and rerun after reviewing the real
+source and tests. You may import the two generated, hash-bound JSON files in
+Onboarding even when the gate is incomplete, to retain partial evidence and run
+a fixed tenant-policy diagnostic. They do not count as passing workload proof or
+unlock activation; rerun and reimport after closing the gaps. This avoids repeating the guided edit plan; the Markdown counts
 remain AI-reported and a real action-path test is still required before
 claiming protection. See the [customer onboarding guide](docs/customer-onboarding.md).
 

{agenticdome_python_sdk-1.2.37 → agenticdome_python_sdk-1.2.39}/agenticdome_python_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.37
+Version: 1.2.39
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License-Expression: Apache-2.0
@@ -186,8 +186,12 @@ attach other boundaries manually, then run
 If a coding assistant has already made and tested the application edits,
 import its canonical `AgenticDome_Integration.md` in the customer portal and
 run `agenticdome validate-report --report AgenticDome_Integration.md` from
-that same deployable workload. Import the two generated, hash-bound JSON files
-in Onboarding. This avoids repeating the guided edit plan; the Markdown counts
+that same deployable workload. If it reports `ready=false`, follow the local
+`.agenticdome/RECONCILIATION.md` worklist and rerun after reviewing the real
+source and tests. You may import the two generated, hash-bound JSON files in
+Onboarding even when the gate is incomplete, to retain partial evidence and run
+a fixed tenant-policy diagnostic. They do not count as passing workload proof or
+unlock activation; rerun and reimport after closing the gaps. This avoids repeating the guided edit plan; the Markdown counts
 remain AI-reported and a real action-path test is still required before
 claiming protection. See the [customer onboarding guide](docs/customer-onboarding.md).
 

{agenticdome_python_sdk-1.2.37 → agenticdome_python_sdk-1.2.39}/agenticdome_sdk/catalog_snapshot.json

@@ -2,12 +2,12 @@
     "schema": "agenticdome.catalog-snapshot.v1",
     "catalog_schema": "agenticdome.hook-catalog.v1",
     "verified_at": "2026-10-02",
-    "python_sdk_version": "1.2.37",
+    "python_sdk_version": "1.2.39",
     "published_packages": {
         "agenticdome-python-sdk": {
             "registry": "pypi",
-            "version": "1.2.37",
-            "url": "https://pypi.org/project/agenticdome-python-sdk/1.2.37/"
+            "version": "1.2.39",
+            "url": "https://pypi.org/project/agenticdome-python-sdk/1.2.39/"
         },
         "agenticdome-sdk": {
             "registry": "npm",

{agenticdome_python_sdk-1.2.37 → agenticdome_python_sdk-1.2.39}/agenticdome_sdk/onboarding_cli.py

@@ -7,6 +7,7 @@ paths and boundary locations, never source snippets or file contents.
 from __future__ import annotations
 
 import argparse
+import ast
 import difflib
 import hashlib
 import importlib.metadata
@@ -42,6 +43,10 @@ from .framework_edits import has_explicit_python_tool_dispatcher
 SCHEMA = "agenticdome.onboarding-report.v1"
 CONFIG_SCHEMA = "agenticdome.project-config.v1"
 COPILOT_ANALYSIS_REVISION = 4
+# Local cache revision is separate from the wire contract: changing the
+# analyzer's finding rules must refresh old on-disk results without forcing
+# every already-published SDK to upgrade in lockstep with its sidecar.
+COPILOT_CACHE_REVISION = 2
 COPILOT_MAX_WORKLOAD_BYTES = 4_000_000
 COPILOT_MAX_WORKLOAD_PARTS = 24
 COPILOT_MAX_EVENTS_PER_FUNCTION = 2_048
@@ -574,6 +579,7 @@ def _copilot_semantic_analysis(root: Path, ir: Dict[str, Any], *, required: bool
             and isinstance(semantic, dict)
             and semantic.get("ir_sha256") == ir_digest
             and semantic.get("analysis_revision") == COPILOT_ANALYSIS_REVISION
+            and cached.get("cache_revision") == COPILOT_CACHE_REVISION
         ):
             return semantic
 
@@ -591,12 +597,14 @@ def _copilot_semantic_analysis(root: Path, ir: Dict[str, Any], *, required: bool
         or part_cache.get("api_base") != api_base
         or part_cache.get("catalog_digest") != expected_catalog_digest
         or part_cache.get("selected_ir_sha256") != ir_digest
+        or part_cache.get("cache_revision") != COPILOT_CACHE_REVISION
         or not isinstance(part_cache.get("parts"), dict)
     ):
         part_cache = {
             "schema": "agenticdome.copilot-part-cache.v1", "tenant_id": tenant_id,
             "api_base": api_base, "catalog_digest": expected_catalog_digest,
-            "selected_ir_sha256": ir_digest, "parts": {},
+            "selected_ir_sha256": ir_digest, "cache_revision": COPILOT_CACHE_REVISION,
+            "parts": {},
         }
     analyzed: List[Tuple[str, Dict[str, Any]]] = []
     response_binding: Dict[str, Any] = {}
@@ -627,7 +635,7 @@ def _copilot_semantic_analysis(root: Path, ir: Dict[str, Any], *, required: bool
         if len(body) > 4_500_000:
             raise SystemExit(f"Bounded Copilot unit {name} exceeds its transport budget; no partial plan was saved.")
         idempotency_key = hashlib.sha256(
-            f"{tenant_id}\n{api_base}\n{part_digest}\n{expected_catalog_digest}".encode("utf-8")
+            f"{tenant_id}\n{api_base}\n{part_digest}\n{expected_catalog_digest}\n{COPILOT_CACHE_REVISION}".encode("utf-8")
         ).hexdigest()
         try:
             result = _post_copilot(api_base, api_key, tenant_id, "/integration-copilot/v1/analyze", body, idempotency_key=idempotency_key)
@@ -663,6 +671,7 @@ def _copilot_semantic_analysis(root: Path, ir: Dict[str, Any], *, required: bool
         "source_upload": False,
         "tenant_id": tenant_id,
         "api_base": api_base,
+        "cache_revision": COPILOT_CACHE_REVISION,
         "semantic_analysis": semantic,
         "catalog_binding": response_binding,
     })
@@ -716,6 +725,82 @@ def _mcp_evidence_id(kind: str, relative: str, line: int) -> str:
     return f"{kind}-{digest}"
 
 
+def _agenticdome_policy_probe_spans(text: str) -> Dict[int, List[Tuple[int, int]]]:
+    """Mask only a confirmed AgenticDome policy call's MCP method literal.
+
+    A policy client can use the MCP JSON-RPC envelope without forwarding
+    customer MCP tools. Keep all other MCP calls in the same file visible.
+    Unparseable or ambiguous source receives no exception.
+    """
+    if "tools/call" not in text or "guardrail.validate" not in text:
+        return {}
+    try:
+        module = ast.parse(text)
+    except (SyntaxError, ValueError):
+        return {}
+
+    def field(mapping: ast.AST, key: str) -> Optional[ast.AST]:
+        if not isinstance(mapping, ast.Dict):
+            return None
+        return next(
+            (value for name, value in zip(mapping.keys, mapping.values)
+             if isinstance(name, ast.Constant) and name.value == key),
+            None,
+        )
+
+    def is_literal(node: Optional[ast.AST], value: str) -> bool:
+        return isinstance(node, ast.Constant) and node.value == value
+
+    # The legacy urllib client uses an environment-overridable URL whose
+    # checked-in default is AgenticDome's own /mcp policy endpoint.
+    policy_url_names: set[str] = set()
+    for node in ast.walk(module):
+        if not isinstance(node, (ast.Assign, ast.AnnAssign)):
+            continue
+        targets = node.targets if isinstance(node, ast.Assign) else [node.target]
+        value = node.value
+        if value is None or not any(
+            isinstance(part, ast.Constant) and isinstance(part.value, str)
+            and re.fullmatch(r"https?://(?:[a-z0-9-]+\.)*agenticdome\.io(?::\d+)?/mcp/?", part.value, re.I)
+            for part in ast.walk(value)
+        ):
+            continue
+        policy_url_names.update(target.id for target in targets if isinstance(target, ast.Name))
+
+    spans: Dict[int, List[Tuple[int, int]]] = {}
+    for function in ast.walk(module):
+        if not isinstance(function, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        calls = [node for node in ast.walk(function) if isinstance(node, ast.Call)]
+        for assignment in ast.walk(function):
+            if not isinstance(assignment, (ast.Assign, ast.AnnAssign)):
+                continue
+            targets = assignment.targets if isinstance(assignment, ast.Assign) else [assignment.target]
+            names = {target.id for target in targets if isinstance(target, ast.Name)}
+            method = field(assignment.value, "method") if assignment.value is not None else None
+            params = field(assignment.value, "params") if assignment.value is not None else None
+            if not names or not is_literal(method, "tools/call") or not is_literal(field(params, "name"), "guardrail.validate"):
+                continue
+
+            def sends_policy_payload(call: ast.Call) -> bool:
+                if not any(isinstance(part, ast.Name) and part.id in names for part in ast.walk(call)):
+                    return False
+                if (isinstance(call.func, ast.Attribute) and call.func.attr == "_post"
+                        and call.args and is_literal(call.args[0], "/mcp")):
+                    return True
+                return (
+                    isinstance(call.func, (ast.Name, ast.Attribute))
+                    and (call.func.id if isinstance(call.func, ast.Name) else call.func.attr) == "Request"
+                    and bool(call.args)
+                    and isinstance(call.args[0], ast.Name)
+                    and call.args[0].id in policy_url_names
+                )
+
+            if any(sends_policy_payload(call) for call in calls):
+                spans.setdefault(method.lineno, []).append((method.col_offset, method.end_col_offset))
+    return spans
+
+
 def _detect_mcp_protection(root: Path, paths: Sequence[Path], languages: Sequence[str]) -> Dict[str, Any]:
     """Collect source-free MCP topology and candidate protection evidence.
 
@@ -735,15 +820,21 @@ def _detect_mcp_protection(root: Path, paths: Sequence[Path], languages: Sequenc
     for path in paths:
         relative = _relative(path, root)
         text = _read_text(path)
-        # A client asking AgenticDome's own /mcp policy endpoint to run
-        # guardrail.validate is not a customer MCP forwarder. Do not suggest
-        # an MCP onboarding path from that protocol-shaped probe alone.
-        policy_probe_only = (
+        python_source = path.suffix.lower() in {".py", ".pyi"}
+        policy_probe_spans = _agenticdome_policy_probe_spans(text) if python_source else {}
+        # Preserve the existing JavaScript/TypeScript policy-client exception.
+        # Unlike Python, this scanner has no AST span for those languages, so
+        # exempt only a single policy call with no other MCP integration hints.
+        if not python_source and (
             bool(re.search(r"['\"]name['\"]\s*:\s*['\"]guardrail\.validate['\"]", text))
             and bool(re.search(r"_post\s*\(\s*['\"]/mcp['\"]", text))
-            and not re.search(r"\b(?:from\s+mcp|import\s+mcp|FastMCP|McpServer|ClientSession|StdioClientTransport|SSEClientTransport)\b|@modelcontextprotocol", text)
-        )
-        if policy_probe_only:
+            and len(re.findall(r"\btools/call\b", text)) == 1
+            and not re.search(
+                r"\b(?:FastMCP|McpServer|MCPClient|McpClient|ClientSession|StdioClientTransport|"
+                r"SSEClientTransport|call_tool|callTool|registerTool|tools/list|setRequestHandler)\b|@modelcontextprotocol",
+                text,
+            )
+        ):
             continue
         if not re.search(
             r"(?:\b(?:from\s+mcp|import\s+mcp|FastMCP|MCPClient|McpClient|McpServer|ClientSession|"
@@ -753,6 +844,14 @@ def _detect_mcp_protection(root: Path, paths: Sequence[Path], languages: Sequenc
         ):
             continue
         for line_number, line in enumerate(text.splitlines(), start=1):
+            # AST offsets are UTF-8 byte offsets. Mask the exact policy method
+            # literal, not the whole line or file: a real MCP call alongside
+            # the policy probe must still trigger specialist onboarding.
+            if line_number in policy_probe_spans:
+                encoded = bytearray(line.encode("utf-8"))
+                for start, end in policy_probe_spans[line_number]:
+                    encoded[start:end] = b" " * (end - start)
+                line = encoded.decode("utf-8")
             for role, patterns in MCP_ROLE_PATTERNS.items():
                 if any(pattern.search(line) for pattern in patterns):
                     roles.add(role)
@@ -1063,6 +1162,23 @@ def _write_json(path: Path, value: Dict[str, Any]) -> None:
             os.unlink(staged)
 
 
+def _write_local_text(path: Path, value: str) -> None:
+    """Replace a local review artifact atomically without following its symlink."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.is_symlink():
+        raise SystemExit("A reconciliation output path is a symlink; remove it and retry.")
+    descriptor, staged = tempfile.mkstemp(prefix=".agenticdome-review-", dir=path.parent)
+    try:
+        with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
+            handle.write(value)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(staged, path)
+    finally:
+        if os.path.exists(staged):
+            os.unlink(staged)
+
+
 def _load_json(path: Path) -> Dict[str, Any]:
     try:
         value = json.loads(path.read_text(encoding="utf-8"))
@@ -2471,6 +2587,84 @@ def verify_project(root: Path, live: bool = False, run_tests: bool = False,
     return (0 if result["ready"] else 2), result
 
 
+def _reconciliation_markdown(plan: Dict[str, Any], verification: Dict[str, Any], report_digest: str) -> str:
+    """Give a bounded, source-free worklist without accepting AI claims as proof."""
+    semantic = plan.get("semantic_analysis") if isinstance(plan.get("semantic_analysis"), dict) else {}
+    gate = verification.get("semantic_gate") if isinstance(verification.get("semantic_gate"), dict) else {}
+
+    def groups(field: str) -> List[Tuple[str, str, int, List[int]]]:
+        grouped: Dict[Tuple[str, str], List[int]] = {}
+        rows = semantic.get(field) if isinstance(semantic.get(field), list) else []
+        for item in rows[:100]:
+            if not isinstance(item, dict):
+                continue
+            boundary = str(item.get("boundary") or "unknown")
+            if boundary not in {"prompt_ingress", "tool_execution", "output_egress"}:
+                boundary = "unknown"
+            raw_path = str(item.get("path") or "")[:500].replace("\\", "/")
+            # These are display paths only. Do not let a remote result inject
+            # Markdown, an absolute path, source text, or a shell instruction.
+            if not raw_path or raw_path.startswith("/") or ".." in Path(raw_path).parts:
+                path = "[invalid relative path]"
+            else:
+                path = re.sub(r"[^A-Za-z0-9_./ -]", "_", raw_path)
+            try:
+                line = max(1, min(int(item.get("line") or 1), 10_000_000))
+            except (TypeError, ValueError):
+                line = 1
+            grouped.setdefault((boundary, path), []).append(line)
+        return [(boundary, path, len(lines), sorted(set(lines))[:12])
+                for (boundary, path), lines in sorted(grouped.items())]
+
+    guidance = {
+        "prompt_ingress": "Review the final assembled model messages at each call. Screen untrusted user, retrieved and tool content immediately before the model; test a blocked input with zero model calls.",
+        "tool_execution": "Trace the actual executor. Authorize the exact final tool name and arguments immediately before it; test BLOCKED = zero handler calls and ALLOWED = one.",
+        "output_egress": "Trace the return to the external response, stream or persistence boundary. Review or redact there, and test that the released value—not merely an internal value—is safe.",
+        "unknown": "Trace this path and identify its real boundary before claiming protection.",
+    }
+    lines = [
+        "# AgenticDome guided reconciliation", "",
+        "This is a local, source-free worklist for the current validation run. It is not a bypass waiver, a code patch, or live tenant proof.",
+        "The AI-authored AgenticDome_Integration.md remains an assertion until these checks and real-path tests pass.", "",
+        f"- AI report SHA-256: `{report_digest}`",
+        f"- Action-required candidates: {int(gate.get('unresolved_bypasses', 0))}",
+        f"- Review-required internal or indirect paths: {int(gate.get('review_required', 0))}",
+        f"- Semantic confidence: {gate.get('confidence', 'unavailable')}", "",
+    ]
+    for field, title in (("bypass_risks", "Action required"), ("review_findings", "Trace and classify")):
+        lines.extend([f"## {title}", ""])
+        found = groups(field)
+        if not found:
+            lines.append("No findings in this category for this run.")
+        for boundary, path, count, positions in found:
+            references = ", ".join(str(number) for number in positions)
+            if count > len(positions):
+                references += ", …"
+            lines.extend([
+                f"### {boundary} · `{path}` ({count} location{'s' if count != 1 else ''})",
+                f"Lines: {references}. {guidance[boundary]}", "",
+            ])
+        lines.append("")
+    tests = verification.get("application_tests") if isinstance(verification.get("application_tests"), dict) else {}
+    report_scope = verification.get("ai_report_scope") if isinstance(verification.get("ai_report_scope"), dict) else {}
+    lines.extend(["## Finish the reconciliation", ""])
+    if report_scope.get("scope_incomplete") or int(report_scope.get("reported_unprotected", 0)) > 0:
+        lines.append("- The AI report itself says a relevant path was NOT ASSESSED or unprotected. Inspect and protect that path, then update the report; its zero-count rows cannot clear this scope gap.")
+    if plan.get("coverage", {}).get("gaps"):
+        lines.append("- Required boundary categories are missing from the inspected workload. Attach and test them before retrying.")
+    if gate.get("cross_part_review_required"):
+        lines.append("- Analysis was split across parts; trace cross-part calls and alternate entry paths. Separate parts are not a proof of guard dominance.")
+    if tests.get("passed") is not True:
+        lines.append("- Workload tests did not pass or were not detected. Run the local test command directly to see its output; no test log is uploaded.")
+    lines.extend([
+        "- Give these grouped paths to your coding assistant together with the real source. Keep the assistant's changes reviewable and update only the canonical AgenticDome_Integration.md.",
+        "- Rerun `agenticdome validate-report --report AgenticDome_Integration.md` after code and test changes. Do not edit the JSON evidence by hand.",
+        "- Even after local `ready=true`, verify a real action through the assigned tenant sidecar and confirm BLOCKED executes zero times and ALLOWED once before going live.",
+        "",
+    ])
+    return "\n".join(lines)
+
+
 def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int, Dict[str, Any]]:
     """Validate an AI-assisted edit with the existing semantic and test gates.
 
@@ -2497,6 +2691,7 @@ def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int,
     rows = re.findall(r"^\|\s*([1-8])\.([^\r\n]*)", markdown, re.MULTILINE)
     if len(rows) != 8 or {number for number, _ in rows} != {str(index) for index in range(1, 9)}:
         raise SystemExit("The integration report needs one valid row for each of the eight interception categories.")
+    reported_unprotected = 0
     for _, cells_text in rows:
         cells = [cell.strip().replace("*", "").replace(",", "") for cell in cells_text.strip().strip("|").split("|")]
         if len(cells) != 6 or any(not re.fullmatch(r"\d{1,5}", cell) for cell in cells[1:]):
@@ -2504,6 +2699,8 @@ def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int,
         found, existing, new, unprotected, live = (int(cell) for cell in cells[1:])
         if any(value > 10000 for value in (found, existing, new, unprotected, live)) or existing + new + unprotected != found or live > existing + new:
             raise SystemExit("The report counts do not reconcile. Correct the AI integration inventory before validation.")
+        reported_unprotected += unprotected
+    scope_incomplete = bool(re.search(r"\bNOT ASSESSED\b", markdown, re.IGNORECASE))
     digest = hashlib.sha256(markdown.encode("utf-8")).hexdigest()
 
     inspection = _exportable_inspection(inspect_repository(root))
@@ -2519,6 +2716,14 @@ def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int,
     plan = integration_plan(root)
     plan["inspection_report_sha256"] = inspection["report_sha256"]
     exit_code, verification = verify_project(root, run_tests=True, plan=plan)
+    local_checks_passed = exit_code == 0 and verification.get("ready") is True
+    verification["ai_report_scope"] = {
+        "scope_incomplete": scope_incomplete,
+        "reported_unprotected": reported_unprotected,
+    }
+    if scope_incomplete or reported_unprotected:
+        verification["ready"] = False
+        exit_code = 2
     verification["ai_integration_report_sha256"] = digest
     verification.pop("report_sha256", None)
     verification["report_sha256"] = hashlib.sha256(
@@ -2527,18 +2732,34 @@ def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int,
 
     inspection_path = root / "agenticdome-inspection.json"
     verification_path = root / ".agenticdome" / "verification.json"
-    for output in (inspection_path, verification_path):
+    reconciliation_path = root / ".agenticdome" / "RECONCILIATION.md"
+    for output in (inspection_path, verification_path, reconciliation_path):
         if output.is_symlink() or not output.resolve().is_relative_to(root):
             raise SystemExit("An evidence output path is a symlink or leaves this workload; remove that path and retry.")
     _write_json(inspection_path, inspection)
     _write_json(verification_path, verification)
+    _write_local_text(reconciliation_path, _reconciliation_markdown(plan, verification, digest))
+    partial_coverage = local_checks_passed and not verification["ready"]
     return exit_code, {
-        "status": "validation_passed" if verification["ready"] else "validation_needs_attention",
+        "status": "validation_passed" if verification["ready"] else (
+            "partial_coverage" if partial_coverage else "validation_needs_attention"
+        ),
         "inspection": str(inspection_path.relative_to(root)),
         "verification": str(verification_path.relative_to(root)),
+        "reconciliation": str(reconciliation_path.relative_to(root)),
         "ai_integration_report_sha256": digest,
         "ready": verification["ready"],
-        "next_action": "Import both JSON files in Onboarding; then run the assigned-runtime check and test a real action path. No customer action executes in these fixed decision cases.",
+        "next_action": (
+            "Import both JSON files in Onboarding; then run the assigned-runtime check and test a real action path. No customer action executes in these fixed decision cases."
+            if verification["ready"] else (
+                "Import both JSON files as partial evidence and run a tenant-policy diagnostic if connected. "
+                "Open .agenticdome/RECONCILIATION.md, assess or protect the remaining paths, then rerun validate-report. "
+                "This is not passing workload evidence and does not unlock activation."
+                if partial_coverage else
+                "You may import both JSON files as diagnostic evidence, but not as passing evidence. "
+                "Open .agenticdome/RECONCILIATION.md, fix or investigate grouped paths and failing tests, then rerun validate-report."
+            )
+        ),
     }
 
 

{agenticdome_python_sdk-1.2.37 → agenticdome_python_sdk-1.2.39}/docs/customer-onboarding.md

@@ -69,8 +69,17 @@ agenticdome validate-report --report AgenticDome_Integration.md
 
 This does not edit the application. It checks current source-free structure,
 requests the tenant-bound semantic assessment and runs detected workload tests.
-Import both generated files, `agenticdome-inspection.json` and
-`.agenticdome/verification.json`, together in the same onboarding workload.
+The command also writes a local `.agenticdome/RECONCILIATION.md` worklist. If
+it exits non-zero or says `ready=false`, open that file: it groups possible
+bypasses and uncertain internal paths by source file, with the next check for
+each boundary. Review the actual source, fix or investigate those paths, rerun
+the workload tests and validation, and update the canonical AI report. The
+worklist is not uploaded and cannot waive a finding. You may import both
+generated files, `agenticdome-inspection.json` and
+`.agenticdome/verification.json`, together in the same onboarding workload even
+when validation is incomplete. The portal records this as partial evidence and
+can run fixed tenant-policy diagnostics, but it does not grant full verification
+or activation readiness. Rerun and reimport after closing the gaps.
 Their hashes bind them to the exact Markdown report. A changed report requires
 rerunning validation. The portal then performs its separate assigned-runtime
 check; test the actual customer action path before activation. MCP and

{agenticdome_python_sdk-1.2.37 → agenticdome_python_sdk-1.2.39}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agenticdome-python-sdk"
-version = "1.2.37"
+version = "1.2.39"
 description = "Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement."
 readme = "README.md"
 requires-python = ">=3.9"