@trac3er/oh-my-god 2.1.9 → 2.2.2

package/runtime/compliance_governor.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+import re
 from collections.abc import Mapping
 from typing import Any
 
 from registry.approval_artifact import load_approval_artifact_from_path, verify_approval_artifact
-from registry.verify_artifact import verify_artifact
+from registry.verify_artifact import verify_artifact, verify_tool_attestation
 from runtime.claim_judge import evaluate_claims_for_release
 from runtime.runtime_contracts import read_run_state
 
@@ -17,10 +18,35 @@ _READ_ONLY_TOOL_HINTS = (
     "glob",
     "list",
     "ls",
+)
+_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
+_EXTERNAL_EXECUTION_TOOL_HINTS = (
     "context7",
     "websearch",
+    "web_search",
+    "browser",
+    "playwright",
+    "chrome-devtools",
+)
+_EXTERNAL_BASH_PATTERNS = (
+    re.compile(r"(?:^|[\s;&|()])(curl|wget)\b"),
+    re.compile(r"(?:^|[\s;&|()])(ssh|scp|rsync)\b"),
+    re.compile(r"\bgit\s+(clone|fetch|pull)\b"),
+)
+_MUTATION_BASH_PATTERNS = (
+    r"\b(git\s+(add|commit|push|rebase|cherry-pick|merge|tag))\b",
+    r"\b(rm|mv|cp|tee|touch|mkdir|rmdir|ln)\b",
+    r"\b(sed\s+-i|perl\s+-pi)\b",
+    r"\b(chmod|chown)\b",
+)
+_HARMLESS_REDIRECTION_PATTERNS = (
+    re.compile(r"(?:^|[\s;&|()])\d*>>?\s*/dev/(?:null|stdout|stderr)(?=\s|$)"),
+    re.compile(r"(?:^|[\s;&|()])\d*>&\d+(?=\s|$)"),
+    re.compile(r"(?:^|[\s;&|()])\d*>&-(?=\s|$)"),
+)
+_FILE_WRITE_REDIRECTION_PATTERN = re.compile(
+    r"(?:^|[\s;&|()])\d*>>?(?!\s*(?:/dev/(?:null|stdout|stderr)\b|&\d+\b|&-\b))\s*\S+"
 )
