agenticdome-python-sdk 1.2.40__tar.gz → 1.2.41__tar.gz

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.40
+Version: 1.2.41
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License-Expression: Apache-2.0

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/agenticdome_python_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.40
+Version: 1.2.41
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License-Expression: Apache-2.0

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/agenticdome_python_sdk.egg-info/SOURCES.txt

@@ -45,10 +45,12 @@ agenticdome_sdk/mcp_verification.py
 agenticdome_sdk/microsoft_agent_framework.py
 agenticdome_sdk/microsoft_ai_foundry.py
 agenticdome_sdk/onboarding_cli.py
+agenticdome_sdk/onboarding_observations.py
 agenticdome_sdk/openai_agents.py
 agenticdome_sdk/outcomes.py
 agenticdome_sdk/proof.py
 agenticdome_sdk/pydantic.py
+agenticdome_sdk/report_scope.py
 agenticdome_sdk/simulation.py
 agenticdome_sdk/smolagents.py
 docs/customer-onboarding.md

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/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.40",
+    "python_sdk_version": "1.2.41",
     "published_packages": {
         "agenticdome-python-sdk": {
             "registry": "pypi",
-            "version": "1.2.40",
-            "url": "https://pypi.org/project/agenticdome-python-sdk/1.2.40/"
+            "version": "1.2.41",
+            "url": "https://pypi.org/project/agenticdome-python-sdk/1.2.41/"
         },
         "agenticdome-sdk": {
             "registry": "npm",

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/agenticdome_sdk/connect.py

@@ -253,9 +253,9 @@ def run_connect(root: Path, args: Any) -> Dict[str, Any]:
     broker_setup["sdk_mode"] = effective_config.get("execution_broker_mode", "existing_sdk_or_environment_default")
     cross_part_review_required = semantic.get("workload_coverage", {}).get("cross_part_flow_proven") is False
     next_action = (
-        "Review the generated pull request and run agenticdome verify. Then review cross-part call paths and workload-specific tests in the portal before activation."
+        "Review the generated pull request and run agenticdome verify. Cross-part limitations will be recorded as optional observations in .agenticdome/DISCLAIMER.md; no acknowledgement is required solely for them."
         if args.open_pr else
-        "Review the generated patch, apply it on a branch, and run agenticdome verify. Then review cross-part call paths and workload-specific tests in the portal before activation."
+        "Review the generated patch, apply it on a branch, and run agenticdome verify. Cross-part limitations will be recorded as optional observations in .agenticdome/DISCLAIMER.md; no acknowledgement is required solely for them."
     ) if cross_part_review_required else (
         "Review the generated pull request and run agenticdome verify."
         if args.open_pr else "Review the generated patch, apply it on a branch, then run agenticdome verify."

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/agenticdome_sdk/guided_integration.py

@@ -490,9 +490,10 @@ def preview(root: Path, plan: Optional[Dict[str, Any]] = None, *, target: str =
         + ", A2A " + str(existing.get("a2a_call_candidates", 0))
         + ", MCP " + str(existing_surfaces.get("mcp", 0))
         + " (categories may overlap; no customer action was exercised)",
-        "- Action-required semantic findings: " + str(semantic_gate.get("action_required", "not assessed")),
-        "- Review-required semantic findings: " + str(semantic_gate.get("review_required", "not assessed")),
+        "- Raw semantic action candidates (lower severity may be optional): " + str(semantic_gate.get("action_required", "not assessed")),
+        "- Optional review observations: " + str(semantic_gate.get("review_required", "not assessed")),
         "",
+        "Optional observations are written to .agenticdome/DISCLAIMER.md on verification; high-severity and required protection/test failures remain blocking.", "",
         "## Framework hooks to attach or verify", "",
     ]
     for recommendation in plan.get("hook_recommendations", []):

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/agenticdome_sdk/onboarding_cli.py

@@ -1645,6 +1645,17 @@ def integration_plan(root: Path) -> Dict[str, Any]:
             hook["required_actions"].append("No candidate use of " + hook["recommended_attachment"]["method"] + " was observed in this selected source; attach it at the real execution path or document the external integration.")
     semantic_bypasses = semantic.get("bypass_risks", []) if isinstance(semantic, dict) else []
     semantic_reviews = semantic.get("review_findings", []) if isinstance(semantic, dict) else []
+    from .onboarding_observations import POLICY as observations_policy
+    workload_coverage = semantic.get("workload_coverage", {})
+    assessment_complete = (
+        workload_coverage.get("complete", True) is True
+        and all(item.get("severity") in {"high", "medium", "low"} for item in semantic_bypasses)
+        and workload_coverage.get("portal_display_capped") is not True
+        and not any(item in {"attachment_points", "bypass_risks", "review_findings"}
+                    for item in workload_coverage.get("result_lists_at_cap", []))
+        and (not workload_coverage.get("selected_parts")
+             or workload_coverage.get("selected_parts") == workload_coverage.get("analyzed_parts"))
+    )
     return {
         "schema": "agenticdome.integration-plan.v1",
         "inspection_report_sha256": _exportable_inspection(report).get("report_sha256"),
@@ -1684,10 +1695,12 @@ def integration_plan(root: Path) -> Dict[str, Any]:
             "unresolved_bypasses": len(semantic_bypasses),
             "high_severity_bypasses": sum(1 for item in semantic_bypasses if item.get("severity") == "high"),
             "review_required": len(semantic_reviews),
-            "production_ready": not semantic_bypasses and not semantic_reviews and semantic.get("confidence") in {"high", "partial"}
-            and semantic.get("workload_coverage", {}).get("cross_part_flow_proven", True)
-            and not any(item in {"attachment_points", "bypass_risks", "review_findings"}
-                        for item in semantic.get("workload_coverage", {}).get("result_lists_at_cap", [])),
+            "review_policy": "advisory",
+            "assessment_complete": assessment_complete,
+            "onboarding_policy": observations_policy,
+            "production_ready": not any(item.get("severity") == "high" for item in semantic_bypasses)
+            and semantic.get("confidence") in {"high", "partial"}
+            and assessment_complete,
             "cross_workload_review_required": semantic.get("workload_coverage", {}).get("cross_part_flow_proven") is False,
             "cross_part_edges_observed": int(semantic.get("workload_coverage", {}).get("cross_part_edges", {}).get("observed_count", 0)),
         },
@@ -2498,6 +2511,7 @@ def verify_project(root: Path, live: bool = False, run_tests: bool = False,
                    *, plan: Optional[Dict[str, Any]] = None) -> Tuple[int, Dict[str, Any]]:
     from .client import AgenticDomeClient
     from .action_path_proof import load_action_path_proof
+    from .onboarding_observations import POLICY as observations_policy, observations_summary
 
     plan = plan or integration_plan(root)
     config_path = _agenticdome_dir(root) / "config.json"
@@ -2548,10 +2562,18 @@ def verify_project(root: Path, live: bool = False, run_tests: bool = False,
     }
     semantic_gate = plan.get("semantic_gate", {})
     cross_part_review_required = bool(semantic_gate.get("cross_workload_review_required"))
+    observations = observations_summary(semantic_gate)
+    bypass_rows = plan.get("semantic_analysis", {}).get("bypass_risks", [])
+    if not isinstance(bypass_rows, list) or any(
+        not isinstance(row, dict) or row.get("severity") not in {"high", "medium", "low"}
+        for row in bypass_rows
+    ):
+        observations["classification_complete"] = False
     semantic_ready = (
         semantic_gate.get("confidence") in {"high", "partial"}
-        and int(semantic_gate.get("unresolved_bypasses", 0)) == 0
-        and int(semantic_gate.get("review_required", 0)) == 0
+        and observations["classification_complete"]
+        and int(semantic_gate.get("high_severity_bypasses", 0)) == 0
+        and semantic_gate.get("assessment_complete", True) is True
     )
     result = {
         "schema": "agenticdome.verification-result.v1",
@@ -2559,6 +2581,8 @@ def verify_project(root: Path, live: bool = False, run_tests: bool = False,
         "mode": "live_sidecar_fixed_payload" if live else "local_sim_fixed_payload",
         "source_upload": False,
         "framework_runtime_instantiated": False,
+        "onboarding_policy": observations_policy,
+        "onboarding_observations": observations,
         "decision_cases": outcomes,
         "static_coverage": plan["coverage"],
         "semantic_gate": {
@@ -2569,10 +2593,13 @@ def verify_project(root: Path, live: bool = False, run_tests: bool = False,
             "unresolved_bypasses": int(semantic_gate.get("unresolved_bypasses", 0)),
             "high_severity_bypasses": int(semantic_gate.get("high_severity_bypasses", 0)),
             "review_required": int(semantic_gate.get("review_required", 0)),
+            "review_policy": "advisory",
+            "review_owner": "coding_assistant_or_agenticdome",
+            "assessment_complete": semantic_gate.get("assessment_complete", True) is True,
             "passed": semantic_ready,
             "cross_part_review_required": cross_part_review_required,
             "cross_part_edges_observed": int(semantic_gate.get("cross_part_edges_observed", 0)),
-            "production_ready": semantic_ready and not cross_part_review_required,
+            "production_ready": semantic_ready,
         },
         "application_tests": application_tests,
         "action_path_proof": load_action_path_proof(root),
@@ -2580,17 +2607,39 @@ def verify_project(root: Path, live: bool = False, run_tests: bool = False,
             and not plan["coverage"]["gaps"]
             and (not run_tests or semantic_ready)
             and (not run_tests or application_tests["passed"] is True),
-        "clarification": "Decision cases use fixed payloads. ready=true means local checks passed, not production approval. Split analyses also require a tenant-admin review of cross-part paths, workload-specific integration tests and live runtime evidence; dynamic paths remain outside static proof.",
+        "clarification": "ready=true means required local checks passed, not production activation. Lower-severity static candidates, reviews and cross-part limitations are optional observations in .agenticdome/DISCLAIMER.md. High-severity findings, incomplete source, missing protection, failing tests and runtime proof failures remain blocking. Fixed decision cases do not execute customer actions.",
     }
     canonical = json.dumps(result, sort_keys=True, separators=(",", ":")).encode("utf-8")
     result["report_sha256"] = hashlib.sha256(canonical).hexdigest()
+    _write_onboarding_disclaimer(root, plan, result)
     return (0 if result["ready"] else 2), result
 
 
+def _write_onboarding_disclaimer(root: Path, plan: Dict[str, Any], verification: Dict[str, Any],
+                                 *, evidence_status: str = "Current local verification") -> None:
+    from .onboarding_observations import FILE, disclaimer_markdown
+    target = root / FILE
+    if target.is_symlink() or not target.resolve().is_relative_to(root.resolve()):
+        raise SystemExit("The disclaimer output is a symlink or leaves this workload; use a regular local output path.")
+    # Reject symlinked ancestors even when they happen to point inside the root.
+    if any(parent.is_symlink() for parent in target.parents if parent != root and root in parent.parents):
+        raise SystemExit("The disclaimer output directory is a symlink; use a regular local output path.")
+    _write_local_text(target, disclaimer_markdown(plan, verification, evidence_status=evidence_status))
+
+
 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 {}
+    from .onboarding_observations import POLICY as observations_policy
+    bypass_rows = semantic.get("bypass_risks", [])
+    known_severities = isinstance(bypass_rows, list) and all(
+        isinstance(row, dict) and row.get("severity") in {"high", "medium", "low"}
+        for row in bypass_rows
+    )
+    optional_policy = (verification.get("onboarding_policy") == observations_policy
+                       and verification.get("onboarding_observations", {}).get("classification_complete") is True
+                       and known_severities)
 
     def groups(field: str) -> List[Tuple[str, str, int, List[int]]]:
         grouped: Dict[Tuple[str, str], List[int]] = {}
@@ -2598,6 +2647,8 @@ def _reconciliation_markdown(plan: Dict[str, Any], verification: Dict[str, Any],
         for item in rows[:100]:
             if not isinstance(item, dict):
                 continue
+            if optional_policy and field == "bypass_risks" and item.get("severity") != "high":
+                continue
             boundary = str(item.get("boundary") or "unknown")
             if boundary not in {"prompt_ingress", "tool_execution", "output_egress"}:
                 boundary = "unknown"
@@ -2627,11 +2678,16 @@ def _reconciliation_markdown(plan: Dict[str, Any], verification: Dict[str, Any],
         "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"- Blocking findings: {int(gate.get('high_severity_bypasses' if optional_policy else 'unresolved_bypasses', 0))}",
+        f"- Advisory internal or indirect paths: {int(gate.get('review_required', 0))} (owner: coding assistant or AgenticDome; not a local readiness blocker)",
         f"- Semantic confidence: {gate.get('confidence', 'unavailable')}", "",
+        "## Who does what", "",
+        "The coding assistant traces grouped code candidates and runs real-path tests. The customer reviews the change summary, intended routes and deployment location—not scanner line numbers.",
+        "Lower-severity candidates and review notes are optional tenant observations in .agenticdome/DISCLAIMER.md. They do not require an acknowledgement or AgenticDome clearance before onboarding continues." if optional_policy else "If an action-required candidate is already protected in a real-path test, supply a minimal reproduction to AgenticDome. Stop unchanged retries; do not add duplicate guards or waive the finding.",
+        "Pending deployment settings and live proof belong to the service operator and are separate from optional observations.", "",
     ]
-    for field, title in (("bypass_risks", "Action required"), ("review_findings", "Trace and classify")):
+    sections = (("bypass_risks", "Action required"),) if optional_policy else (("bypass_risks", "Action required"), ("review_findings", "Trace and classify"))
+    for field, title in sections:
         lines.extend([f"## {title}", ""])
         found = groups(field)
         if not found:
@@ -2652,10 +2708,14 @@ def _reconciliation_markdown(plan: Dict[str, Any], verification: Dict[str, Any],
         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"):
+    if gate.get("assessment_complete") is False or not known_severities:
+        lines.append("- Source assessment or severity classification is incomplete. The coding assistant must resolve that required check; unclassified candidates are not optional observations.")
+    if gate.get("cross_part_review_required") and not optional_policy:
         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.")
+    if report_scope.get("activation_pending"):
+        lines.append("- Local source assessment and operator activation are separate. Complete the report's exact runtime handoff and safe staging proof before production activation.")
     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.",
@@ -2688,7 +2748,19 @@ def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int,
     scope = (quoted.group(1) if quoted else scope_match.group(1).split()[0]).strip().rstrip("/")
     if Path(scope).name.casefold() != root.name.casefold() or ".." in Path(scope).parts:
         raise SystemExit("The report's Workload scope does not match this workload root. Run from the correct deployable service.")
-    rows = re.findall(r"^\|\s*([1-8])\.([^\r\n]*)", markdown, re.MULTILINE)
+    # Numbered operator steps are not interception categories. Older reports
+    # without a table heading remain readable, with the original strict counts.
+    inventory_lines = []
+    has_header = bool(re.search(r"^\s*\|\s*Category\s*\|", markdown, re.MULTILINE))
+    in_inventory = not has_header
+    for line in markdown.splitlines():
+        if has_header and not line.lstrip().startswith("|"):
+            in_inventory = False
+        if re.match(r"^\s*\|\s*Category\s*\|", line):
+            in_inventory = True
+        if in_inventory:
+            inventory_lines.append(line)
+    rows = re.findall(r"^\s*\|\s*\*?\*?([1-8])\.([^\r\n]*)", "\n".join(inventory_lines), 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
@@ -2700,7 +2772,9 @@ def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int,
         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))
+    from .report_scope import assessment_scope
+    report_scope = assessment_scope(markdown)
+    scope_incomplete = report_scope["scope_incomplete"]
     digest = hashlib.sha256(markdown.encode("utf-8")).hexdigest()
 
     inspection = _exportable_inspection(inspect_repository(root))
@@ -2719,6 +2793,7 @@ def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int,
     local_checks_passed = exit_code == 0 and verification.get("ready") is True
     verification["ai_report_scope"] = {
         "scope_incomplete": scope_incomplete,
+        "activation_pending": report_scope["activation_pending"],
         "reported_unprotected": reported_unprotected,
     }
     if scope_incomplete or reported_unprotected:
@@ -2739,18 +2814,25 @@ def validate_ai_integration_report(root: Path, report_path: Path) -> Tuple[int,
     _write_json(inspection_path, inspection)
     _write_json(verification_path, verification)
     _write_local_text(reconciliation_path, _reconciliation_markdown(plan, verification, digest))
+    _write_onboarding_disclaimer(root, plan, verification)
+    has_observations = int(verification.get("onboarding_observations", {}).get("total_count", 0)) > 0
     partial_coverage = local_checks_passed and not verification["ready"]
     return exit_code, {
-        "status": "validation_passed" if verification["ready"] else (
+        "status": ("validation_passed_with_observations" if has_observations else "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)),
+        "disclaimer": ".agenticdome/DISCLAIMER.md",
+        "optional_observations": int(verification.get("onboarding_observations", {}).get("total_count", 0)),
         "ai_integration_report_sha256": digest,
         "ready": verification["ready"],
+        "local_status": ("passed_with_observations" if has_observations else "passed") if verification["ready"] else "needs_code_or_test_fix",
+        "activation_status": "pending_operator_checks",
+        "review_owner": "coding_assistant_or_agenticdome",
         "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."
+            "Import both JSON files and continue tenant verification. Optional observations are in .agenticdome/DISCLAIMER.md; investigating them is the tenant's choice. Prove a safe real action before production activation."
             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. "

agenticdome_python_sdk-1.2.41/agenticdome_sdk/onboarding_observations.py

@@ -0,0 +1,74 @@
+"""Optional static observations, separate from runtime enforcement and proof."""
+
+import re
+from pathlib import Path
+
+
+POLICY = "pass_with_observations_v1"
+SCHEMA = "agenticdome.onboarding-observations.v1"
+FILE = ".agenticdome/DISCLAIMER.md"
+
+
+def observations_summary(gate):
+    names = ("action_required", "unresolved_bypasses", "review_required", "high_severity_bypasses")
+    values = {name: gate.get(name, 0) for name in names}
+    valid = "high_severity_bypasses" in gate and all(
+        isinstance(value, int) and not isinstance(value, bool) and 0 <= value <= 10000
+        for value in values.values()
+    )
+    counts = {name: value if isinstance(value, int) and not isinstance(value, bool) and 0 <= value <= 10000 else 0
+              for name, value in values.items()}
+    actions = max(counts["action_required"], counts["unresolved_bypasses"])
+    high = counts["high_severity_bypasses"]
+    valid = valid and high <= actions
+    candidates = max(0, actions - high)
+    cross_part = bool(gate.get("cross_part_review_required") or gate.get("cross_workload_review_required"))
+    return {
+        "schema": SCHEMA, "policy": POLICY, "file": FILE,
+        "classification_complete": valid,
+        "candidate_count": candidates, "review_count": counts["review_required"],
+        "cross_part_note": cross_part,
+        "total_count": candidates + counts["review_required"] + int(cross_part),
+    }
+
+
+def disclaimer_markdown(plan, verification, *, evidence_status="Current local verification"):
+    gate = verification.get("semantic_gate", {})
+    observations = verification.get("onboarding_observations") or observations_summary(gate)
+    semantic = plan.get("semantic_analysis", {})
+    lines = [
+        "# AgenticDome onboarding observations and disclaimer", "",
+        f"Evidence status: {evidence_status}", "",
+        "These observations are optional. The tenant may investigate or improve these paths later; no acknowledgement or AgenticDome clearance is required to continue onboarding solely because of these observations.",
+        "Passing local checks does not certify every execution branch or activate production. High-severity bypass findings, missing protection, uninspected source, failed tests and runtime/tenant proof failures remain blocking. Runtime BLOCKED decisions, unknown verdicts and policy failures still stop execution.", "",
+        "| Observation | Count | Tenant action |",
+        "|---|---:|---|",
+        f"| Lower-severity analyzer candidates | {observations['candidate_count'] if observations['classification_complete'] else 0} | Optional investigation |",
+        f"| Review-only paths | {observations['review_count']} | Optional investigation |",
+        f"| Cross-part flow not automatically proven | {int(observations['cross_part_note'])} | Optional additional path tests |", "",
+        "## Optional locations", "",
+    ]
+    if not observations["classification_complete"]:
+        lines.extend(["Severity classification is incomplete. Unclassified candidates remain in RECONCILIATION.md for the coding assistant to resolve; they are not optional observations.", ""])
+    for field in ("bypass_risks", "review_findings"):
+        rows = semantic.get(field, [])
+        if not isinstance(rows, list):
+            continue
+        for item in rows[:100]:
+            if not isinstance(item, dict) or (field == "bypass_risks" and (
+                not observations["classification_complete"] or item.get("severity") not in {"medium", "low"}
+            )):
+                continue
+            raw = str(item.get("path") or "")[:500].replace("\\", "/")
+            if not raw or raw.startswith("/") or ".." in Path(raw).parts:
+                location = "[invalid relative path]"
+            else:
+                location = re.sub(r"[^A-Za-z0-9_./ -]", "_", raw)
+            line = item.get("line", 1)
+            line = max(1, min(line, 10000000)) if isinstance(line, int) and not isinstance(line, bool) else 1
+            kind = "analyzer candidate" if field == "bypass_risks" else "review-only path"
+            lines.append(f"- `{location}:{line}` — {kind}; static metadata may not observe an existing shared or downstream guard.")
+    if observations["total_count"] == 0:
+        lines.append("No optional observations in this run.")
+    lines.extend(["", "This file is replaced in place on verification; it is a local note, not a protection certificate or an authorization to execute a business action.", ""])
+    return "\n".join(lines)

agenticdome_python_sdk-1.2.41/agenticdome_sdk/report_scope.py

@@ -0,0 +1,58 @@
+"""Separate current source assessment from historical and operator handoff text.
+
+Markdown remains an assertion; inspection, semantic bypass and test gates still
+run independently. Unknown application read sites remain source gaps.
+"""
+import re
+
+
+OPERATOR_SECTIONS = {
+    "runtime configuration handoff", "must do steps to activate firewall",
+    "activation prerequisites", "production activation",
+}
+HISTORY_SECTIONS = {"preserved historical baseline and unique evidence", "historical evidence"}
+
+
+def assessment_scope(markdown):
+    headings = []
+    source_incomplete = False
+    activation_pending = False
+    source_rows = 0
+    structured = False
+    for line in markdown.splitlines():
+        match = re.match(r"^\s*(#{1,6})\s+(.+?)\s*$", line)
+        if match:
+            level, title = len(match[1]), match[2].casefold()
+            headings = [(depth, name) for depth, name in headings if depth < level]
+            headings.append((level, title))
+            structured = structured or title == "source assessment scope"
+            continue
+        sections = {name for _, name in headings}
+        if sections & HISTORY_SECTIONS:
+            continue
+        cells = [cell.strip().strip("*`").strip() for cell in line.strip().strip("|").split("|")] if line.lstrip().startswith("|") else []
+        if "source assessment scope" in sections and cells:
+            if cells[0].casefold() == "runtime source paths":
+                source_rows += 1
+                source_incomplete |= len(cells) < 2 or cells[1].upper() != "ASSESSED" or bool(re.search(r"\bNOT ASSESSED\b", line, re.I))
+                continue
+            if cells[0].casefold() == "production activation":
+                activation_pending |= len(cells) < 2 or cells[1].upper() != "VERIFIED"
+                continue
+        # A missing code read site is a source defect, even in an operator table.
+        if cells and cells[0].startswith(("AGENTICDOME_", "AGENTIC_ORCHESTRATOR_")):
+            if len(cells) < 2 or re.search(r"NOT ASSESSED|Not found|Unknown", cells[1], re.I):
+                source_incomplete = True
+        not_assessed = bool(re.search(r"\bNOT ASSESSED\b", line, re.I))
+        operator_row = bool(cells and (
+            cells[0].startswith(("AGENTICDOME_", "AGENTIC_ORCHESTRATOR_"))
+            or (len(cells) == 4 and re.match(r"^[1-6]\.", cells[0]))
+        ))
+        if sections & OPERATOR_SECTIONS:
+            activation_pending |= (not_assessed and operator_row) or bool(re.search(r"REQUIRED BEFORE LIVE|LIVE VERIFICATION PENDING|\bPENDING\b", line, re.I))
+            # Arbitrary uninspected source prose cannot be hidden in handoff.
+            source_incomplete |= not_assessed and not operator_row
+        else:
+            source_incomplete |= not_assessed
+    source_incomplete |= structured and source_rows != 1
+    return {"scope_incomplete": bool(source_incomplete), "activation_pending": bool(activation_pending)}

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/docs/customer-onboarding.md

@@ -69,11 +69,10 @@ 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.
-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
+The command replaces a local `.agenticdome/RECONCILIATION.md` worklist in place.
+Give it to your coding assistant. The assistant owns code investigation, repairs
+and tests; you review its short change summary, intended routes and deployment
+location. You do not have to interpret scanner line numbers. High-severity findings, uninspected source, missing hooks and failing tests block local readiness. Lower-severity static candidates and review-only paths are optional tenant observations in `.agenticdome/DISCLAIMER.md`. They do not block onboarding or require an acknowledgement, scanner-count cleanup or AgenticDome clearance. The tenant may investigate these observations later if they wish; no manual source classification is required solely for them. A tested protected path still flagged at lower severity remains an optional observation; add no duplicate guard and do not repeat validation solely to clear it. High-severity findings still need a repair or verified path explanation. 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
@@ -87,6 +86,28 @@ OpenClaw workloads use their specialist onboarding journeys rather than this
 application shortcut. The validation command cannot turn an AI report or a
 fixed synthetic decision into proof that real customer traffic is intercepted.
 
+Record current source scope separately from operator activation:
+
+```markdown
+## Source assessment scope
+
+| Scope | Status | Owner / evidence |
+|---|---|---|
+| Runtime source paths | ASSESSED | Assistant: real routes and tests reviewed |
+| Production activation | PENDING | Service operator: exact runtime handoff |
+```
+
+Use `NOT ASSESSED` for genuinely uninspected current source; it still blocks.
+Known application read sites with pending running-process configuration checks
+belong in `Runtime configuration handoff`; numbered operator steps belong in
+`MUST Do Steps to Activate Firewall`. Their pending status is tracked separately
+as `ai_report_scope.activation_pending`. An unknown code read site or uninspected
+source prose cannot be hidden in an operator section. Retain old evidence under
+`Preserved historical baseline and unique evidence`; do not append another full
+report on each run. `ready=true` means required local checks passed; `onboarding_policy=pass_with_observations_v1` keeps raw finding counts and reports optional totals in `onboarding_observations`. Explicit valid high-severity classification is required; absent or malformed counts cannot silently pass. The portal recognizes this policy only in fresh bound evidence; legacy results keep their original strict readiness. The portal retains
+pending deployment checks and tenant verification before activation; no source
+report or SDK import proves that workers loaded the reviewed release.
+
 The local Integration Assistant collects source-free structure and prepares a
 reviewable local diff. Guided `integrate preview` obtains a signed, tenant-bound
 plan through the assigned sidecar; only source-free structural IR reaches the
@@ -132,8 +153,7 @@ parts sequentially through the assigned sidecar. Completed parts are cached
 locally and reused on retry, so a later failure does not restart the entire
 analysis. Each part receives tenant-bound private analysis; the SDK merges the
 results and inventories resolvable calls between parts. This does not prove
-cross-part guard coverage, and the portal requires a documented review of
-those paths and workload-specific tests before marking a split workload ready.
+cross-part guard coverage. With pass_with_observations_v1, that limitation is an optional note in .agenticdome/DISCLAIMER.md and does not require a review form or acknowledgement. Legacy evidence retains its original cross-part review gate. Workload tests and real runtime checks remain required.
 Source text is not uploaded. A plan remains a static proposal, not proof that
 a customer action is intercepted. A single source file over 2 MB or a scope
 that exceeds the collection limits remains an explicit gap; do not exclude a

{agenticdome_python_sdk-1.2.40 → agenticdome_python_sdk-1.2.41}/pyproject.toml

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