-_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
 
 
 def evaluate_tool_compliance(
@@ -30,18 +56,26 @@ def evaluate_tool_compliance(
     tool: str,
     has_tool_plan: bool,
     clarification_status: dict[str, object] | None = None,
+    tool_input: dict[str, object] | None = None,
 ) -> dict[str, object]:
     clarification = _normalized_clarification_status(clarification_status)
     if clarification["requires_clarification"]:
         reason = _clarification_reason(str(clarification["clarification_prompt"]))
-        if _is_mutation_capable_tool(tool):
+        if _is_mutation_capable_tool(tool, tool_input=tool_input):
             return {
                 "status": "blocked",
                 "authority": "clarification",
                 "reason": reason,
                 "clarification_status": clarification,
             }
-        if _is_read_search_review_tool(tool):
+        if _is_external_execution_tool(tool, tool_input=tool_input):
+            return {
+                "status": "blocked",
+                "authority": "clarification",
+                "reason": _clarification_external_reason(str(clarification["clarification_prompt"])),
+                "clarification_status": clarification,
+            }
+        if _is_read_search_review_tool(tool, tool_input=tool_input):
             return {
                 "status": "allowed",
                 "authority": "clarification",
@@ -128,6 +162,53 @@ def evaluate_release_compliance(
     }
 
 
+def evaluate_governed_tool_request(
+    *,
+    project_dir: str,
+    run_id: str,
+    lane_name: str,
+    tool: str,
+    has_tool_plan: bool,
+    attestation_artifact: dict[str, object] | None,
+    require_attestation: bool,
+    clarification_status: dict[str, object] | None = None,
+) -> dict[str, object]:
+    plan_decision = evaluate_tool_compliance(
+        project_dir=project_dir,
+        run_id=run_id,
+        tool=tool,
+        has_tool_plan=has_tool_plan,
+        clarification_status=clarification_status,
+    )
+    if plan_decision.get("status") == "blocked":
+        return plan_decision
+
+    if not require_attestation:
+        return {
+            "status": "allowed",
+            "authority": "governed_tool",
+            "reason": "compliance checks passed without attestation requirement",
+        }
+
+    attestation_decision = verify_tool_attestation(
+        lane_name=lane_name,
+        tool_name=tool,
+        artifact=attestation_artifact,
+        mode="warn_and_run",
+    )
+    if attestation_decision.get("status") == "blocked":
+        return {
+            "status": "blocked",
+            "authority": "artifact",
+            "reason": str(attestation_decision.get("reason", "attestation required")),
+        }
+    return {
+        "status": "allowed",
+        "authority": "governed_tool",
+        "reason": "compliance checks passed",
+    }
+
+
 _UNVERIFIED_ARTIFACT_STATUSES = frozenset({"pending_verification", "insufficient_evidence", "placeholder"})
 
 
@@ -266,17 +347,73 @@ def _clarification_reason(clarification_prompt: str) -> str:
     return "Clarification required before mutation: provide the missing intent details."
 
 
-def _is_mutation_capable_tool(tool: str) -> bool:
+def _clarification_external_reason(clarification_prompt: str) -> str:
+    prompt = " ".join(str(clarification_prompt or "").split())
+    if prompt:
+        return f"Clarification required before external execution: {prompt}"
+    return "Clarification required before external execution: provide the missing intent details."
+
+
+def classify_bash_command_mode(command: str) -> str:
+    normalized_command = str(command or "").strip()
+    if not normalized_command:
+        return "read"
+    if _is_mutation_capable_bash(normalized_command):
+        return "mutation"
+    lowered = normalized_command.lower()
+    for pattern in _EXTERNAL_BASH_PATTERNS:
+        if pattern.search(lowered):
+            return "external"
+    return "read"
+
+
+def _is_mutation_capable_bash(command: str) -> bool:
+    normalized_command = str(command or "").strip()
+    if not normalized_command:
+        return False
+    lowered = _strip_harmless_redirections(normalized_command.lower())
+    for pattern in _MUTATION_BASH_PATTERNS:
+        if re.search(pattern, lowered):
+            return True
+    if _FILE_WRITE_REDIRECTION_PATTERN.search(lowered):
+        return True
+    return False
+
+
+def _strip_harmless_redirections(command: str) -> str:
+    sanitized = command
+    for pattern in _HARMLESS_REDIRECTION_PATTERNS:
+        sanitized = pattern.sub(" ", sanitized)
+    return re.sub(r"\s+", " ", sanitized).strip()
+
+
+def _is_mutation_capable_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
     token = str(tool or "").strip().lower()
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "mutation"
     if token in _MUTATION_TOOLS:
         return True
-    return token.startswith("bash:")
+    return token == "bash:mutation"
+
+
+def _is_external_execution_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
+    token = str(tool or "").strip().lower()
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "external"
+    if token == "bash:external":
+        return True
+    return any(hint in token for hint in _EXTERNAL_EXECUTION_TOOL_HINTS)
 
 
-def _is_read_search_review_tool(tool: str) -> bool:
+def _is_read_search_review_tool(tool: str, *, tool_input: dict[str, object] | None = None) -> bool:
     token = str(tool or "").strip().lower()
     if not token:
         return False
+    if token == "bash":
+        mode = classify_bash_command_mode(str((tool_input or {}).get("command", "")))
+        return mode == "read"
     return any(hint in token for hint in _READ_ONLY_TOOL_HINTS)
 
 

package/runtime/context_engine.py

@@ -30,6 +30,11 @@ _PROFILE_DIGEST_CONSTRAINT_MAX = 5
 _PACKET_REL_PATH = Path(".omg") / "state" / "context_engine_packet.json"
 _PROFILE_REL_PATH = Path(".omg") / "state" / "profile.yaml"
 _MEMORY_STORE_REL_PATH = Path(".omg") / "state" / "memory.sqlite3"
+_RELEASE_COORDINATOR_REL_BASE = Path(".omg") / "state" / "release_run_coordinator"
+_CONTEXT_PACKET_KIND = "context_engine_v2_packet"
+_CONTEXT_PACKET_SUMMARY = "governed context packet index"
+_PACKET_VERSION = "v2"
+_MAX_PROVENANCE_POINTERS = 24
 
 _STATE_PATHS = {
     "architecture_signal": Path(".omg") / "state" / "architecture_signal" / "latest.json",
@@ -199,6 +204,49 @@ def _clean_single_line(value: object) -> str:
     return " ".join(str(value).strip().split())
 
 
+def _extract_clarification(data_or_state: object) -> dict[str, Any]:
+    source: dict[str, Any] = {}
+    if isinstance(data_or_state, dict):
+        clarification_obj = data_or_state.get("clarification_status")
+        intent_gate_obj = data_or_state.get("intent_gate")
+        if isinstance(clarification_obj, dict):
+            source = clarification_obj
+        elif isinstance(intent_gate_obj, dict):
+            source = intent_gate_obj
+        else:
+            source = data_or_state
+
+    prompt = _clean_single_line(source.get("clarification_prompt", ""))
+    try:
+        confidence = float(source.get("confidence", 0.0))
+    except (TypeError, ValueError):
+        confidence = 0.0
+
+    slots_candidate = source.get("missing_slots")
+    missing_slots_raw = slots_candidate if isinstance(slots_candidate, list) else []
+    missing_slots: list[str] = []
+    for raw_slot in missing_slots_raw:
+        slot = _clean_single_line(raw_slot)[:32]
+        if not slot:
+            continue
+        missing_slots.append(slot)
+        if len(missing_slots) >= 6:
+            break
+
+    requires_clarification = bool(source.get("requires_clarification") is True)
+    unresolved = requires_clarification or bool(missing_slots)
+    return {
+        "requires_clarification": requires_clarification,
+        "intent_class": str(source.get("intent_class", "")).strip()[:48],
+        "clarification_prompt": prompt[:_MAX_CLARIFICATION_PROMPT_CHARS],
+        "confidence": round(max(0.0, min(1.0, confidence)), 2),
+        "missing_slots": missing_slots,
+        "updated_at": str(source.get("updated_at", "")).strip()[:48],
+        "status": "unresolved" if unresolved else "resolved",
+        "unresolved": unresolved,
+    }
+
+
 def _resolve_profile_confidence(
     profile: dict[str, Any],
     user_vector: dict[str, Any],
@@ -272,21 +320,51 @@ class ContextEngine:
     # ------------------------------------------------------------------
 
     def _build(self, run_id: str, *, delta_only: bool) -> dict[str, Any]:
-        raw = self._read_all_state(run_id)
-        artifact_pointers = self._collect_artifact_pointers(run_id)
-        artifact_handles = self._collect_artifact_handles(run_id)
-
-        if not artifact_pointers and not artifact_handles and all(v == {} for v in raw.values()):
-            pkt = self._fallback(run_id)
+        profile_digest = load_profile_digest(self.project_dir)
+        profile_id_raw = str(profile_digest.get("profile_version", "")).strip()
+        profile_id = profile_id_raw if profile_id_raw else None
+
+        coordinator_run_id = self._resolve_coordinator_run_id(run_id)
+        scoped_run_id = coordinator_run_id or run_id
+
+        raw = self._read_all_state(scoped_run_id)
+        clarification_status = self._compose_clarification_status(raw)
+        ambiguity_state = self._compose_ambiguity_state(raw)
+        provenance_only = bool(ambiguity_state.get("unresolved") is True)
+
+        release_metadata, release_pointers = self._compose_release_metadata(scoped_run_id)
+        artifact_pointers = self._collect_artifact_pointers(scoped_run_id)
+        provenance_pointers = self._merge_provenance_pointers(artifact_pointers, release_pointers)
+        artifact_handles = self._collect_artifact_handles(scoped_run_id, profile_id=profile_id)
+
+        if (
+            not provenance_pointers
+            and not artifact_handles
+            and all(v == {} for v in raw.values())
+            and not release_metadata
+        ):
+            pkt = self._fallback(run_id, coordinator_run_id=coordinator_run_id)
             pkt["delta_only"] = delta_only
-            pkt["profile_digest"] = load_profile_digest(self.project_dir)
+            pkt["profile_digest"] = profile_digest
             self._persist_packet(pkt)
+            self._index_governed_packet(pkt, scoped_run_id=scoped_run_id, profile_id=profile_id)
             return pkt
 
-        summary = self._compose_summary(raw)
-        current_snapshot = self._snapshot_key(raw)
-
-        if delta_only and self._last_snapshot is not None:
+        summary = (
+            self._provenance_only_summary(clarification_status)
+            if provenance_only
+            else self._compose_summary(raw)
+        )
+        current_snapshot = self._snapshot_key(
+            {
+                **raw,
+                "_release_metadata": release_metadata,
+                "_ambiguity_state": ambiguity_state,
+                "_provenance_only": provenance_only,
+            }
+        )
+
+        if delta_only and self._last_snapshot is not None and not provenance_only:
             changed_keys: list[str] = []
             for key in current_snapshot:
                 if current_snapshot.get(key) != self._last_snapshot.get(key):
@@ -295,16 +373,23 @@ class ContextEngine:
             if not changed_keys:
                 summary = "no changes since last packet"
                 artifact_pointers = []
+                provenance_pointers = []
 
         self._last_snapshot = current_snapshot
 
         packet: dict[str, Any] = {
+            "packet_version": _PACKET_VERSION,
             "summary": summary,
             "artifact_pointers": artifact_pointers,
+            "provenance_pointers": provenance_pointers,
             "artifact_handles": artifact_handles,
-            "clarification_status": self._compose_clarification_status(raw),
+            "clarification_status": clarification_status,
+            "ambiguity_state": ambiguity_state,
+            "provenance_only": provenance_only,
             "governance": self._compose_governance(raw),
-            "profile_digest": load_profile_digest(self.project_dir),
+            "release_metadata": release_metadata,
+            "coordinator_run_id": coordinator_run_id,
+            "profile_digest": profile_digest,
             "budget": {
                 "max_chars": _MAX_SUMMARY_CHARS,
                 "used_chars": len(summary),
@@ -313,8 +398,11 @@ class ContextEngine:
             "run_id": run_id,
             "deterministic_contract": build_deterministic_contract(run_id),
         }
+        if not provenance_only:
+            packet["derived_action_summary"] = summary
 
         self._persist_packet(packet)
+        self._index_governed_packet(packet, scoped_run_id=scoped_run_id, profile_id=profile_id)
         return packet
 
     def _read_all_state(self, run_id: str) -> dict[str, Any]:
@@ -352,24 +440,145 @@ class ContextEngine:
             pointers.append(str(intent_gate_rel))
         return pointers
 
-    def _compose_clarification_status(self, raw: dict[str, Any]) -> dict[str, Any]:
-        intent_gate = raw.get("intent_gate", {})
-        if not isinstance(intent_gate, dict):
-            intent_gate = {}
+    def _resolve_coordinator_run_id(self, run_id: str) -> str:
+        try:
+            module = __import__("runtime.release_run_coordinator", fromlist=["get_active_coordinator_run_id"])
+            resolver = getattr(module, "get_active_coordinator_run_id", None)
+            if callable(resolver):
+                active_run_id = resolver(str(self.project_dir))
+                if isinstance(active_run_id, str) and active_run_id.strip():
+                    return active_run_id.strip()
+        except Exception:
+            pass
+        return run_id
+
+    def _compose_release_metadata(self, run_id: str) -> tuple[dict[str, Any], list[str]]:
+        run_token = str(run_id).strip()
+        if not run_token:
+            return {}, []
+
+        state_rel = _RELEASE_COORDINATOR_REL_BASE / f"{run_token}.json"
+        evidence_rel = _RELEASE_COORDINATOR_REL_BASE / f"{run_token}-release-evidence.json"
+        council_rel = _RELEASE_COORDINATOR_REL_BASE / run_token / "council.json"
+        rollback_rel = _RELEASE_COORDINATOR_REL_BASE / run_token / "rollback.json"
+
+        pointers: list[str] = []
+        for rel_path in (state_rel, evidence_rel, council_rel, rollback_rel):
+            if (self.project_dir / rel_path).exists():
+                pointers.append(str(rel_path))
+
+        state_payload = self._read_json(self.project_dir / state_rel)
+        evidence_payload = self._read_json(self.project_dir / evidence_rel)
+        if not state_payload and not evidence_payload and not pointers:
+            return {}, []
+
+        evidence_links_obj = state_payload.get("evidence_links")
+        evidence_links = evidence_links_obj if isinstance(evidence_links_obj, list) else []
+        claims_obj = evidence_payload.get("claims")
+        claims = claims_obj if isinstance(claims_obj, list) else []
+        artifact_obj = evidence_payload.get("artifact")
+        artifact = artifact_obj if isinstance(artifact_obj, dict) else {}
+        attestation_obj = artifact.get("attestation")
+
+        metadata = {
+            "run_id": str(state_payload.get("run_id", run_token)).strip(),
+            "status": str(state_payload.get("status", "")).strip()[:24],
+            "phase": str(state_payload.get("phase", "")).strip()[:24],
+            "resolution_source": str(state_payload.get("resolution_source", "")).strip()[:24],
+            "resolution_reason": str(state_payload.get("resolution_reason", "")).strip()[:80],
+            "health_action": str(state_payload.get("health_action", "")).strip()[:48],
+            "compliance_authority": str(state_payload.get("compliance_authority", "")).strip()[:48],
+            "compliance_reason": str(state_payload.get("compliance_reason", "")).strip()[:120],
+            "evidence_links_count": len(evidence_links),
+            "claim_count": len(claims),
+            "has_release_evidence": bool(evidence_payload),
+            "artifact_attested": isinstance(attestation_obj, dict),
+        }
+        return metadata, pointers
+
+    def _merge_provenance_pointers(self, pointers: list[str], release_pointers: list[str]) -> list[str]:
+        merged: list[str] = []
+        seen: set[str] = set()
+        for raw_pointer in [*pointers, *release_pointers]:
+            pointer = str(raw_pointer).strip()
+            if not pointer or pointer in seen:
+                continue
+            seen.add(pointer)
+            merged.append(pointer)
+            if len(merged) >= _MAX_PROVENANCE_POINTERS:
+                break
+        return merged
+
+    def _compose_ambiguity_state(self, raw: dict[str, Any]) -> dict[str, Any]:
+        clarification = _extract_clarification(raw)
+        return {
+            "status": str(clarification.get("status", "resolved")),
+            "unresolved": bool(clarification.get("unresolved") is True),
+            "requires_clarification": bool(clarification.get("requires_clarification") is True),
+            "missing_slots": list(clarification.get("missing_slots", [])),
+            "updated_at": str(clarification.get("updated_at", "")).strip()[:48],
+        }
+
+    def _provenance_only_summary(self, clarification_status: dict[str, Any]) -> str:
+        intent_class = str(clarification_status.get("intent_class", "")).strip()
+        if intent_class:
+            return f"clarification pending for intent={intent_class}; provenance-only packet"[:_MAX_SUMMARY_CHARS]
+        return "clarification pending; provenance-only packet"
+
+    def _index_governed_packet(self, packet: dict[str, Any], *, scoped_run_id: str, profile_id: str | None) -> None:
+        run_token = str(scoped_run_id).strip()
+        if not run_token:
+            return
+
+        clarification_obj = packet.get("clarification_status")
+        clarification = clarification_obj if isinstance(clarification_obj, dict) else {}
+        release_obj = packet.get("release_metadata")
+        release_metadata = release_obj if isinstance(release_obj, dict) else {}
+
+        metadata: dict[str, Any] = {
+            "packet_version": str(packet.get("packet_version", "")).strip(),
+            "coordinator_run_id": str(packet.get("coordinator_run_id", "")).strip(),
+            "provenance_only": bool(packet.get("provenance_only") is True),
+            "artifact_pointer_count": len(packet.get("artifact_pointers", [])) if isinstance(packet.get("artifact_pointers"), list) else 0,
+            "provenance_pointer_count": len(packet.get("provenance_pointers", [])) if isinstance(packet.get("provenance_pointers"), list) else 0,
+            "artifact_handle_count": len(packet.get("artifact_handles", [])) if isinstance(packet.get("artifact_handles"), list) else 0,
+            "requires_clarification": bool(clarification.get("requires_clarification") is True),
+            "intent_class": str(clarification.get("intent_class", "")).strip()[:48],
+            "release_phase": str(release_metadata.get("phase", "")).strip()[:24],
+            "release_status": str(release_metadata.get("status", "")).strip()[:24],
+        }
 
-        prompt = str(intent_gate.get("clarification_prompt", "")).strip().replace("\n", " ")
-        confidence_raw = intent_gate.get("confidence", 0.0)
         try:
-            confidence = float(confidence_raw)
-        except (TypeError, ValueError):
-            confidence = 0.0
-        confidence = max(0.0, min(1.0, confidence))
+            store = MemoryStore(store_path=str(self.project_dir / _MEMORY_STORE_REL_PATH))
+            scoped_profile_id = str(profile_id or "")
+            existing = store.query_artifacts(
+                run_id=run_token,
+                profile_id=scoped_profile_id or None,
+                kind=_CONTEXT_PACKET_KIND,
+                limit=1,
+            )
+            if existing:
+                store.close()
+                return
+            store.index_artifact(
+                run_id=run_token,
+                profile_id=scoped_profile_id,
+                kind=_CONTEXT_PACKET_KIND,
+                path=str(_PACKET_REL_PATH),
+                summary=_CONTEXT_PACKET_SUMMARY,
+                metadata=metadata,
+            )
+            store.close()
+        except Exception:
+            pass
 
+    def _compose_clarification_status(self, raw: dict[str, Any]) -> dict[str, Any]:
+        clarification = _extract_clarification(raw)
         return {
-            "requires_clarification": bool(intent_gate.get("requires_clarification") is True),
-            "intent_class": str(intent_gate.get("intent_class", "")).strip()[:48],
-            "clarification_prompt": prompt[:_MAX_CLARIFICATION_PROMPT_CHARS],
-            "confidence": round(confidence, 2),
+            "requires_clarification": bool(clarification.get("requires_clarification") is True),
+            "intent_class": str(clarification.get("intent_class", "")).strip()[:48],
+            "clarification_prompt": str(clarification.get("clarification_prompt", "")).strip()[:_MAX_CLARIFICATION_PROMPT_CHARS],
+            "confidence": round(float(clarification.get("confidence", 0.0)), 2),
         }
 
     def _compose_governance(self, raw: dict[str, Any]) -> dict[str, Any]:
@@ -450,10 +659,12 @@ class ContextEngine:
         except Exception:
             pass  # crash isolation
 
-    def _fallback(self, run_id: str) -> dict[str, Any]:
+    def _fallback(self, run_id: str, *, coordinator_run_id: str = "") -> dict[str, Any]:
         return {
+            "packet_version": _PACKET_VERSION,
             "summary": "no context signals available",
             "artifact_pointers": [],
+            "provenance_pointers": [],
             "artifact_handles": [],
             "clarification_status": {
                 "requires_clarification": False,
@@ -461,7 +672,17 @@ class ContextEngine:
                 "clarification_prompt": "",
                 "confidence": 0.0,
             },
+            "ambiguity_state": {
+                "status": "resolved",
+                "unresolved": False,
+                "requires_clarification": False,
+                "missing_slots": [],
+                "updated_at": "",
+            },
+            "provenance_only": False,
             "governance": {},
+            "release_metadata": {},
+            "coordinator_run_id": coordinator_run_id,
             "profile_digest": _empty_profile_digest(),
             "budget": {"max_chars": _MAX_SUMMARY_CHARS, "used_chars": 0},
             "delta_only": False,
@@ -469,11 +690,19 @@ class ContextEngine:
             "deterministic_contract": build_deterministic_contract(run_id),
         }
 
-    def _collect_artifact_handles(self, run_id: str) -> list[dict[str, Any]]:
+    def _collect_artifact_handles(self, run_id: str, *, profile_id: str | None = None) -> list[dict[str, Any]]:
+        run_token = str(run_id).strip()
+        if not run_token:
+            return []
         try:
-            profile_id_raw = str(load_profile_digest(self.project_dir).get("profile_version", "")).strip()
-            profile_id = profile_id_raw if profile_id_raw else None
+            profile_id_raw = str(profile_id or "").strip()
+            if not profile_id_raw:
+                digest_profile_id = str(load_profile_digest(self.project_dir).get("profile_version", "")).strip()
+                profile_id_raw = digest_profile_id
+            scoped_profile_id = profile_id_raw if profile_id_raw else None
             store = MemoryStore(store_path=str(self.project_dir / _MEMORY_STORE_REL_PATH))
-            return store.query_artifacts(run_id=run_id, profile_id=profile_id)
+            handles = store.query_artifacts(run_id=run_token, profile_id=scoped_profile_id)
+            store.close()
+            return handles
         except Exception:
             return []